ProcessLib::LargeDeformation Namespace Reference

Namespaces
namespace	ConstitutiveRelations
namespace	detail

Classes
struct	DeformationGradientData
struct	GravityModel
struct	IntegrationPointData
class	LargeDeformationLocalAssembler
struct	LargeDeformationLocalAssemblerInterface
class	LargeDeformationProcess
struct	LargeDeformationProcessData
class	MaterialStateData
struct	MediaData
struct	SecondaryData
struct	SolidDensityModel

Typedefs
template<int DisplacementDim>
using	KelvinVector = KV::KelvinVectorType<DisplacementDim>
template<int DisplacementDim>
using	KelvinMatrix = KV::KelvinMatrixType<DisplacementDim>
template<int DisplacementDim>
using	GlobalDimVector = Eigen::Vector<double, DisplacementDim>
template<int DisplacementDim>
using	GlobalDimMatrix
using	Temperature = BaseLib::StrongType<double, struct TemperatureTag>
template<int DisplacementDim>
using	VolumetricBodyForce
using	SolidDensity = BaseLib::StrongType<double, struct SolidDensityTag>

Functions
template<int D>
constexpr GlobalDimVector< D >	DVnan ()
	Used to set a D dimensional vector to all not-a-number.
template<int D>
constexpr GlobalDimMatrix< D >	DMnan ()
	Used to set a D x D matrix to all not-a-number.
