Classes
class	MFront

Functions
template<int DisplacementDim>
std::unique_ptr< MechanicsBase< DisplacementDim > >	createMFront (std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)

template std::unique_ptr< MechanicsBase< 2 > >	createMFront< 2 > (std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)

template std::unique_ptr< MechanicsBase< 3 > >	createMFront< 3 > (std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)

const char *	toString (mgis::behaviour::Behaviour::Kinematic)
	Converts MGIS kinematic to a string representation. More...

const char *	toString (mgis::behaviour::Behaviour::Symmetry)
	Converts MGIS symmetry to a string representation. More...

const char *	btypeToString (int)
	Converts MGIS behaviour type to a string representation. More...

const char *	varTypeToString (int)
	Converts MGIS variable type to a string representation. More...

int	getEquivalentPlasticStrainOffset (mgis::behaviour::Behaviour const &b)

Function Documentation

◆ btypeToString()

const char * MaterialLib::Solids::MFront::btypeToString ( int btype )

Converts MGIS behaviour type to a string representation.

Definition at line 136 of file MFront.cpp.

 {
     using B = mgis::behaviour::Behaviour;
     if (btype == B::GENERALBEHAVIOUR)
         return "GENERALBEHAVIOUR";
     if (btype == B::STANDARDSTRAINBASEDBEHAVIOUR)
         return "STANDARDSTRAINBASEDBEHAVIOUR";
     if (btype == B::STANDARDFINITESTRAINBEHAVIOUR)
         return "STANDARDFINITESTRAINBEHAVIOUR";
     if (btype == B::COHESIVEZONEMODEL)
         return "COHESIVEZONEMODEL";
  
     OGS_FATAL("Unknown behaviour type {:d}.", btype);
 }

References OGS_FATAL.

Referenced by createMFront().

◆ createMFront()

template<int DisplacementDim>

std::unique_ptr< MechanicsBase< DisplacementDim > > MaterialLib::Solids::MFront::createMFront	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config
	)

Input File Parameter:: material__solid__constitutive_relation__type

Input File Parameter:: material__solid__constitutive_relation__MFront__library

Input File Parameter:: material__solid__constitutive_relation__MFront__behaviour

Input File Parameter:: material__solid__constitutive_relation__MFront__material_properties

Input File Parameter:: material__solid__constitutive_relation__MFront__material_properties__material_property

Input File Parameter:: material__solid__constitutive_relation__MFront__material_properties__material_property__name

Input File Parameter:: material__solid__constitutive_relation__MFront__material_properties__material_property__parameter

