MaterialLib Namespace Reference

Namespaces
namespace	Fluid
namespace	Fracture
namespace	PhysicalConstant
namespace	Solids

Functions
void	checkForWhitespaces (std::string_view part)
auto	expandRange (int start, int end)
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

checkForWhitespaces()

void MaterialLib::checkForWhitespaces

(

std::string_view

part

)

Checks that a string part contains no whitespace. Throws OGS_FATAL if any whitespace is found.

Definition at line 21 of file MediaCreation.cpp.

{
    if (std::ranges::any_of(
            part,
            [](char c) { return std::isspace(static_cast<unsigned char>(c)); }))
    {
        OGS_FATAL(
            "Whitespace is not allowed in ranges. Use 'start:end' without "
            "spaces around the colon.");
    }
}

References OGS_FATAL.

Referenced by splitMaterialIdString().

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 44 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().

expandRange()

auto MaterialLib::expandRange	(	int	start,
		int	end )

Creates a range of integers from start to end (inclusive). Throws OGS_FATAL if end < start.

Definition at line 35 of file MediaCreation.cpp.

{
    if (end < start)
    {
        OGS_FATAL(
            "Invalid range '{}:{}'. The end must be greater than or equal "
            "to the start.",
            start, end);
    }
    return ranges::views::iota(start, end + 1);
}

References OGS_FATAL.

Referenced by splitMaterialIdString().

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. Range syntax is supported with colon separator, e.g., "1:5" expands to "1,2,3,4,5". 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 102 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> const material_ids_of_this_medium =
            *material_ids | ranges::views::unique | ranges::to_vector |
            ranges::actions::sort | ranges::actions::unique |
            ranges::to<std::vector>;
        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 or ranges separated by comma.
    return splitMaterialIdString(material_id_string);
}

References DBUG(), 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 and/or ranges. Such lists occur in the medium definition in the OGS prj file. Range syntax is supported with colon separator, e.g., "1:5" expands to "1,2,3,4,5". Multiple entries are separated by comma, e.g., "-1:2,5,7:9" expands to "-1,0,1,2,5,7,8,9". Error messages in this function refer to this specific purpose.

Definition at line 47 of file MediaCreation.cpp.

{
    auto const material_ids_strings =
        BaseLib::splitString(material_id_string, ',');
 
    // Pre-allocate with estimated capacity (simplified heuristic)
    std::vector<int> material_ids;
    material_ids.reserve(material_ids_strings.size());
 
    for (std::string mid_str : material_ids_strings)
    {
        // Trim leading and trailing whitespace
        BaseLib::trim(mid_str);
 
        auto const parts =
            BaseLib::splitString(mid_str, ':') | ranges::to_vector;
        if (parts.size() == 2)
        {
            checkForWhitespaces(parts[0]);
            auto const start_id = BaseLib::parseInteger(parts[0]);
            if (!start_id)
            {
                OGS_FATAL("Could not parse material ID: {}", start_id.error());
            }
            checkForWhitespaces(parts[1]);
            auto const end_id = BaseLib::parseInteger(parts[1]);
            if (!end_id)
            {
                OGS_FATAL("Could not parse material ID: {}", end_id.error());
            }
            ranges::copy(expandRange(*start_id, *end_id),
                         std::back_inserter(material_ids));
        }
        else if (parts.size() == 1)
        {
            auto const material_id = BaseLib::parseInteger(mid_str);
            if (!material_id)
            {
                OGS_FATAL("Could not parse material ID: {}",
                          material_id.error());
            }
            material_ids.push_back(*material_id);
        }
        else
        {
            OGS_FATAL(
                "Could not parse material ID from '{}'. Invalid range format. "
                "Use 'start:end' for ranges or a single integer.",
                mid_str);
        }
    }
 
    return material_ids;
}

References checkForWhitespaces(), expandRange(), OGS_FATAL, BaseLib::parseInteger(), BaseLib::splitString(), and BaseLib::trim().

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