ProcessLib::SmallDeformation Namespace Reference

Namespaces
namespace	ConstitutiveRelations
namespace	detail

Classes
struct	FreeEnergyDensityData
struct	GravityModel
struct	IntegrationPointData
struct	MaterialForcesInterface
class	MaterialStateData
struct	MediaData
struct	SecondaryData
class	SmallDeformationLocalAssembler
struct	SmallDeformationLocalAssemblerInterface
class	SmallDeformationProcess
struct	SmallDeformationProcessData
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>
using	Temperature = BaseLib::StrongType<double, struct TemperatureTag>
template<int DisplacementDim>
using	VolumetricBodyForce
using	SolidDensity = BaseLib::StrongType<double, struct SolidDensityTag>

Functions
template<typename T >
constexpr bool	areEvalArgumentTypesUnique ()
template<typename Model >
constexpr void	assertEvalArgsUnique (Model const &)
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)
void	checkMPLProperties (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
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, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
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, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
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, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template<int DisplacementDim, typename ShapeFunction , typename ShapeMatricesType , typename NodalForceVectorType , typename NodalDisplacementVectorType , typename GradientVectorType , typename GradientMatrixType , typename IPData , typename StressData , typename OutputData , typename IntegrationMethod >
std::vector< double > const &	getMaterialForces (std::vector< double > const &local_x, std::vector< double > &nodal_values, IntegrationMethod const &_integration_method, IPData const &_ip_data, StressData const &stress_data, OutputData const &output_data, MeshLib::Element const &element, bool const is_axially_symmetric)
template<typename LocalAssemblerInterface >
void	writeMaterialForces (std::unique_ptr< GlobalVector > &material_forces, std::vector< std::unique_ptr< LocalAssemblerInterface > > const &local_assemblers, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, GlobalVector const &x)

Typedef Documentation

GlobalDimVector

template<int DisplacementDim>

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

Definition at line 32 of file Base.h.

KelvinMatrix

template<int DisplacementDim>

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

Definition at line 29 of file Base.h.

KelvinVector

template<int DisplacementDim>

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

Definition at line 26 of file Base.h.

SolidDensity

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

Definition at line 17 of file SolidDensity.h.

Temperature

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

Definition at line 45 of file Base.h.

VolumetricBodyForce

template<int DisplacementDim>

using ProcessLib::SmallDeformation::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::SmallDeformation::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::SmallDeformation::detail::areEvalArgumentTypesUnique().

Referenced by assertEvalArgsUnique().

assertEvalArgsUnique()

template<typename Model >

void ProcessLib::SmallDeformation::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::SmallDeformation::ConstitutiveRelations::ConstitutiveSetting< DisplacementDim >::eval().

checkMPLProperties()

void ProcessLib::SmallDeformation::checkMPLProperties

(

std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &

media

)

Definition at line 27 of file CreateSmallDeformationProcess.cpp.

{
    for (auto const& m : media)
    {
        checkRequiredProperties(m.second->phase("Solid"),
                                {{MaterialPropertyLib::density}});
    }
}

createLocalAssemblers()

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

void ProcessLib::SmallDeformation::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::PhaseField::PhaseFieldProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::initializeConcreteProcess(), and ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::initializeConcreteProcess().

createSmallDeformationProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::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,
		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__SMALL_DEFORMATION__process_variables

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

Input File Parameter

prj__processes__process__SMALL_DEFORMATION__process_variables__process_variable

Process Parameters

Input File Parameter

prj__processes__process__SMALL_DEFORMATION__solid_density

Input File Parameter

prj__processes__process__SMALL_DEFORMATION__specific_body_force

Input File Parameter

prj__processes__process__SMALL_DEFORMATION__use_b_bar

Input File Parameter

prj__processes__process__SMALL_DEFORMATION__reference_temperature

Input File Parameter

prj__processes__process__SMALL_DEFORMATION__initial_stress

Definition at line 38 of file CreateSmallDeformationProcess.cpp.

{
    config.checkConfigParameter("type", "SMALL_DEFORMATION");
    DBUG("Create SmallDeformationProcess.");
 
 
    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 =
        MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
            parameters, local_coordinate_system, materialIDs(mesh), config);
 
    if (config.getConfigParameterOptional<std::string>("solid_density"))
    {
        OGS_FATAL(
            "The <solid_density> tag has been removed. Use <media> definitions "
            "to specify solid's density.");
    }
 
    // 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 const use_b_bar = config.getConfigParameter<bool>("use_b_bar", false);
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
    DBUG(
        "Check the media properties of SmallDeformation process "
        "...");
    checkMPLProperties(media);
    DBUG("Media properties verified.");
 
    // 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);
 
    SmallDeformationProcessData<DisplacementDim> process_data{
        materialIDs(mesh),
        std::move(media_map),
        std::move(solid_constitutive_relations),
        initial_stress,
        specific_body_force,
        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::Solids::createConstitutiveRelations(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), ParameterLib::findOptionalTagParameter(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), MathLib::KelvinVector::kelvin_vector_dimensions(), and OGS_FATAL.

createSmallDeformationProcess< 2 >()

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

Referenced by ProjectData::parseProcesses().

createSmallDeformationProcess< 3 >()

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

Referenced by ProjectData::parseProcesses().

getMaterialForces()

template<int DisplacementDim, typename ShapeFunction , typename ShapeMatricesType , typename NodalForceVectorType , typename NodalDisplacementVectorType , typename GradientVectorType , typename GradientMatrixType , typename IPData , typename StressData , typename OutputData , typename IntegrationMethod >

std::vector< double > const & ProcessLib::SmallDeformation::getMaterialForces	(	std::vector< double > const &	local_x,
		std::vector< double > &	nodal_values,
		IntegrationMethod const &	_integration_method,
		IPData const &	_ip_data,
		StressData const &	stress_data,
		OutputData const &	output_data,
		MeshLib::Element const &	element,
		bool const	is_axially_symmetric )

Definition at line 40 of file MaterialForces.h.

{
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    nodal_values.clear();
    auto local_b = MathLib::createZeroedVector<NodalDisplacementVectorType>(
        nodal_values, ShapeFunction::NPOINTS * DisplacementDim);
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& sigma = stress_data[ip].stress_data.sigma;
        auto const& N = _ip_data[ip].N_u;
        auto const& dNdx = _ip_data[ip].dNdx_u;
 
        auto const& psi =
            output_data[ip].free_energy_density_data.free_energy_density;
 
        auto const x_coord =
            NumLib::interpolateXCoordinate<ShapeFunction, ShapeMatricesType>(
                element, _ip_data[ip].N_u);
 
        // For the 2D case the 33-component is needed (and the four entries
        // of the non-symmetric matrix); In 3d there are nine entries.
        GradientMatrixType G(
            DisplacementDim * DisplacementDim + (DisplacementDim == 2 ? 1 : 0),
            ShapeFunction::NPOINTS * DisplacementDim);
        Deformation::computeGMatrix<DisplacementDim, ShapeFunction::NPOINTS>(
            dNdx, G, is_axially_symmetric, N, x_coord);
 
        GradientVectorType const grad_u =
            G * Eigen::Map<NodalForceVectorType const>(
                    local_x.data(), ShapeFunction::NPOINTS * DisplacementDim);
 
        GradientVectorType eshelby_stress;
        eshelby_stress.setZero(DisplacementDim * DisplacementDim +
                               (DisplacementDim == 2 ? 1 : 0));
 
        if (DisplacementDim == 3)
        {
            eshelby_stress[0] = eshelby_stress[DisplacementDim + 1] =
                eshelby_stress[8] = psi;
 
            eshelby_stress[0] -= sigma[0] * grad_u[0] +
                                 sigma[3] / std::sqrt(2) * grad_u[3] +
                                 sigma[5] / std::sqrt(2) * grad_u[6];
 
            eshelby_stress[1] -= sigma[3] / std::sqrt(2) * grad_u[0] +
                                 sigma[1] * grad_u[3] +
                                 sigma[4] / std::sqrt(2) * grad_u[6];
 
            eshelby_stress[2] -= sigma[5] / std::sqrt(2) * grad_u[0] +
                                 sigma[4] / std::sqrt(2) * grad_u[3] +
                                 sigma[2] * grad_u[6];
 
            eshelby_stress[3] -= sigma[0] * grad_u[1] +
                                 sigma[3] / std::sqrt(2) * grad_u[4] +
                                 sigma[5] / std::sqrt(2) * grad_u[7];
 
            eshelby_stress[4] -= sigma[3] / std::sqrt(2) * grad_u[1] +
                                 sigma[1] * grad_u[4] +
                                 sigma[4] / std::sqrt(2) * grad_u[7];
 
            eshelby_stress[5] -= sigma[5] / std::sqrt(2) * grad_u[1] +
                                 sigma[4] / std::sqrt(2) * grad_u[4] +
                                 sigma[2] * grad_u[7];
 
            eshelby_stress[6] -= sigma[0] * grad_u[2] +
                                 sigma[3] / std::sqrt(2) * grad_u[5] +
                                 sigma[5] / std::sqrt(2) * grad_u[8];
 
            eshelby_stress[7] -= sigma[3] / std::sqrt(2) * grad_u[2] +
                                 sigma[1] * grad_u[5] +
                                 sigma[4] / std::sqrt(2) * grad_u[8];
 
            eshelby_stress[8] -= sigma[5] / std::sqrt(2) * grad_u[2] +
                                 sigma[4] / std::sqrt(2) * grad_u[5] +
                                 sigma[2] * grad_u[8];
        }
        else if (DisplacementDim == 2)
        {
            eshelby_stress[0] = eshelby_stress[DisplacementDim + 1] =
                eshelby_stress[4] = psi;
 
            eshelby_stress[0] -=
                sigma[0] * grad_u[0] + sigma[3] / std::sqrt(2) * grad_u[2];
 
            eshelby_stress[1] -=
                sigma[3] / std::sqrt(2) * grad_u[0] + sigma[1] * grad_u[2];
 
            eshelby_stress[2] -=
                sigma[0] * grad_u[1] + sigma[3] / std::sqrt(2) * grad_u[3];
 
            eshelby_stress[3] -=
                sigma[3] / std::sqrt(2) * grad_u[1] + sigma[1] * grad_u[3];
 
            // for axial-symmetric case the following is not zero in general
            eshelby_stress[4] -= sigma[2] * grad_u[4];
        }
        else
        {
            OGS_FATAL(
                "Material forces not implemented for displacement "
                "dimension "
                "other than 2 and 3.");
        }
 
        auto const& w = _ip_data[ip].integration_weight;
        local_b += G.transpose() * eshelby_stress * w;
    }
 
    return nodal_values;
}

References ProcessLib::Deformation::computeGMatrix(), MathLib::createZeroedVector(), NumLib::interpolateXCoordinate(), OGS_FATAL, and ProcessLib::ConstitutiveRelations::StressData< DisplacementDim >::sigma.

Referenced by ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::getMaterialForces().

writeMaterialForces()

template<typename LocalAssemblerInterface >

void ProcessLib::SmallDeformation::writeMaterialForces	(	std::unique_ptr< GlobalVector > &	material_forces,
		std::vector< std::unique_ptr< LocalAssemblerInterface > > const &	local_assemblers,
		NumLib::LocalToGlobalIndexMap const &	local_to_global_index_map,
		GlobalVector const &	x )

Definition at line 159 of file MaterialForces.h.

{
    DBUG("Compute material forces for small deformation process.");
 
    // Prepare local storage and fetch values.
    MathLib::LinAlg::setLocalAccessibleVector(x);
 
    if (!material_forces)
    {
        material_forces =
            MathLib::MatrixVectorTraits<GlobalVector>::newInstance(x);
    }
 
    MathLib::LinAlg::set(*material_forces, 0);
 
    GlobalExecutor::executeDereferenced(
        [](const std::size_t mesh_item_id,
           LocalAssemblerInterface& local_assembler,
           const NumLib::LocalToGlobalIndexMap& dof_table,
           GlobalVector const& x,
           GlobalVector& node_values)
        {
            auto const indices = NumLib::getIndices(mesh_item_id, dof_table);
            std::vector<double> local_data;
            auto const local_x = x.get(indices);
 
            local_assembler.getMaterialForces(local_x, local_data);
 
            assert(local_data.size() == indices.size());
            node_values.add(indices, local_data);
        },
        local_assemblers, local_to_global_index_map, x, *material_forces);
    MathLib::LinAlg::finalizeAssembly(*material_forces);
}

References MathLib::EigenVector::add(), DBUG(), NumLib::SerialExecutor::executeDereferenced(), MathLib::LinAlg::finalizeAssembly(), MathLib::EigenVector::get(), NumLib::getIndices(), MathLib::LinAlg::set(), and MathLib::LinAlg::setLocalAccessibleVector().

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