ProcessLib::Deformation Namespace Reference

Classes
class	CollectIntegrationPointDataForExtrapolation
class	CollectIntegrationPointDataForIpWriter
struct	InternalVariablesCollection

Functions
template<int DisplacementDim, int NPOINTS, typename DNDX_Type >
double	divergence (const Eigen::Ref< Eigen::Matrix< double, NPOINTS *DisplacementDim, 1 > const > &u, DNDX_Type const &dNdx)
	Divergence of displacement, the volumetric strain.
template<int DisplacementDim, int NPOINTS, typename N_Type , typename DNDX_Type , typename GMatrixType >
void	computeGMatrix (DNDX_Type const &dNdx, GMatrixType &g_matrix, const bool is_axially_symmetric, N_Type const &N, const double radius)
	Fills a G-matrix based on given shape function dN/dx values.
template<typename SolidMaterial >
std::map< std::string, std::vector< std::pair< int, typename SolidMaterial::InternalVariable > > >	collectInternalVariables (std::map< int, std::unique_ptr< SolidMaterial > > const &solid_materials)
template<typename Pair >
	InternalVariablesCollection (std::vector< Pair > &&, int, bool) -> InternalVariablesCollection< typename Pair::second_type >
template<typename SolidMaterial >
void	forEachSolidMaterialInternalVariable (std::map< int, std::unique_ptr< SolidMaterial > > const &solid_materials, auto const &function)
template<typename LocalAssemblerInterface , typename SolidMaterial , typename AddSecondaryVariableCallback >
void	solidMaterialInternalToSecondaryVariables (std::map< int, std::unique_ptr< SolidMaterial > > const &solid_materials, AddSecondaryVariableCallback const &add_secondary_variable)
template<typename LocalAssemblerInterface , typename SolidMaterial >
void	solidMaterialInternalVariablesToIntegrationPointWriter (std::map< int, std::unique_ptr< SolidMaterial > > const &solid_materials, std::vector< std::unique_ptr< LocalAssemblerInterface > > const &local_assemblers, std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > &integration_point_writer, int const integration_order)

Function Documentation

collectInternalVariables()

template<typename SolidMaterial >

std::map< std::string, std::vector< std::pair< int, typename SolidMaterial::InternalVariable > > > ProcessLib::Deformation::collectInternalVariables

(

std::map< int, std::unique_ptr< SolidMaterial > > const &

solid_materials

)

Definition at line 27 of file SolidMaterialInternalToSecondaryVariables.h.

{
    assert(!solid_materials.empty());
 
    // For each name of an internal variable collect all solid material/
    // internal variable pairs.
    std::map<
        std::string,
        std::vector<std::pair<int, typename SolidMaterial::InternalVariable>>>
        internal_variables_by_name;
    for (auto const& [material_id, solid_material] : solid_materials)
    {
        auto const& internal_variables = solid_material->getInternalVariables();
        for (auto const& iv : internal_variables)
        {
            internal_variables_by_name[iv.name].push_back({material_id, iv});
        }
    }
 
    // Check for each internal variable name, that the number of components is
    // equal for all materials.
    for (auto const& [name, mat_iv_collection] : internal_variables_by_name)
    {
        if (mat_iv_collection.empty())
        {
            continue;
        }
        auto const num_components =
            mat_iv_collection.front().second.num_components;
 
        if (!std::all_of(
                begin(mat_iv_collection), end(mat_iv_collection),
                [num_components](auto const& mat_iv)
                { return mat_iv.second.num_components == num_components; }))
        {
            OGS_FATAL(
                "Not for all material ids the secondary variable '{:s}' has "
                "{:d} components.",
                name, num_components);
        }
    }
 
    return internal_variables_by_name;
}

References OGS_FATAL.

Referenced by forEachSolidMaterialInternalVariable().

computeGMatrix()

template<int DisplacementDim, int NPOINTS, typename N_Type , typename DNDX_Type , typename GMatrixType >

void ProcessLib::Deformation::computeGMatrix	(	DNDX_Type const &	dNdx,
		GMatrixType &	g_matrix,
		const bool	is_axially_symmetric,
		N_Type const &	N,
		const double	radius )

Fills a G-matrix based on given shape function dN/dx values.

Definition at line 25 of file GMatrix.h.

{
    static_assert(0 < DisplacementDim && DisplacementDim <= 3,
                  "LinearGMatrix::computeGMatrix: DisplacementDim must be in "
                  "range [1,3].");
 
    g_matrix.setZero();
 
    switch (DisplacementDim)
    {
        case 3:
            // The gradient coordinates are organized in the following order:
            // (1,1), (1,2), (1,3)
            // (2,1), (2,2), (2,3)
            // (3,1), (3,2), (3,3)
            for (int d = 0; d < DisplacementDim; ++d)
            {
                for (int i = 0; i < NPOINTS; ++i)
                {
                    g_matrix(d + 0 * DisplacementDim, i + 0 * NPOINTS) =
                        dNdx(d, i);
                    g_matrix(d + 1 * DisplacementDim, i + 1 * NPOINTS) =
                        dNdx(d, i);
                    g_matrix(d + 2 * DisplacementDim, i + 2 * NPOINTS) =
                        dNdx(d, i);
                }
            }
            break;
        case 2:
            // The gradient coordinates are organized in the following order:
            // (1,1), (1,2)
            // (2,1), (2,2)
            // (3,3)
            for (int d = 0; d < DisplacementDim; ++d)
            {
                for (int i = 0; i < NPOINTS; ++i)
                {
                    g_matrix(d, i) = dNdx(d, i);
                    g_matrix(d + DisplacementDim, i + NPOINTS) = dNdx(d, i);
                }
            }
            if (is_axially_symmetric)
            {
                for (int i = 0; i < NPOINTS; ++i)
                {
                    g_matrix(4, i) = N[i] / radius;
                }
            }
            break;
        default:
            break;
    }
}

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