Definition at line 59 of file CreateMFront.cpp.

 {
     INFO("### MFRONT ########################################################");
  
     config.checkConfigParameter("type", "MFront");
  
     auto const library_name =
         config.getConfigParameterOptional<std::string>("library");
     auto const lib_path =
         library_name
             ? BaseLib::joinPaths(BaseLib::getProjectDirectory(), *library_name)
             : "libOgsMFrontBehaviour";
  
     auto const behaviour_name =
         config.getConfigParameter<std::string>("behaviour");
  
     static_assert(DisplacementDim == 2 || DisplacementDim == 3,
                   "Given DisplacementDim not supported.");
  
     mgis::behaviour::Hypothesis hypothesis;
     if (DisplacementDim == 2)
     {
         // TODO support the axial symmetry modelling hypothesis.
         WARN(
             "The model is defined in 2D. On the material level currently a "
             "plane strain setting is used. In particular it is not checked if "
             "axial symmetry or plane stress are assumed. Special material "
             "behaviour for these settings is currently not supported.");
         hypothesis = mgis::behaviour::Hypothesis::PLANESTRAIN;
     }
     else if (DisplacementDim == 3)
     {
         hypothesis = mgis::behaviour::Hypothesis::TRIDIMENSIONAL;
     }
  
     // Fix for https://gitlab.opengeosys.org/ogs/ogs/-/issues/3073
     // Pre-load dependencies of mfront lib
 #ifndef _WIN32
     dlopen("libTFELNUMODIS.so", RTLD_NOW);
     dlopen("libTFELUtilities.so", RTLD_NOW);
     dlopen("libTFELException.so", RTLD_NOW);
 #endif
  
     auto behaviour =
         mgis::behaviour::load(lib_path, behaviour_name, hypothesis);
  
     INFO("Behaviour:      `{:s}'.", behaviour.behaviour);
     INFO("Hypothesis:     `{:s}'.", mgis::behaviour::toString(hypothesis));
     INFO("Source:         `{:s}'.", behaviour.source);
     INFO("TFEL version:   `{:s}'.", behaviour.tfel_version);
     INFO("Behaviour type: `{:s}'.", btypeToString(behaviour.btype));
     INFO("Kinematic:      `{:s}'.", toString(behaviour.kinematic));
     INFO("Symmetry:       `{:s}'.", toString(behaviour.symmetry));
  
     varInfo("Mat. props.", behaviour.mps, hypothesis);
     varInfo("Gradients", behaviour.gradients, hypothesis);
     varInfo("Thdyn. forces", behaviour.thermodynamic_forces, hypothesis);
     varInfo("Int. StVars.", behaviour.isvs, hypothesis);
     varInfo("Ext. StVars.", behaviour.esvs, hypothesis);
  
     // TODO read parameters from prj file, not yet (2018-11-05) supported by
     // MGIS library.
     varInfo("Real-valued parameters", behaviour.params);
     varInfo("Integer parameters", behaviour.iparams);
     varInfo("Unsigned parameters", behaviour.usparams);
  
     std::vector<ParameterLib::Parameter<double> const*> material_properties;
  
     if (!behaviour.mps.empty())
     {
         std::map<std::string, std::string> map_name_to_param;
  
         // gather material properties from the prj file
         auto const mps_config = config.getConfigSubtree("material_properties");
         for (
             auto const mp_config :
             mps_config.getConfigParameterList("material_property"))
         {
             auto name = mp_config.getConfigAttribute<std::string>("name");
             auto const param_name =
                 mp_config.getConfigAttribute<std::string>("parameter");
  
             map_name_to_param.emplace(std::move(name), std::move(param_name));
         }
  
         for (auto& mp : behaviour.mps)
         {
             auto const it = map_name_to_param.find(mp.name);
             if (it == map_name_to_param.end())
                 OGS_FATAL(
                     "Material Property `{:s}' has not been configured in the "
                     "project file.",
                     mp.name);
  
             auto const param_name = it->second;
             auto const num_comp =
                 mgis::behaviour::getVariableSize(mp, hypothesis);
             auto const* param = &ParameterLib::findParameter<double>(
                 param_name, parameters, num_comp);
  
             INFO("Using OGS parameter `{:s}' for material property `{:s}'.",
                  param_name, mp.name);
  
             using V = mgis::behaviour::Variable;
             if (mp.type == V::STENSOR || mp.type == V::TENSOR)
             {
                 WARN(
                     "Material property `{:s}' is a tensorial quantity. You, "
                     "the "
                     "user, have to make sure that the component order of "
                     "parameter `{:s}' matches the one required by MFront!",
                     mp.name, param_name);
             }
  
             material_properties.push_back(param);
             map_name_to_param.erase(it);
         }
  
         if (!map_name_to_param.empty())
         {
             ERR("Some material parameters that were configured are not used by "
                 "the material model.");
             ERR("These parameters are:");
  
             for (auto& e : map_name_to_param)
             {
                 ERR("  name: `{:s}', parameter: `{:s}'.", e.first, e.second);
             }
  
             OGS_FATAL(
                 "Configuration errors occurred. Please fix the project file.");
         }
     }
  
     INFO("### MFRONT END ####################################################");
  
     return std::make_unique<MFront<DisplacementDim>>(
         std::move(behaviour), std::move(material_properties),
         local_coordinate_system);
 }

