Classes
class	CollectIntegrationPointDataForExtrapolation
class	CollectIntegrationPointDataForIpWriter
struct	InternalVariablesCollection

Functions
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::shared_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::shared_ptr< SolidMaterial > > const &solid_materials, auto const &function)
template<typename LocalAssemblerInterface, typename SolidMaterial, typename AddSecondaryVariableCallback>
void	solidMaterialInternalToSecondaryVariables (std::map< int, std::shared_ptr< SolidMaterial > > const &solid_materials, AddSecondaryVariableCallback const &add_secondary_variable)
template<typename LocalAssemblerInterface, typename SolidMaterial>
void	solidMaterialInternalVariablesToIntegrationPointWriter (std::map< int, std::shared_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::shared_ptr< SolidMaterial > > const & solid_materials )

Definition at line 20 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 18 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 i = 0; i < NPOINTS; ++i)
            {
                auto G_col0 = g_matrix.col(i);
                auto G_col1 = g_matrix.col(i + NPOINTS);
                auto G_col2 = g_matrix.col(i + 2 * NPOINTS);
                auto const dNidx = dNdx.col(i);
 
                G_col0.template segment<DisplacementDim>(0).noalias() = dNidx;
                G_col1.template segment<DisplacementDim>(DisplacementDim)
                    .noalias() = dNidx;
                G_col2.template segment<DisplacementDim>(2 * DisplacementDim)
                    .noalias() = dNidx;
            }
 
            break;
        case 2:
            // The gradient coordinates are organized in the following order:
            // (1,1), (1,2)
            // (2,1), (2,2)
            // (3,3)
            for (int i = 0; i < NPOINTS; ++i)
            {
                auto G_col0 = g_matrix.col(i);
                auto G_col1 = g_matrix.col(i + NPOINTS);
                auto const dNidx = dNdx.col(i);
 
                G_col0.template segment<DisplacementDim>(0).noalias() = dNidx;
                G_col1.template segment<DisplacementDim>(DisplacementDim)
                    .noalias() = dNidx;
 
                if (is_axially_symmetric)
                {
                    G_col0[4] = N[i] / radius;
                }
            }
            break;
        default:
            break;
    }
}

Referenced by ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::NonLinearFbar::computeFBarInitialVariablesElementCenter(), ProcessLib::SmallDeformation::getMaterialForces(), and ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete().

◆ forEachSolidMaterialInternalVariable()

template<typename SolidMaterial>

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

Definition at line 102 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::shared_ptr< SolidMaterial > > const &	solid_materials,
		AddSecondaryVariableCallback const &	add_secondary_variable )

Definition at line 197 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().

◆ solidMaterialInternalVariablesToIntegrationPointWriter()

template<typename LocalAssemblerInterface, typename SolidMaterial>

void ProcessLib::Deformation::solidMaterialInternalVariablesToIntegrationPointWriter	(	std::map< int, std::shared_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 256 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);
}