AdolCOps.hpp

Go to the documentation of this file.

/**
 * \file AdolCOps.hpp
 * \example mofem/tutorials/vec-2_nonlinear_elasticity/src/AdolCOps.hpp
 *
 * @copyright Copyright (c) 2023
 */
 
#ifndef __ADOLC_OPS_HPP__
#define __ADOLC_OPS_HPP__
 
namespace AdolCOps {
 
struct AdolCTagsRegistry {
 
  static auto atTagName(std::string name) { return tagNameVsTag.at(name); }
  static auto setTagName(std::string name, int tag = -1) {
    MOFEM_LOG_CHANNEL("WORLD");
 
    auto it = tagNameVsTag.find(name);
 
    if (tag >= 0) {
      if (it != tagNameVsTag.end()) {
        MOFEM_LOG("WORLD", Sev::warning)
            << "Tag name: " << name
            << " is already registered with tag: " << it->second
            << ". Overwriting with new tag: " << tag;
        it->second = -1; // set it to invalid value to avoid confusion
      }
      for (auto &p : tagNameVsTag) {
        if (p.second == tag) {
          CHK_THROW_MESSAGE(MOFEM_OPERATION_UNSUCCESSFUL,
                            "Tag: " + std::to_string(tag) +
                                " is already registered with name: " + p.first);
        }
      }
      // register new tag
      tagNameVsTag[name] = tag;
      return tag;
    }
 
    int max_tag = 0;
    for (auto &p : tagNameVsTag) {
      if (p.second > max_tag) {
        max_tag = p.second;
      }
    }
 
    if (it == tagNameVsTag.end()) {
      tagNameVsTag[name] = max_tag + 1;
    }
 
    MOFEM_LOG("WORLD", Sev::inform)
        << "Tag name: " << name
        << " is registered with tag: " << tagNameVsTag[name];
 
    return tagNameVsTag[name];
  }
 
private:
  static int getTagByName(std::string name) {
    auto it = tagNameVsTag.find(name);
    if (it == tagNameVsTag.end()) {
      int new_tag = tagNameVsTag.size() + 1;
      tagNameVsTag[name] = new_tag;
      return new_tag;
    }
    return it->second;
  }
 
  static inline std::map<std::string, int> tagNameVsTag;
};
 
/** \name ADOL-C Data Interface */
/**@{*/
struct ADolCData : public boost::enable_shared_from_this<ADolCData> {
  virtual ~ADolCData() = default;
 
  using MatrixPtr = boost::shared_ptr<MatrixDouble>;
 
  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;
 
  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 PhysicalEquations {
 
  PhysicalEquations() = delete;
  PhysicalEquations(
      boost::shared_ptr<ADolCData> adolc_data_ptr, int tag,
      boost::shared_ptr<std::map<int, Range>> tag_vs_range_ptr = nullptr)
      : adolcDataPtr(adolc_data_ptr), tAg(tag),
        tagVsRangePtr(tag_vs_range_ptr) {}
  virtual ~PhysicalEquations() = default;
 
  virtual MoFEMErrorCode
  getOptions(MoFEM::Interface *m_field_ptr = nullptr) = 0;
  virtual MoFEMErrorCode setParams(EntityHandle ent, int gg) = 0;
  virtual MoFEMErrorCode recordTape() = 0;
 
  virtual ForcesAndSourcesCore::UserDataOperator *
  createOp(boost::shared_ptr<PhysicalEquations> physical_ptr, bool eval_stress,
           bool eval_tangent) = 0;
 
  MoFEMErrorCode setActiveContinuousVector() {
    return adolcDataPtr->setActiveContinuousVector(activeVariables);
  }
  MoFEMErrorCode setDependentContinuousVector() {
    return adolcDataPtr->setDependentContinuousVector(dependentVariables);
  }
  MoFEMErrorCode setDependentDerivativesContinuousVector() {
    return adolcDataPtr->setDependentDerivativesContinuousVector(
        dependentVariablesDerivatives);
  }
  MoFEMErrorCode getActiveContinuousVector() {
    return adolcDataPtr->getActiveContinuousVector(activeVariables);
  }
  MoFEMErrorCode getDependentContinuousVector() {
    return adolcDataPtr->getDependentContinuousVector(dependentVariables);
  }
  MoFEMErrorCode getDependentDerivativesContinuousVector() {
    return adolcDataPtr->getDependentDerivativesContinuousVector(
        dependentVariablesDerivatives);
  }
 
  int tAg;
  boost::shared_ptr<std::map<int, Range>> tagVsRangePtr;
  std::vector<std::pair<Range, std::vector<double>>> paramVecByRange;
 
  boost::shared_ptr<ADolCData> adolcDataPtr;
  std::vector<double> activeVariables;
  std::vector<double> dependentVariables;
  std::vector<double> dependentVariablesDerivatives;
};
/**@}*/
 
/** \name Data Factory */
/**@{*/
boost::shared_ptr<ADolCData> createADolCDataPtr();
/**@}*/
 
/** \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>
createAdolCPhysicalEquationsPtr(boost::shared_ptr<ADolCData> adolc_data_ptr,
                                int tag);
 
template <class MODEL, int MODEL_TYPE> struct OpMaterialFactory {
  OpMaterialFactory() = delete;
};
/**@}*/
 
} // namespace AdolCOps
 
 
#endif // __ADOLC_OPS_HPP__