template<typename T >
constexpr bool	areEvalArgumentTypesUnique ()
template<typename Model >
constexpr void	assertEvalArgsUnique (Model const &)
template<int DisplacementDim>
std::unique_ptr< Process >	createLargeDeformationProcess (std::string 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, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process >	createLargeDeformationProcess< 2 > (std::string 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, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process >	createLargeDeformationProcess< 3 > (std::string 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, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template<int GlobalDim, template< typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , IntegrationMethodProviderOrIntegrationOrder ProviderOrOrder, typename... ExtraCtorArgs>
void	createLocalAssemblers (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface > > &local_assemblers, ProviderOrOrder const &provider_or_order, ExtraCtorArgs &&... extra_ctor_args)
template<int DisplacementDim, typename ShapeMatricesType >
Eigen::Matrix< double, MPL::tensorSize(DisplacementDim), MPL::tensorSize(DisplacementDim)>	computeSigmaGeom (Eigen::Matrix3d const &sigma_tensor)

Typedef Documentation

GlobalDimMatrix

template<int DisplacementDim>

using ProcessLib::LargeDeformation::GlobalDimMatrix

Initial value:

 
    Eigen::Matrix<double, DisplacementDim, DisplacementDim, Eigen::RowMajor>

Definition at line 36 of file Base.h.

GlobalDimVector

template<int DisplacementDim>

using ProcessLib::LargeDeformation::GlobalDimVector = Eigen::Vector<double, DisplacementDim>

Definition at line 33 of file Base.h.

KelvinMatrix

template<int DisplacementDim>

using ProcessLib::LargeDeformation::KelvinMatrix = KV::KelvinMatrixType<DisplacementDim>

Definition at line 30 of file Base.h.

KelvinVector

template<int DisplacementDim>

using ProcessLib::LargeDeformation::KelvinVector = KV::KelvinVectorType<DisplacementDim>

Definition at line 27 of file Base.h.

SolidDensity

using ProcessLib::LargeDeformation::SolidDensity = BaseLib::StrongType<double, struct SolidDensityTag>

Definition at line 17 of file SolidDensity.h.

Temperature

using ProcessLib::LargeDeformation::Temperature = BaseLib::StrongType<double, struct TemperatureTag>

Definition at line 64 of file Base.h.

VolumetricBodyForce

template<int DisplacementDim>

using ProcessLib::LargeDeformation::VolumetricBodyForce

Initial value:

 
    BaseLib::StrongType<GlobalDimVector<DisplacementDim>, struct GravityTag>

Definition at line 18 of file Gravity.h.

Function Documentation

areEvalArgumentTypesUnique()

template<typename T >

bool ProcessLib::LargeDeformation::areEvalArgumentTypesUnique ( )

constexpr

Checks whether the argument types of the eval() method of the given type T are unique.

Argument types differing only in constness, reference or volatility are considered equal.

Definition at line 41 of file Invoke.h.

{
    return detail::areEvalArgumentTypesUnique(&T::eval);
}

References ProcessLib::LargeDeformation::detail::areEvalArgumentTypesUnique().

Referenced by assertEvalArgsUnique().

assertEvalArgsUnique()

template<typename Model >

void ProcessLib::LargeDeformation::assertEvalArgsUnique ( Model const & )

constexpr

Statically asserts that the argument types of the passed Model's eval() method are unique.

Definition at line 49 of file Invoke.h.

{
    static_assert(areEvalArgumentTypesUnique<std::remove_cvref_t<Model>>());
}

References areEvalArgumentTypesUnique().

Referenced by ProcessLib::LargeDeformation::ConstitutiveRelations::ConstitutiveSetting< DisplacementDim >::eval().

computeSigmaGeom()

template<int DisplacementDim, typename ShapeMatricesType >

Eigen::Matrix< double, MPL::tensorSize(DisplacementDim), MPL::tensorSize(DisplacementDim)> ProcessLib::LargeDeformation::computeSigmaGeom

(

Eigen::Matrix3d const &

sigma_tensor

)

Definition at line 54 of file LargeDeformationFEM.h.

{
    static constexpr auto& sigma_geom_op = MathLib::eigenBlockMatrixView<
        DisplacementDim,
        Eigen::Matrix<double, DisplacementDim, DisplacementDim>>;
 
    using SigmaGeom = Eigen::Matrix<double, MPL::tensorSize(DisplacementDim),
                                    MPL::tensorSize(DisplacementDim)>;
    if constexpr (DisplacementDim == 2)
    {
        SigmaGeom sigma_geom = SigmaGeom::Zero(5, 5);
        sigma_geom.template block<4, 4>(0, 0) =
            sigma_geom_op(sigma_tensor.template block<2, 2>(0, 0).eval());
        sigma_geom(4, 4) = sigma_tensor(2, 2);
 
        return sigma_geom;
    }
 
    if constexpr (DisplacementDim == 3)
    {
        return sigma_geom_op(sigma_tensor);
    }
}

References MathLib::eigenBlockMatrixView(), and MaterialPropertyLib::tensorSize().

Referenced by ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian().

createLargeDeformationProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::LargeDeformation::createLargeDeformationProcess	(	std::string	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,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

Input File Parameter

prj__processes__process__type

Process Variables

Input File Parameter

prj__processes__process__LARGE_DEFORMATION__process_variables

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

Input File Parameter

prj__processes__process__LARGE_DEFORMATION__process_variables__process_variable

Process Parameters

Input File Parameter

prj__processes__process__LARGE_DEFORMATION__specific_body_force

Input File Parameter

prj__processes__process__LARGE_DEFORMATION__reference_temperature

Input File Parameter

prj__processes__process__LARGE_DEFORMATION__initial_stress

Definition at line 28 of file CreateLargeDeformationProcess.cpp.

{
    config.checkConfigParameter("type", "LARGE_DEFORMATION");
    DBUG("Create LargeDeformationProcess.");
 
 
    auto const pv_config = config.getConfigSubtree("process_variables");
 
    auto per_process_variables = findProcessVariables(
        variables, pv_config,
        {
         "process_variable"});
 
    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 =
        ConstitutiveRelations::CreateConstitutiveSetting<DisplacementDim>::
            createSolidConstitutiveRelations(
                parameters, local_coordinate_system, materialIDs(mesh), config);
 
    // Specific body force
    Eigen::Matrix<double, DisplacementDim, 1> specific_body_force;
    {
        std::vector<double> const b =
            config.getConfigParameter<std::vector<double>>(
                "specific_body_force");
        if (b.size() != DisplacementDim)
        {
            OGS_FATAL(
                "The size of the specific body force vector does not match the "
                "displacement dimension. Vector size is {:d}, displacement "
                "dimension is {:d}",
                b.size(), DisplacementDim);
        }
 
        std::copy_n(b.data(), b.size(), specific_body_force.data());
    }
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
 
    // Reference temperature
    auto const reference_temperature = ParameterLib::findOptionalTagParameter<
        double>(
        config, "reference_temperature", parameters, 1, &mesh);
    if (reference_temperature)
    {
        DBUG("Use '{:s}' as reference temperature parameter.",
             (*reference_temperature).name);
    }
 
    // Initial stress conditions
    auto const initial_stress = ParameterLib::findOptionalTagParameter<double>(
        config, "initial_stress", parameters,
        // Symmetric tensor size, 4 or 6, not a Kelvin vector.
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim),
        &mesh);
 
    LargeDeformationProcessData<DisplacementDim> process_data{
        materialIDs(mesh),
        std::move(media_map),
        std::move(solid_constitutive_relations),
        initial_stress,
        specific_body_force,
        reference_temperature};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<LargeDeformationProcess<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(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), ProcessLib::LargeDeformation::ConstitutiveRelations::CreateConstitutiveSetting< DisplacementDim >::createSolidConstitutiveRelations(), DBUG(), ParameterLib::findOptionalTagParameter(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), MathLib::KelvinVector::kelvin_vector_dimensions(), and OGS_FATAL.

createLargeDeformationProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::LargeDeformation::createLargeDeformationProcess< 2 >	(	std::string	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,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

Referenced by ProjectData::parseProcesses().

createLargeDeformationProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::LargeDeformation::createLargeDeformationProcess< 3 >	(	std::string	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,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

Referenced by ProjectData::parseProcesses().

createLocalAssemblers()

template<int GlobalDim, template< typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , IntegrationMethodProviderOrIntegrationOrder ProviderOrOrder, typename... ExtraCtorArgs>

void ProcessLib::LargeDeformation::createLocalAssemblers	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface > > &	local_assemblers,
		ProviderOrOrder const &	provider_or_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 76 of file CreateLocalAssemblers.h.

{
    DBUG("Create local assemblers.");
 
    detail::createLocalAssemblers<GlobalDim, LocalAssemblerImplementation>(
        dof_table, mesh_elements, local_assemblers, provider_or_order,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

References DBUG().

Referenced by ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::initializeConcreteProcess().

DMnan()

template<int D>

GlobalDimMatrix< D > ProcessLib::LargeDeformation::DMnan ( )

constexpr

Used to set a D x D matrix to all not-a-number.

Definition at line 48 of file Base.h.

{
    return GlobalDimMatrix<D>::Constant(nan);
}

References ProcessLib::ConstitutiveRelations::nan.

DVnan()

template<int D>

GlobalDimVector< D > ProcessLib::LargeDeformation::DVnan ( )

constexpr

Used to set a D dimensional vector to all not-a-number.

Definition at line 41 of file Base.h.

{
    return GlobalDimVector<D>::Constant(nan);
}

References ProcessLib::ConstitutiveRelations::nan.