Namespaces
namespace	detail

Classes
struct	IntegrationPointDataFracture
struct	IntegrationPointDataMatrix
class	LocalDataInitializer
struct	SecondaryData
class	SmallDeformationLocalAssemblerFracture
class	SmallDeformationLocalAssemblerInterface
class	SmallDeformationLocalAssemblerMatrix
class	SmallDeformationLocalAssemblerMatrixNearFracture
class	SmallDeformationProcess
struct	SmallDeformationProcessData

Functions
template<int DisplacementDim>
std::unique_ptr< Process >	createSmallDeformationProcess (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process >	createSmallDeformationProcess< 2 > (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process >	createSmallDeformationProcess< 3 > (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template<int DisplacementDim, template< typename, int > class LocalAssemblerMatrixImplementation, template< typename, int > class LocalAssemblerMatrixNearFractureImplementation, template< typename, int > class LocalAssemblerFractureImplementation, typename LocalAssemblerInterface, typename... ExtraCtorArgs>
void	createLocalAssemblers (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface > > &local_assemblers, NumLib::IntegrationOrder const integration_order, ExtraCtorArgs &&... extra_ctor_args)

Function Documentation

◆ createLocalAssemblers()

template<int DisplacementDim, template< typename, int > class LocalAssemblerMatrixImplementation, template< typename, int > class LocalAssemblerMatrixNearFractureImplementation, template< typename, int > class LocalAssemblerFractureImplementation, typename LocalAssemblerInterface, typename... ExtraCtorArgs>

void ProcessLib::LIE::SmallDeformation::createLocalAssemblers	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface > > &	local_assemblers,
		NumLib::IntegrationOrder const	integration_order,
		ExtraCtorArgs &&...	extra_ctor_args )

Creates local assemblers for each element of the given mesh.

Template Parameters

LocalAssemblerImplementation	the individual local assembler type
LocalAssemblerInterface	the general local assembler interface
ExtraCtorArgs	types of additional constructor arguments. Those arguments will be passed to the constructor of `LocalAssemblerImplementation`.

The first two template parameters cannot be deduced from the arguments. Therefore they always have to be provided manually.

Definition at line 72 of file LIE/SmallDeformation/LocalAssembler/CreateLocalAssemblers.h.

{
    DBUG("Create local assemblers.");
 
    detail::createLocalAssemblers<
        DisplacementDim, LocalAssemblerMatrixImplementation,
        LocalAssemblerMatrixNearFractureImplementation,
        LocalAssemblerFractureImplementation>(
        dof_table, mesh_elements, local_assemblers, integration_order,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

References ProcessLib::LIE::SmallDeformation::detail::createLocalAssemblers(), and DBUG().

Referenced by ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess().

◆ createSmallDeformationProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config )

Input File Parameter: prj__processes__process__type

Process Variables

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__process_variables

Primary process variables as they appear in the global component vector:

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__process_variables__process_variable

Process Parameters

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_model

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_model__type

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_properties

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_properties__material_id

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_properties__initial_aperture

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__reference_temperature

Input File Parameter: prj__processes__process__SMALL_DEFORMATION_WITH_LIE__use_b_bar

Definition at line 24 of file LIE/SmallDeformation/CreateSmallDeformationProcess.cpp.

{
    config.checkConfigParameter("type", "SMALL_DEFORMATION_WITH_LIE");
    DBUG("Create SmallDeformationProcess with LIE.");
    auto const pv_conf = config.getConfigSubtree("process_variables");
    auto range =
        pv_conf.getConfigParameterList<std::string>("process_variable");
    std::vector<std::reference_wrapper<ProcessVariable>> per_process_variables;
 
    std::size_t n_var_du = 0;
    for (std::string const& pv_name : range)
    {
        if (pv_name != "displacement" &&
            !pv_name.starts_with("displacement_jump"))
        {
            OGS_FATAL(
                "Found a process variable name '{:s}'. It should be "
                "'displacement' or 'displacement_jumpN' or "
                "'displacement_junctionN'",
                pv_name);
        }
        if (pv_name.starts_with("displacement_jump"))
        {
            n_var_du++;
        }
 
        auto variable = std::find_if(variables.cbegin(), variables.cend(),
                                     [&pv_name](ProcessVariable const& v)
                                     { return v.getName() == pv_name; });
 
        if (variable == variables.end())
        {
            OGS_FATAL(
                "Could not find process variable '{:s}' in the provided "
                "variables "
                "list for config tag <{:s}>.",
                pv_name, "process_variable");
        }
        DBUG("Found process variable '{:s}' for config tag <{:s}>.",
             variable->getName(), "process_variable");
 
        per_process_variables.emplace_back(
            const_cast<ProcessVariable&>(*variable));
    }
 
    if (n_var_du < 1)
    {
        OGS_FATAL("No displacement jump variables are specified");
    }
 
    DBUG("Associate displacement with process variable '{:s}'.",
         per_process_variables.back().get().getName());
 
    if (per_process_variables.back().get().getNumberOfGlobalComponents() !=
        DisplacementDim)
    {
        OGS_FATAL(
            "Number of components of the process variable '{:s}' is different "
            "from the displacement dimension: got {:d}, expected {:d}",
            per_process_variables.back().get().getName(),
            per_process_variables.back().get().getNumberOfGlobalComponents(),
            DisplacementDim);
    }
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
    process_variables.push_back(std::move(per_process_variables));
    auto solid_constitutive_relations =
        MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
            parameters, local_coordinate_system, materialIDs(mesh), config);
 
    // Fracture constitutive relation.
    // read type;
    auto const fracture_model_config =
        config.getConfigSubtree("fracture_model");
 
    auto const frac_type =
        fracture_model_config.peekConfigParameter<std::string>("type");
 
    std::unique_ptr<MaterialLib::Fracture::FractureModelBase<DisplacementDim>>
        fracture_model = nullptr;
    if (frac_type == "LinearElasticIsotropic")
    {
        fracture_model = MaterialLib::Fracture::createLinearElasticIsotropic<
            DisplacementDim>(parameters, fracture_model_config);
    }
    else if (frac_type == "Coulomb")
    {
        fracture_model = MaterialLib::Fracture::createCoulomb<DisplacementDim>(
            parameters, fracture_model_config);
    }
    else if (frac_type == "CohesiveZoneModeI")
    {
        fracture_model =
            MaterialLib::Fracture::CohesiveZoneModeI::createCohesiveZoneModeI<
                DisplacementDim>(parameters, fracture_model_config);
    }
    else
    {
        OGS_FATAL(
            "Cannot construct fracture constitutive relation of given type "
            "'{:s}'.",
            frac_type);
    }
 
    // Fracture properties
    std::vector<FractureProperty> fracture_properties;
    for (
        auto fracture_properties_config :
        config.getConfigSubtreeList("fracture_properties"))
    {
        fracture_properties.emplace_back(
            fracture_properties.size(),
            fracture_properties_config.getConfigParameter<int>("material_id"),
            ParameterLib::findParameter<double>(
                fracture_properties_config, "initial_aperture", parameters, 1,
                &mesh));
    }
 
    if (n_var_du < fracture_properties.size())
    {
        OGS_FATAL(
            "The number of displacement jumps {} and the number of "
            "<fracture_properties> {} are not consistent.",
            n_var_du,
            fracture_properties.size());
    }
 
    // Reference temperature
    const auto& reference_temperature =
        config.getConfigParameter<double>(
            "reference_temperature", std::numeric_limits<double>::quiet_NaN());
    auto const use_b_bar = config.getConfigParameter<bool>("use_b_bar", false);
 
    SmallDeformationProcessData<DisplacementDim> process_data{
        materialIDs(mesh),         std::move(solid_constitutive_relations),
        std::move(fracture_model), std::move(fracture_properties),
        reference_temperature,     use_b_bar};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<SmallDeformationProcess<DisplacementDim>>(
        std::move(name), mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables));
}

References BaseLib::ConfigTree::checkConfigParameter(), MaterialLib::Fracture::CohesiveZoneModeI::createCohesiveZoneModeI(), MaterialLib::Solids::createConstitutiveRelations(), MaterialLib::Fracture::createCoulomb(), MaterialLib::Fracture::createLinearElasticIsotropic(), ProcessLib::createSecondaryVariables(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterList(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeList(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

◆ createSmallDeformationProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess< 2 >	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config )

Referenced by ProjectData::parseProcesses().

◆ createSmallDeformationProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess< 3 >	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config )