MaterialLib Namespace Reference

Detailed Description

Common convenitions for naming: x_D - deviatoric part of tensor x x_V - volumetric part of tensor x x_p - a variable related to plastic potential x_prev - value of x in previous time step

Variables used in the code: eps_D - deviatoric strain eps_p_D_dot - deviatoric increment of plastic strain eps_p_eff_dot - increment of effective plastic strain eps_p_V_dot - volumetric increment of plastic strain sigma_D_inverse_D - deviatoric part of sigma_D_inverse

derivation of the flow rule theta - J3 / J2^(3 / 2) from yield function dtheta_dsigma - derivative of theta sqrtPhi - square root of Phi from plastic potential flow_D - deviatoric part of flow flow_V - volumetric part of flow lambda_flow_D - deviatoric increment of plastic strain

Namespaces
namespace	Fluid
namespace	Fracture
namespace	PhysicalConstant
namespace	PorousMedium
namespace	Solids

Functions
std::vector< int >	splitMaterialIdString (std::string const &material_id_string)
std::vector< int >	parseMaterialIdString (std::string const &material_id_string, MeshLib::PropertyVector< int > const *const material_ids)
template<typename T , typename CreateMedium > requires std::convertible_to< decltype(std::declval<CreateMedium>()(std::declval<int>())), std::shared_ptr<T>>
void	createMediumForId (int const id, std::map< int, std::shared_ptr< T > > &media, std::vector< int > const &material_ids_of_this_medium, CreateMedium &&create_medium)

Function Documentation

createMediumForId()

template<typename T , typename CreateMedium >
requires std::convertible_to< decltype(std::declval<CreateMedium>()(std::declval<int>())), std::shared_ptr<T>>

void MaterialLib::createMediumForId	(	int const	id,
		std::map< int, std::shared_ptr< T > > &	media,
		std::vector< int > const &	material_ids_of_this_medium,
		CreateMedium &&	create_medium )

Creates a new entry for the material id in the media map by either calling the create_medium function and creating a new shared pointer, or by reusing the existing shared pointer.

Definition at line 46 of file MediaCreation.h.

{
    if (media.find(id) != end(media))
    {
        OGS_FATAL(
            "Multiple media were specified for the same material id '{:d}'. "
            "Keep in mind, that if no material id is specified, it is assumed "
            "to be 0 by default.",
            id);
    }
 
    if (id == material_ids_of_this_medium[0])
    {
        media[id] = create_medium(id);
    }
    else
    {
        media[id] = media[material_ids_of_this_medium[0]];
    }
}

References OGS_FATAL.

Referenced by MaterialLib::Solids::createConstitutiveRelationsGeneric(), and ProjectData::parseMedia().

parseMaterialIdString()

std::vector< int > MaterialLib::parseMaterialIdString	(	std::string const &	material_id_string,
		MeshLib::PropertyVector< int > const *const	material_ids )

Parses a comma separated list of integers or "*" string. Such lists occur in the medium definition in the OGS prj file. For the "*" input a vector of all (unique) material ids is returned. Error messages in this function refer to this specific purpose.

Definition at line 71 of file MediaCreation.cpp.

{
    if (material_id_string == "*")
    {
        if (material_ids == nullptr)
        {
            OGS_FATAL(
                "MaterialIDs property is not defined in the mesh but it is "
                "required to parse '*' definition.");
        }
 
        std::vector<int> material_ids_of_this_medium =
            *material_ids |
            ranges::views::adjacent_remove_if(std::equal_to<>()) |
            ranges::to_vector;
        BaseLib::makeVectorUnique(material_ids_of_this_medium);
        DBUG("Catch all medium definition for material ids {}.",
             fmt::join(material_ids_of_this_medium, ", "));
        return material_ids_of_this_medium;
    }
 
    // Usual case of ids separated by comma.
    return splitMaterialIdString(material_id_string);
}

References DBUG(), BaseLib::makeVectorUnique(), OGS_FATAL, and splitMaterialIdString().

Referenced by MaterialLib::Solids::createConstitutiveRelationsGeneric(), and ProjectData::parseMedia().

splitMaterialIdString()

std::vector< int > MaterialLib::splitMaterialIdString

(

std::string const &

material_id_string

)

Parses a comma separated list of integers. Such lists occur in the medium definition in the OGS prj file. Error messages in this function refer to this specific purpose.

Definition at line 21 of file MediaCreation.cpp.

{
    auto const material_ids_strings =
        BaseLib::splitString(material_id_string, ',');
 
    std::vector<int> material_ids;
    for (auto& mid_str : material_ids_strings)
    {
        std::size_t num_chars_processed = 0;
        int material_id;
        try
        {
            material_id = std::stoi(mid_str, &num_chars_processed);
        }
        catch (std::invalid_argument&)
        {
            OGS_FATAL(
                "Could not parse material ID from '{}' to a valid integer.",
                mid_str);
        }
        catch (std::out_of_range&)
        {
            OGS_FATAL(
                "Could not parse material ID from '{}'. The integer value of "
                "the given string exceeds the permitted range.",
                mid_str);
        }
 
        if (num_chars_processed != mid_str.size())
        {
            // Not the whole string has been parsed. Check the rest.
            if (auto const it = std::find_if_not(
                    begin(mid_str) + num_chars_processed, end(mid_str),
                    [](unsigned char const c) { return std::isspace(c); });
                it != end(mid_str))
            {
                OGS_FATAL(
                    "Could not parse material ID from '{}'. Please separate "
                    "multiple material IDs by comma only. Invalid character: "
                    "'{}' at position {}.",
                    mid_str, *it, distance(begin(mid_str), it));
            }
        }
 
        material_ids.push_back(material_id);
    };
 
    return material_ids;
}

References OGS_FATAL, and BaseLib::splitString().

Referenced by ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess(), parseMaterialIdString(), and parseOutputMeshConfig().