SolutionUserObjectBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

// MOOSE includes
#include "GeneralUserObject.h"

// Forward declarations
namespace libMesh
{
class ExodusII_IO;
class Nemesis_IO;
class EquationSystems;
class System;
class MeshFunction;
template <class T>
class NumericVector;
}

class SolutionUserObjectBase : public GeneralUserObject
{
public:
  static InputParameters validParams();

  SolutionUserObjectBase(const InputParameters & parameters);

  virtual Real solutionSampleTime() = 0;

  virtual void timestepSetup() override;

  unsigned int getLocalVarIndex(const std::string & var_name) const;

  Real pointValueWrapper(Real t,
                         const Point & p,
                         const std::string & var_name,
                         const MooseEnum & weighting_type = weightingType(),
                         const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  Real pointValue(Real t,
                  const Point & p,
                  const unsigned int local_var_index,
                  const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  Real pointValue(Real t,
                  const Point & p,
                  const std::string & var_name,
                  const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  std::map<const Elem *, Real>
  discontinuousPointValue(Real t,
                          Point pt,
                          const unsigned int local_var_index,
                          const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  std::map<const Elem *, Real>
  discontinuousPointValue(Real t,
                          const Point & p,
                          const std::string & var_name,
                          const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  libMesh::RealGradient
  pointValueGradientWrapper(Real t,
                            const Point & p,
                            const std::string & var_name,
                            const MooseEnum & weighting_type = weightingType(),
                            const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  libMesh::RealGradient
  pointValueGradient(Real t,
                     const Point & p,
                     const std::string & var_name,
                     const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  libMesh::RealGradient
  pointValueGradient(Real t,
                     Point pt,
                     const unsigned int local_var_index,
                     const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  std::map<const Elem *, libMesh::RealGradient> discontinuousPointValueGradient(
      Real t,
      const Point & p,
      const std::string & var_name,
      const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  std::map<const Elem *, libMesh::RealGradient> discontinuousPointValueGradient(
      Real t,
      Point pt,
      const unsigned int local_var_index,
      const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  Real directValue(const Node * node, const std::string & var_name) const;

  Real directValue(const Elem * elem, const std::string & var_name) const;

  Real scalarValue(Real t, const std::string & var_name) const;

  // Required pure virtual function (not used)
  virtual void initialize() override;

  // Required pure virtual function (not used)
  virtual void finalize() override;

  // Required pure virtual function (not used)
  virtual void execute() override;

  virtual void initialSetup() override;

  const std::vector<std::string> & variableNames() const;

  bool isVariableNodal(const std::string & var_name) const;

  static MooseEnum weightingType()
  {
    return MooseEnum("found_first=1 average=2 smallest_element_id=4 largest_element_id=8",
                     "found_first");
  }

  unsigned int getMeshFileDimension() const { return _mesh->spatial_dimension(); }

  const std::string getMeshFileName() const { return _mesh_file; }

  const std::map<SubdomainName, SubdomainID> & getBlockNamesToIds() const
  {
    return _block_name_to_id;
  }

  const std::map<SubdomainID, SubdomainName> & getBlockIdsToNames() const
  {
    return _block_id_to_name;
  }

  MooseEnum getSolutionFileType() const;

protected:
  void readXda();

  void readExodusIIOrNemesis();

  virtual Real directValue(dof_id_type dof_index) const;

  void updateTimeInterpolationFromFile();

  bool updateInterpolationBracketingTimeIndices();

  Real evalMeshFunction(const Point & p,
                        const unsigned int local_var_index,
                        unsigned int func_num,
                        const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  std::map<const Elem *, Real>
  evalMultiValuedMeshFunction(const Point & p,
                              const unsigned int local_var_index,
                              unsigned int func_num,
                              const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  libMesh::RealGradient
  evalMeshFunctionGradient(const Point & p,
                           const unsigned int local_var_index,
                           unsigned int func_num,
                           const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  std::map<const Elem *, libMesh::RealGradient> evalMultiValuedMeshFunctionGradient(
      const Point & p,
      const unsigned int local_var_index,
      unsigned int func_num,
      const std::set<subdomain_id_type> * subdomain_ids = nullptr) const;

  void readBlockIdMapFromExodusII();

  MooseEnum _file_type;

  std::string _mesh_file;

  std::string _es_file;

  std::string _system_name;

  std::vector<std::string> _system_variables;

  std::map<std::string, unsigned int> _local_variable_index;

  std::vector<std::string> _nodal_variables;

  std::vector<std::string> _elemental_variables;

  std::vector<std::string> _scalar_variables;

  int _exodus_time_index;

  bool _interpolate_times;

  std::unique_ptr<libMesh::MeshBase> _mesh;

  std::unique_ptr<libMesh::EquationSystems> _es;

  libMesh::System * _system;

  std::unique_ptr<libMesh::MeshFunction> _mesh_function;

  std::unique_ptr<libMesh::ExodusII_IO> _exodusII_io;

  std::unique_ptr<libMesh::Nemesis_IO> _nemesis_io;

  std::unique_ptr<NumericVector<Number>> _serialized_solution;

  std::unique_ptr<libMesh::EquationSystems> _es2;

  libMesh::System * _system2;

  std::unique_ptr<libMesh::MeshFunction> _mesh_function2;

  std::unique_ptr<NumericVector<Number>> _serialized_solution2;

  Real _interpolation_time;

  Real _interpolation_factor;

  const std::vector<Real> * _exodus_times;

  int _exodus_index1;

  int _exodus_index2;

  const MooseEnum _nodal_variable_order;

  std::vector<Real> _scale;

  std::vector<Real> _scale_multiplier;

  std::vector<Real> _translation;

  RealVectorValue _rotation0_vector;

  Real _rotation0_angle;

  RealTensorValue _r0;

  RealVectorValue _rotation1_vector;

  Real _rotation1_angle;

  RealTensorValue _r1;

  MultiMooseEnum _transformation_order;

  const bool _force_replicated_source;

  bool _initialized;

  std::map<SubdomainName, SubdomainID> _block_name_to_id;

  std::map<SubdomainID, SubdomainName> _block_id_to_name;

  // All the caches are duplicated between the before-timestep and after-timestep mesh functions
  mutable Point _cached_p = Point(std::numeric_limits<Real>::max(), 0., 0.);
  mutable Point _cached_p2 = Point(std::numeric_limits<Real>::max(), 0., 0.);
  mutable std::set<subdomain_id_type> _cached_subdomain_ids;
  mutable std::set<subdomain_id_type> _cached_subdomain_ids2;
  mutable DenseVector<Number> _cached_values;
  mutable DenseVector<Number> _cached_values2;

private:
  static Threads::spin_mutex _solution_user_object_mutex;
};