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);
 
  CreateMooseEnumClass(WeightingType, AVERAGE);
 
  virtual Real solutionSampleTime() = 0;
 
  virtual void timestepSetup() override;
 
  unsigned int getLocalVarIndex(const std::string & var_name) 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;
 
  Real pointValue(Real t,
                  const Point & p,
                  const std::string & var_name,
                  WeightingType weighting_type,
                  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
  pointValueGradient(Real t,
                     const Point & p,
                     const std::string & var_name,
                     WeightingType weighting_type,
                     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(getWeightingTypeOptions()); }
 
  bool isVariableScalarValued(const std::string & var_name) const;
 
  bool isVariableADiscontinuousScalarField(const std::string & var_name) const;
 
  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;
 
  bool initialized() const { return _initialized; }
 
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:
  bool isVariableScalarValued(unsigned int local_var_index) const;
 
  static Threads::spin_mutex _solution_user_object_mutex;
};