References btypeToString(), BaseLib::ConfigTree::checkConfigParameter(), ERR(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::getProjectDirectory(), INFO(), BaseLib::joinPaths(), MaterialPropertyLib::name, OGS_FATAL, toString(), anonymous_namespace{CreateMFront.cpp}::varInfo(), and WARN().

◆ createMFront< 2 >()

template std::unique_ptr< MechanicsBase< 2 > > MaterialLib::Solids::MFront::createMFront< 2 >	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config
	)

◆ createMFront< 3 >()

template std::unique_ptr< MechanicsBase< 3 > > MaterialLib::Solids::MFront::createMFront< 3 >	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config
	)

◆ getEquivalentPlasticStrainOffset()

int MaterialLib::Solids::MFront::getEquivalentPlasticStrainOffset ( mgis::behaviour::Behaviour const & b )

Definition at line 165 of file MFront.cpp.

 {
     return mgis::behaviour::contains(b.isvs, "EquivalentPlasticStrain")
                ? mgis::behaviour::getVariableOffset(
                      b.isvs, "EquivalentPlasticStrain", b.hypothesis)
                : -1;
 }

References BaseLib::contains().

◆ toString() [1/2]

const char * MaterialLib::Solids::MFront::toString ( mgis::behaviour::Behaviour::Kinematic kin )

Converts MGIS kinematic to a string representation.

Definition at line 103 of file MFront.cpp.

 {
     using K = mgis::behaviour::Behaviour::Kinematic;
     switch (kin)
     {
         case K::UNDEFINEDKINEMATIC:
             return "UNDEFINEDKINEMATIC";
         case K::SMALLSTRAINKINEMATIC:
             return "SMALLSTRAINKINEMATIC";
         case K::COHESIVEZONEKINEMATIC:
             return "COHESIVEZONEKINEMATIC";
         case K::FINITESTRAINKINEMATIC_F_CAUCHY:
             return "FINITESTRAINKINEMATIC_F_CAUCHY";
         case K::FINITESTRAINKINEMATIC_ETO_PK1:
             return "FINITESTRAINKINEMATIC_ETO_PK1";
     }
  
     OGS_FATAL("Unknown kinematic {:d}.", kin);
 }

References OGS_FATAL.

Referenced by MainWindow::about(), ProcessLib::LIE::PostProcessTool::copyPropertyValues(), createMFront(), ProcessLib::LIE::PostProcessTool::createProperty(), MeshLib::Properties::getPropertyVector(), DiagramPrefsDialog::loadFile(), GeoTreeModel::removeGeoList(), StationTreeModel::vtkSource(), GeoTreeModel::vtkSource(), and ApplicationUtils::writeProperties().

◆ toString() [2/2]

const char * MaterialLib::Solids::MFront::toString ( mgis::behaviour::Behaviour::Symmetry sym )

Converts MGIS symmetry to a string representation.

Definition at line 123 of file MFront.cpp.

 {
     using S = mgis::behaviour::Behaviour::Symmetry;
     switch (sym)
     {
         case S::ISOTROPIC:
             return "ISOTROPIC";
         case S::ORTHOTROPIC:
             return "ORTHOTROPIC";
     }
  
     OGS_FATAL("Unknown symmetry {:d}.", sym);
 }

References OGS_FATAL.

◆ varTypeToString()

const char * MaterialLib::Solids::MFront::varTypeToString ( int v )

Converts MGIS variable type to a string representation.

Definition at line 150 of file MFront.cpp.

 {
     using V = mgis::behaviour::Variable;
     if (v == V::SCALAR)
         return "SCALAR";
     if (v == V::VECTOR)
         return "VECTOR";
     if (v == V::STENSOR)
         return "STENSOR";
     if (v == V::TENSOR)
         return "TENSOR";
  
     OGS_FATAL("Unknown variable type {:d}.", v);
 }

References OGS_FATAL.

Referenced by anonymous_namespace{CreateMFront.cpp}::varInfo().

Classes

Functions

Function Documentation

◆ btypeToString()

◆ createMFront()

◆ createMFront< 2 >()

◆ createMFront< 3 >()

◆ getEquivalentPlasticStrainOffset()

◆ toString() [1/2]

◆ toString() [2/2]

◆ varTypeToString()