MatOps.hpp

Go to the documentation of this file.

/**
 * \file MatOps.hpp
 * \example mofem/src/materials/MatOps.hpp
 *
 * @copyright Copyright (c) 2023
 */
 
#ifndef __MAT_OPS_HPP__
#define __MAT_OPS_HPP__
 
namespace MatOps {
 
// One valid tag-info type for addTagDGProjectionOps(...).
// Equivalent to std::tuple<std::string, Tag, int>.
struct StateTag {
  std::string name;
  Tag tag = 0;
  int numComponents = 0;
};
 
using StateTags = std::vector<StateTag>;
using DataDictionary = std::map<std::string, std::string>;
 
struct MatOpsTagsRegistry {
 
  static int atTagName(std::string name);
  static int setTagName(std::string name, int tag = -1);
  static std::string getTagName(int tag);
 
protected:
  static int getTagByName(std::string name);
  static inline std::map<std::string, int> tagNameVsTag;
};
 
/** \name MatOps Data Interface */
/**@{*/
struct MatOpsData : public boost::enable_shared_from_this<MatOpsData> {
  virtual ~MatOpsData() = default;
 
  using MatrixPtr = boost::shared_ptr<MatrixDouble>;
  using StateMatrixPtr = boost::shared_ptr<MatrixAdaptor>;
 
  /// Base for user-defined material data, supporting dynamic_pointer_cast.
  struct UserData {
    virtual ~UserData() = default;
  };
 
  /// Get the optional user-defined material data.
  virtual boost::shared_ptr<UserData> getUserDataPtr() const = 0;
 
  /// Set data owned by this container; back-references should be weak.
  virtual void setUserDataPtr(boost::shared_ptr<UserData> user_data_ptr) = 0;
 
  virtual std::pair<bool, MatrixPtr>
  insertCommonData(const std::string &name,
                   const MatrixDouble &data = MatrixDouble(),
                   int shift = 0) = 0;
 
  virtual std::pair<bool, MatrixPtr>
  insertActiveData(const std::string &name,
                   const MatrixDouble &data = MatrixDouble(),
                   int shift = 0) = 0;
 
  virtual std::pair<bool, MatrixPtr>
  insertDependentData(const std::string &name,
                      const MatrixDouble &data = MatrixDouble(),
                      int shift = 0) = 0;
 
  virtual std::pair<bool, MatrixPtr>
  insertDependentDerivativesData(const std::string &name,
                                 const MatrixDouble &data = MatrixDouble(),
                                 int shift = 0) = 0;
 
  virtual MatrixPtr getCommonDataPtr(const std::string &name) = 0;
  virtual MatrixPtr getActiveDataPtr(const std::string &name) = 0;
  virtual MatrixPtr getDependentDataPtr(const std::string &name) = 0;
  virtual MatrixPtr getDependentDerivativesDataPtr(const std::string &name) = 0;
  /// Start each integration-point sweep at gg == 0 to refresh cached tag storage.
  virtual StateMatrixPtr getStateDataPtr(const std::string &name,
                                         EntityHandle ent, int gg) = 0;
  virtual StateTags getStateTags() const = 0;
 
  virtual MoFEMErrorCode bindStateTag(MoFEM::Interface &m_field,
                                      const std::string &tag_name,
                                      int num_components) = 0;
  virtual MoFEMErrorCode setupStateData() = 0;
 
  virtual MoFEMErrorCode
  setActiveContinuousVector(std::vector<double> &active_variables) = 0;
  virtual MoFEMErrorCode
  setDependentContinuousVector(std::vector<double> &dependent_variables) = 0;
  virtual MoFEMErrorCode setDependentDerivativesContinuousVector(
      std::vector<double> &dependent_variables_derivatives) = 0;
 
  virtual MoFEMErrorCode
  getActiveContinuousVector(const std::vector<double> &active_variables) = 0;
  virtual MoFEMErrorCode getDependentContinuousVector(
      const std::vector<double> &dependent_variables) = 0;
  virtual MoFEMErrorCode getDependentDerivativesContinuousVector(
      const std::vector<double> &dependent_variables_derivatives) = 0;
};
 
/**@}*/
 
/** \name Physical Equation Interface */
/**@{*/
struct AdolCEvaluation {
  static MoFEMErrorCode
  evaluateVariable(boost::shared_ptr<MatOpsData> mat_ops_data_ptr, int tag,
                   EntityHandle entity, int gg);
  static MoFEMErrorCode
  evaluateDerivatives(boost::shared_ptr<MatOpsData> mat_ops_data_ptr, int tag,
                      EntityHandle entity, int gg);
 
private:
  inline static std::vector<double> activeVariables;
  inline static std::vector<double> dependentVariables;
  inline static std::vector<double> dependentVariablesDerivatives;
  inline static std::vector<double *> jacPtrVec;
};
 
struct PhysicalEquations {
 