divergence()

template<int DisplacementDim, int NPOINTS, typename DNDX_Type >

double ProcessLib::Deformation::divergence	(	const Eigen::Ref< Eigen::Matrix< double, NPOINTS *DisplacementDim, 1 > const > &	u,
		DNDX_Type const &	dNdx )

Divergence of displacement, the volumetric strain.

Definition at line 19 of file Divergence.h.

{
    double divergence = 0;
    for (int i = 0; i < DisplacementDim; ++i)
    {
        divergence += dNdx.template block<1, NPOINTS>(i, 0) *
                      u.template segment<NPOINTS>(i * NPOINTS);
    }
    return divergence;
}

References divergence().

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::computeCrackIntegral(), and divergence().

forEachSolidMaterialInternalVariable()

template<typename SolidMaterial >

void ProcessLib::Deformation::forEachSolidMaterialInternalVariable	(	std::map< int, std::unique_ptr< SolidMaterial > > const &	solid_materials,
		auto const &	function )

Definition at line 109 of file SolidMaterialInternalToSecondaryVariables.h.

{
    auto internal_variables_by_name = collectInternalVariables(solid_materials);
 
    // Multiple material ids could be present but only one material for the
    // whole domain. In this case the choice of callbacks is independent of
    // local assembler's material id, and the material id is 0.
    // \see selectSolidConstitutiveRelation() for material id logic.
    bool const material_id_independent = solid_materials.size() == 1;
 
    // Create *single* callback passing all solid materials to it. Choose
    // correct solid material based on the local assembler's solid material in
    // the callback.
    for (auto&& [name, mat_iv_collection] : internal_variables_by_name)
    {
        auto const num_components =
            mat_iv_collection.front().second.num_components;
 
        function(name,
                 InternalVariablesCollection{std::move(mat_iv_collection),
                                             num_components,
                                             material_id_independent});
    }
}

References collectInternalVariables().

Referenced by solidMaterialInternalToSecondaryVariables(), and solidMaterialInternalVariablesToIntegrationPointWriter().

InternalVariablesCollection()

template<typename Pair >

ProcessLib::Deformation::InternalVariablesCollection	(	std::vector< Pair > &&	,
		int	,
		bool	) -> InternalVariablesCollection< typename Pair::second_type >

solidMaterialInternalToSecondaryVariables()

template<typename LocalAssemblerInterface , typename SolidMaterial , typename AddSecondaryVariableCallback >

void ProcessLib::Deformation::solidMaterialInternalToSecondaryVariables	(	std::map< int, std::unique_ptr< SolidMaterial > > const &	solid_materials,
		AddSecondaryVariableCallback const &	add_secondary_variable )

Definition at line 204 of file SolidMaterialInternalToSecondaryVariables.h.

{
    auto register_secondary_variable =
        [&add_secondary_variable](
            std::string const& name,
            InternalVariablesCollection<
                typename SolidMaterial::InternalVariable>&&
                internal_variables_collection)
    {
        DBUG("Registering internal variable {:s}.", name);
 
        add_secondary_variable(name,
                               internal_variables_collection.num_components,
                               CollectIntegrationPointDataForExtrapolation{
                                   std::move(internal_variables_collection)});
    };
 
    forEachSolidMaterialInternalVariable(solid_materials,
                                         register_secondary_variable);
}

References DBUG(), and forEachSolidMaterialInternalVariable().

Referenced by ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >::initializeConcreteProcess().

solidMaterialInternalVariablesToIntegrationPointWriter()

template<typename LocalAssemblerInterface , typename SolidMaterial >

void ProcessLib::Deformation::solidMaterialInternalVariablesToIntegrationPointWriter	(	std::map< int, std::unique_ptr< SolidMaterial > > const &	solid_materials,
		std::vector< std::unique_ptr< LocalAssemblerInterface > > const &	local_assemblers,
		std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > &	integration_point_writer,
		int const	integration_order )

Definition at line 263 of file SolidMaterialInternalToSecondaryVariables.h.

{
    auto add_integration_point_writer =
        [&local_assemblers, &integration_point_writer, integration_order](
            std::string const& name,
            InternalVariablesCollection<
                typename SolidMaterial::InternalVariable>&&
                internal_variables_collection)
    {
        DBUG("Creating integration point writer for  internal variable {:s}.",
             name);
 
        integration_point_writer.emplace_back(
            std::make_unique<MeshLib::IntegrationPointWriter>(
                "material_state_variable_" + name + "_ip",
                internal_variables_collection.num_components, integration_order,
                local_assemblers,
                CollectIntegrationPointDataForIpWriter{
                    std::move(internal_variables_collection)}));
    };
 
    forEachSolidMaterialInternalVariable(solid_materials,
                                         add_integration_point_writer);
}

References DBUG(), and forEachSolidMaterialInternalVariable().

Referenced by ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >::initializeConcreteProcess().