AdolCElastic.hpp

Go to the documentation of this file.

/**
 * @file AdolCElastic.hpp
 * @brief 
 * @version 0.1
 * @date 2026-04-02
 * 
 * @copyright Copyright (c) 2026
 * 
 */
 
#ifndef ADOLC_OPS_ELEASTIC_HPP
#define ADOLC_OPS_ELEASTIC_HPP
 
namespace AdolCOps {
 
struct ELASTICITY {
  ELASTICITY() = delete;
  // Behaviors
  struct META {};
  struct NEOHOOKEAN {};
  struct VOLUMELENGTHQUALITY {};
};
 
/** \name Elasticity Operator Factory */
/**@{*/
template <int MODEL_TYPE> struct OpMaterialFactory<ELASTICITY, MODEL_TYPE> {
  OpMaterialFactory() = delete;
 
  template <AssemblyType A, IntegrationType I, typename DomainEleOp>
  static MoFEMErrorCode
  opRhsFactory(MoFEM::Interface &m_field,
               boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pip,
               std::string field_name,
               boost::shared_ptr<PhysicalEquations> physical_equations_ptr) {
    MoFEMFunctionBegin;
    constexpr int DIM = (MODEL_TYPE == MODEL_3D) ? 3 : 2;
    using B = typename FormsIntegrators<DomainEleOp>::template Assembly<
        A>::template LinearForm<I>;
    using OpInternalForce = typename B::template OpGradTimesTensor<1, DIM, DIM>;
    auto m_grad =
        physical_equations_ptr->adolcDataPtr->getCommonDataPtr("grad");
    auto m_P = physical_equations_ptr->adolcDataPtr->getCommonDataPtr("P");
    pip.push_back(
        new OpCalculateVectorFieldGradient<DIM, DIM>(field_name, m_grad));
    pip.push_back(
        physical_equations_ptr->createOp(physical_equations_ptr, true, false));
    pip.push_back(new OpInternalForce(field_name, m_P));
    MoFEMFunctionReturn(0);
  }
 
  template <AssemblyType A, IntegrationType I, typename DomainEleOp>
  static MoFEMErrorCode
  opLhsFactory(MoFEM::Interface &m_field,
               boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pip,
               std::string field_name,
               boost::shared_ptr<PhysicalEquations> physical_equations_ptr) {
    MoFEMFunctionBegin;
    constexpr int DIM = (MODEL_TYPE == MODEL_3D) ? 3 : 2;
    using B = typename FormsIntegrators<DomainEleOp>::template Assembly<
        A>::template BiLinearForm<I>;
    using OpKPiola = typename B::template OpGradTensorGrad<1, DIM, DIM, 1>;
    auto m_grad =
        physical_equations_ptr->adolcDataPtr->getCommonDataPtr("grad");
    auto m_P_dF =
        physical_equations_ptr->adolcDataPtr->getCommonDataPtr("P_dF");
    pip.push_back(
        new OpCalculateVectorFieldGradient<DIM, DIM>(field_name, m_grad));
    pip.push_back(
        physical_equations_ptr->createOp(physical_equations_ptr, false, true));
    pip.push_back(new OpKPiola(field_name, field_name, m_P_dF));
    MoFEMFunctionReturn(0);
  }
 
  static MoFEMErrorCode opPostProcFactory(
      MoFEM::Interface &m_field,
      boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pip,
      std::string field_name,
      boost::shared_ptr<PhysicalEquations> physical_equations_ptr) {
    MoFEMFunctionBegin;
    constexpr int DIM = (MODEL_TYPE == MODEL_3D) ? 3 : 2;
    auto m_grad =
        physical_equations_ptr->adolcDataPtr->getCommonDataPtr("grad");
    auto m_P = physical_equations_ptr->adolcDataPtr->getCommonDataPtr("P");
    pip.push_back(
        new OpCalculateVectorFieldGradient<DIM, DIM>(field_name, m_grad));
    pip.push_back(
        physical_equations_ptr->createOp(physical_equations_ptr, true, false));
    MoFEMFunctionReturn(0);
  }
};
/**@}*/
 
/** \name Elasticity Material Models Creators */
/**@{*/
 
template <>
boost::shared_ptr<PhysicalEquations>
createAdolCPhysicalEquationsPtr<ELASTICITY::META, MODEL_3D>(
    boost::shared_ptr<ADolCData> adolc_data_ptr, int tag);
 
template <>
boost::shared_ptr<PhysicalEquations>
createAdolCPhysicalEquationsPtr<ELASTICITY::META, MODEL_2D_PLANE_STRAIN>(
    boost::shared_ptr<ADolCData> adolc_data_ptr, int tag);
 
template <>
boost::shared_ptr<PhysicalEquations>
createAdolCPhysicalEquationsPtr<ELASTICITY::NEOHOOKEAN, MODEL_3D>(
    boost::shared_ptr<ADolCData> adolc_data_ptr, int tag);
 
template <>
boost::shared_ptr<PhysicalEquations>
createAdolCPhysicalEquationsPtr<ELASTICITY::NEOHOOKEAN, MODEL_2D_PLANE_STRAIN>(
    boost::shared_ptr<ADolCData> adolc_data_ptr, int tag);
 
enum VolumeLengthQualityType {
  QUALITY,
  BARRIER_AND_QUALITY,
  BARRIER_AND_CHANGE_QUALITY,
  BARRIER_AND_CHANGE_QUALITY_SCALED_BY_VOLUME,
  LASTOP_VOLUMELENGTHQUALITYTYPE
};
 
template <>
boost::shared_ptr<PhysicalEquations>
createAdolCPhysicalEquationsPtr<ELASTICITY::VOLUMELENGTHQUALITY, MODEL_3D>(
    boost::shared_ptr<ADolCData> adolc_data_ptr, int tag);
 
/**@}*/
 
} // namespace AdolCOps
 
#endif // ADOLC_OPS_ELEASTIC_HPP