MFrontInterface.hpp

Go to the documentation of this file.

/** \file MFrontInterface.hpp
 * \brief MFrontInterface
 *
 * This file defines the MFrontInterface base class, which provides
 * an interface for integrating MFront material models with MoFEM.
 * Derived class templates handle specific model hypotheses (plane strain,
 * axisymmetrical, 3D) and assembly types (PETSc, Schur blocks).
 *
 * \ingroup mfront
 */
 
#ifndef __MFRONT_INTERFACE_HPP__
#define __MFRONT_INTERFACE_HPP__
 
namespace MoFEM {
 
/**
 * @brief Interface for integrating MFront material models with MoFEM.
 *
 * This class defines a set of pure virtual methods that must be implemented
 * by derived classes to handle various operations such as setting monitors,
 * creating operators, and updating internal variables.
 */
class MFrontInterface {
public:
  virtual ~MFrontInterface() = default;
  /**
   * @brief Retrieve command-line parameters for the interface.
   */
 
  virtual MoFEMErrorCode getCommandLineParameters() = 0;
 
  /**
   * @brief Set a monitor for the interface.
   * @param monitor_ptr Shared pointer to the FEMethod monitor.
   */
  virtual MoFEMErrorCode
  setMonitor(boost::shared_ptr<MoFEM::FEMethod> monitor_ptr) = 0;
 
  /**
   * @brief Push domain operators for the right-hand side (RHS).
   * @param pip pipeline to push the operators into.
   * @param field_name Name of the field associated with displacement.
   */
  virtual MoFEMErrorCode opFactoryDomainRhs(
      boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pip,
      std::string field_name) = 0;
 
  /**
   * @brief  Push domain operators for the left-hand side (LHS).
   * @param pip pipeline to push the operators into.
   * @param field_name Name of the field associated with displacement.
   */
  virtual MoFEMErrorCode opFactoryDomainLhs(
      boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pip,
      std::string field_name) = 0;
 
  /**
   * @brief Set operators for updating internal variables using internal
   * pipeline.
   * @param rule Hook function defining the integration rule
   * @param field_name Name of the field associated with displacement.
   */
  virtual MoFEMErrorCode
  setUpdateInternalVariablesOperators(ForcesAndSourcesCore::RuleHookFun rule,
                                      std::string field_name) = 0;
 
  /**
   * @brief Set operators for post-processing using internal pipeline.
   * @param rule Hook function defining the integration rule.
   * @param fe_name Name of the domain finite element.
   * @param field_name Name of the field associated with displacement.
   * @param order Approximation order for L2 projection
   */
  virtual MoFEMErrorCode
  setPostProcessOperators(ForcesAndSourcesCore::RuleHookFun rule,
                          std::string fe_name, std::string field_name,
                          int order) = 0;
 
  /**
   * @brief Loop internal pipeline to update internal variables at each Gauss
   * point.
   * @param dm SmartPetscObj
   * @param fe_name Name of the domain finite element.
   */
  virtual MoFEMErrorCode updateInternalVariables(SmartPetscObj<DM> dm,
                                                 std::string fe_name) = 0;
 
  /**
   * @brief Perform post-processing for displacement, strain and stress.
   * @param step Current time step.
   * @param dm SmartPetscObj
   * @param fe_name Name of the domain finite element.
   */
  virtual MoFEMErrorCode postProcess(int step, SmartPetscObj<DM> dm,
                                     string fe_name) = 0;
 
  /**
   * @brief Structure to hold common data shared across the operators.
   */
  struct CommonData;
};
 
using EntData = EntitiesFieldData::EntData;
 
/**
 * @brief Enumeration of model hypotheses supported by MFront interface
 */
enum ModelHypothesis {
  TRIDIMENSIONAL, ///< 3D model hypothesis.
  PLANESTRAIN,    ///< Plane strain model hypothesis.
  AXISYMMETRICAL  ///< Axisymmetrical model hypothesis.
};
 
/**
 * @brief create mfront interface
 * 
 * @param m_field 
 * @param mh model hypothesis (TRIDIMENSIONAL, PLANESTRAIN, AXISYMMETRICAL)
 * @param at assembly type (PETSC, SCHUR, BLOCK_MAT, BLOCK_SCHUR,)
 * @return boost::shared_ptr<MFrontInterface> 
 */
boost::shared_ptr<MFrontInterface>
createMFrontInterface(MoFEM::Interface &m_field, ModelHypothesis mh,
                      AssemblyType at = AssemblyType::PETSC);
 
} // namespace MoFEM
 
#endif // __MFRONT_INTERFACE_HPP__