  PhysicalEquations() = delete;
  PhysicalEquations(
      boost::shared_ptr<MatOpsData> mat_ops_data_ptr, int tag,
      boost::shared_ptr<std::map<int, Range>> tag_vs_range_ptr = nullptr)
      : tAg(tag), tagVsRangePtr(tag_vs_range_ptr),
        matOpsDataPtr(mat_ops_data_ptr) {}
  virtual ~PhysicalEquations() = default;
 
  virtual MoFEMErrorCode
  getOptions(MoFEM::Interface *m_field_ptr = nullptr) = 0;
  virtual MoFEMErrorCode setParams(FEMethod *fe_ptr, int gg) = 0;
  virtual MoFEMErrorCode recordTape() = 0;
  virtual MoFEMErrorCode
  addBlockParameters(MoFEM::Interface &m_field, const std::string &block_name,
                     int block_id, const Range &block_entities,
                     const std::vector<double> &block_data) {
    (void)m_field;
    (void)block_name;
    (void)block_id;
    paramVecByRange.push_back({block_entities, block_data});
    return 0;
  }
 
  virtual ForcesAndSourcesCore::UserDataOperator *
  createOp(boost::shared_ptr<PhysicalEquations> physical_ptr, bool eval_stress,
           bool eval_tangent, bool update) = 0;
 
  using HookFunction = std::function<MoFEMErrorCode(
      boost::shared_ptr<MatOpsData>, int, EntityHandle, int)>;
 
  HookFunction hookEvaluateVariable = AdolCEvaluation::evaluateVariable;
  HookFunction hookEvaluateDerivatives = AdolCEvaluation::evaluateDerivatives;
  HookFunction hookUpdateState = AdolCEvaluation::evaluateVariable;
 
  virtual MoFEMErrorCode evaluateVariable(int tag, EntityHandle entity,
                                          int gg) {
    return hookEvaluateVariable(this->matOpsDataPtr, tag, entity, gg);
  }
 
  virtual MoFEMErrorCode evaluateDerivatives(int tag, EntityHandle entity,
                                             int gg) {
    return hookEvaluateDerivatives(matOpsDataPtr, tag, entity, gg);
  }
 
  virtual MoFEMErrorCode updateState(int tag, EntityHandle entity, int gg) {
    return hookUpdateState(this->matOpsDataPtr, tag, entity, gg);
  }
 
  int tAg;
  boost::shared_ptr<std::map<int, Range>> tagVsRangePtr;
  std::vector<std::pair<Range, std::vector<double>>> paramVecByRange;
 
  boost::shared_ptr<MatOpsData> matOpsDataPtr;
};
 
/**
 * @brief Constitutive response expressed by first Piola stress.
 *
 * Implementations provide the deformation-gradient input, first Piola stress,
 * and its derivative.  This interface does not imply the existence of a stored
 * energy; conservative elastic responses use MatElastic.
 */
struct MatPiolaResponse : public PhysicalEquations {
  using PhysicalEquations::PhysicalEquations;
 
  inline static bool useDeformationGradient =
      false; ///< Otherwise the displacement gradient is supplied and I is added.
};
 
struct MatElastic;
 
/**@}*/
 
/** \name Data Factory */
/**@{*/
boost::shared_ptr<MatOpsData> createMatOpsDataPtr();
boost::shared_ptr<MatOpsData>
createMatOpsDataPtr(boost::weak_ptr<MatOpsData>,
                    DataDictionary common_data_dictionary = {},
                    DataDictionary state_data_dictionary = {});
/**@}*/
 
/** \name Generic Operator Factory */
/**@{*/
enum ModelType {
  MODEL_3D,
  MODEL_2D_PLANE_STRAIN,
  MODEL_2D_PLANE_STRESS,
  MODEL_AXISYMMETRIC
};
 
struct MODEL {
  MODEL() = delete;
};
 
template <class MODEL, int MODEL_TYPE>
boost::shared_ptr<PhysicalEquations>
createMatOpsPhysicalEquationsPtr(boost::shared_ptr<MatOpsData> mat_ops_data_ptr,
                                 int tag);
 
template <class MODEL, int MODEL_TYPE> struct OpMaterialFactory {
  OpMaterialFactory() = delete;
};
/**@}*/
 
} // namespace MatOps
 
#endif // __MAT_OPS_HPP__