#include "ProjectData.h"
#include <pybind11/eval.h>
#include <spdlog/fmt/ranges.h>
#include <algorithm>
#include <boost/algorithm/string/predicate.hpp>
#include <cctype>
#include <range/v3/algorithm/contains.hpp>
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/adjacent_remove_if.hpp>
#include <set>
#include "BaseLib/Algorithm.h"
#include "BaseLib/ConfigTree.h"
#include "BaseLib/FileTools.h"
#include "BaseLib/Logging.h"
#include "BaseLib/StringTools.h"
#include "GeoLib/GEOObjects.h"
#include "GeoLib/IO/AsciiRasterInterface.h"
#include "GeoLib/IO/NetCDFRasterReader.h"
#include "GeoLib/Raster.h"
#include "InfoLib/CMakeInfo.h"
#include "MaterialLib/MPL/CreateMedium.h"
#include "MaterialLib/Utils/MediaCreation.h"
#include "MathLib/Curve/CreatePiecewiseLinearCurve.h"
#include "MathLib/LinAlg/EigenLis/LinearSolverOptionsParser.h"
#include "MeshGeoToolsLib/ConstructMeshesFromGeometries.h"
#include "MeshGeoToolsLib/CreateSearchLength.h"
#include "MeshGeoToolsLib/SearchLength.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/MeshEnums.h"
#include "MeshLib/NodePartitionedMesh.h"
#include "MeshLib/Utils/SetMeshSpaceDimension.h"
#include "MeshToolsLib/OverwriteMeshFieldDataByMaterialIDs.h"
#include "NumLib/ODESolver/ConvergenceCriterion.h"
#include "ParameterLib/Utils.h"
#include "ProcessLib/CreateJacobianAssembler.h"
#include "ProcessLib/DeactivatedSubdomain.h"
#include "GeoLib/IO/XmlIO/Boost/BoostXmlGmlInterface.h"
#include "MeshLib/IO/readMeshFromFile.h"
#include "ParameterLib/ConstantParameter.h"
#include "ParameterLib/CreateCoordinateSystem.h"
#include "ProcessLib/CreateTimeLoop.h"
#include "ProcessLib/TimeLoop.h"

Include dependency graph for ProjectData.cpp:

Namespaces
namespace	anonymous_namespace{ProjectData.cpp}

Functions
void	parseOverwriteMeshData (BaseLib::ConfigTree const &project_config, std::vector< MeshToolsLib::InitialConditionDataSet > &data_initial_conditions, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
void	anonymous_namespace{ProjectData.cpp}::readGeometry (std::string const &fname, GeoLib::GEOObjects &geo_objects, std::string const &dir_first, std::string const &dir_second)
std::unique_ptr< MeshLib::Mesh >	anonymous_namespace{ProjectData.cpp}::readSingleMesh (BaseLib::ConfigTree const &mesh_config_parameter, std::string const &directory)
std::vector< std::unique_ptr< MeshLib::Mesh > >	anonymous_namespace{ProjectData.cpp}::readMeshes (BaseLib::ConfigTree const &config, std::string const &directory)
std::vector< GeoLib::NamedRaster >	anonymous_namespace{ProjectData.cpp}::readRasters (BaseLib::ConfigTree const &config, GeoLib::MinMaxPoints const &min_max_points)

Function Documentation

◆ parseOverwriteMeshData()

void parseOverwriteMeshData	(	BaseLib::ConfigTree const &	project_config,
		std::vector< MeshToolsLib::InitialConditionDataSet > &	data_initial_conditions,
		std::vector< std::unique_ptr< MeshLib::Mesh > > const &	meshes,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Handles <remove>, <set>, and <take_original> sub-elements of

Input File Parameter: prj__overwrite_mesh_data.

For <remove>: field_name, mesh_name, mesh_item_type For <set>/<take_original>: field_name, mesh_name, mesh_item_type, material_ids, parameter_name

Input File Parameter: prj__overwrite_mesh_data

Input File Parameter: prj__overwrite_mesh_data__remove__field_name

Input File Parameter: prj__overwrite_mesh_data__remove__mesh

Input File Parameter: prj__overwrite_mesh_data__remove__mesh_item_type

Input File Parameter: prj__overwrite_mesh_data__take_original__field_name

Input File Parameter

Input File Parameter: prj__overwrite_mesh_data__take_original__mesh

Input File Parameter

Input File Parameter: prj__overwrite_mesh_data__take_original__mesh_item_type

Input File Parameter

Input File Parameter: prj__overwrite_mesh_data__take_original__material_ids

Input File Parameter: prj__overwrite_mesh_data__set__field_name

Input File Parameter: prj__overwrite_mesh_data__set__mesh

Input File Parameter: prj__overwrite_mesh_data__set__mesh_item_type

Input File Parameter: prj__overwrite_mesh_data__set__material_ids

Input File Parameter: prj__overwrite_mesh_data__set__parameter_name

Definition at line 54 of file ProjectData.cpp.

{
    auto const overwrite_mesh_data_config =
        project_config.getConfigSubtreeOptional("overwrite_mesh_data");
    if (!overwrite_mesh_data_config)
    {
        return;
    }
 
    for (auto const& [tag, config] :
         overwrite_mesh_data_config->getAllChildren())
    {
        if (tag == "remove")
        {
            auto const field_name =
                config->getConfigParameter<std::string>("field_name");
            auto const mesh_name = config->getConfigParameter<std::string>(
                "mesh", meshes[0]->getName());
            auto& mesh = MeshLib::findMeshByName(meshes, mesh_name);
            auto const mesh_item_type = MeshLib::string2MeshItemType(
                config->getConfigParameter<std::string>("mesh_item_type"));
 
            MeshLib::Properties& properties = mesh.getProperties();
            if (properties.template hasPropertyVector<double>(field_name,
                                                              mesh_item_type))
            {
                DBUG("remove property: {}", field_name);
                properties.removePropertyVector(field_name);
            }
            continue;
        }
 
        if (tag == "set" || tag == "take_original")
        {
            // The "take_original" element shares the parsing code below with
            // "set", so its parameters are documented separately here.
            auto const field_name =
                config->getConfigParameter<std::string>("field_name");
            auto const mesh_name = config->getConfigParameter<std::string>(
                "mesh", meshes[0]->getName());
            auto& mesh = MeshLib::findMeshByName(meshes, mesh_name);
            auto const mesh_item_type = MeshLib::string2MeshItemType(
                config->getConfigParameter<std::string>("mesh_item_type"));
 
            // string2MeshItemType() also accepts 'edge' and 'face', but the
            // overwrite only supports node, cell and integration-point data.
            // Reject the unsupported types here so the user gets a clear error
            // at project-file parsing time instead of a fatal later during the
            // overwrite.
            if (mesh_item_type != MeshLib::MeshItemType::Node &&
                mesh_item_type != MeshLib::MeshItemType::Cell &&
                mesh_item_type != MeshLib::MeshItemType::IntegrationPoint)
            {
                OGS_FATAL(
                    "overwrite_mesh_data: <{:s}> with mesh_item_type '{:s}' is "
                    "not supported. Only 'node', 'cell' and "
                    "'integration_point' "
                    "can be overwritten.",
                    tag, MeshLib::toString(mesh_item_type));
            }
 
            // Genuine multi-rank PETSc partition: each rank holds only a local
            // mesh slice. Material-id selection and node writes not implemented
            // there. Single-thread wrapper (serial / 1 rank) covers whole mesh,
            // so allowed.
            auto const* const partitioned_mesh =
                dynamic_cast<MeshLib::NodePartitionedMesh const*>(&mesh);
            bool const is_partition =
                partitioned_mesh && !partitioned_mesh->isForSingleThread();
 
            if (is_partition && mesh_item_type == MeshLib::MeshItemType::Node)
            {
                OGS_FATAL(
                    "overwrite_mesh_data: <{:s}> modifying node data is not "
                    "implemented for partitioned (PETSc) meshes.",
                    tag);
            }
 
            auto const selected_material_ids_string =
                config->getConfigParameter<std::string>("material_ids", "0");
            auto const* const material_ids = MeshLib::materialIDs(mesh);
 
            std::vector<std::size_t> element_ids_for_selected_materials;
            if (material_ids == nullptr)
            {
                // The mesh has no MaterialIDs: treat it as a single material-0
                // region rather than injecting a permanent MaterialIDs
                // property (which would leak into the output and into any
                // downstream code that branches on materialIDs() being
                // present).
                if (selected_material_ids_string != "0" &&
                    selected_material_ids_string != "*")
                {
                    OGS_FATAL(
                        "overwrite_mesh_data: mesh '{:s}' has no MaterialIDs, "
                        "so material_ids='{:s}' cannot be resolved. Only '0' "
                        "or '*' are valid in this case.",
                        mesh_name, selected_material_ids_string);
                }
                element_ids_for_selected_materials =
                    ranges::views::iota(std::size_t{0},
                                        mesh.getNumberOfElements()) |
                    ranges::to<std::vector>;
            }
            else
            {
                // Specific material subset: depends on material ids, cannot
                // resolve against partition-local subset. "*" (whole mesh)
                // exempt.
                if (is_partition && selected_material_ids_string != "*")
                {
                    OGS_FATAL(
                        "overwrite_mesh_data: <{:s}> material-id-based "
                        "selection (material_ids='{:s}') is not implemented "
                        "for "
                        "partitioned (PETSc) meshes.",
                        tag, selected_material_ids_string);
                }
                std::set<int> const selected_material_ids =
                    MaterialLib::parseMaterialIdString(
                        selected_material_ids_string, material_ids, ' ',
                        /*validate=*/true) |
                    ranges::to<std::set<int>>();
                element_ids_for_selected_materials =
                    ranges::views::iota(std::size_t{0}, material_ids->size()) |
                    ranges::views::filter(
                        [&](std::size_t const i)
                        {
                            return selected_material_ids.contains(
                                (*material_ids)[i]);
                        }) |
                    ranges::to<std::vector>;
            }
 
            // For \c set, get parameter_name; for \c take_original, it's
            // empty
            auto const& parameter_name =
                tag == "set"
                    ? config->getConfigParameterOptional<std::string>(
                          "parameter_name")
                    : std::optional<std::string>{};
 
            if (tag == "set" && !parameter_name)
            {
                OGS_FATAL(
                    "\"set\" element requires a parameter_name attribute.");
            }
 
            auto const parameter =
                !parameter_name || parameter_name->empty()
                    ? static_cast<ParameterLib::Parameter<double>*>(nullptr)
                    : &ParameterLib::findParameter<double>(
                          *parameter_name, parameters, 0, nullptr);
            data_initial_conditions.emplace_back(
                field_name,
                std::move(element_ids_for_selected_materials),
                nullptr,
                &mesh,
                parameter,
                mesh_item_type);
            continue;
        }
 
        OGS_FATAL(
            "Unknown element <{:s}> in <overwrite_mesh_data>. Expected one of "
            "<remove>, <set>, or <take_original>.",
            tag);
    }
}

References MeshLib::Cell, DBUG(), MeshLib::findMeshByName(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigSubtreeOptional(), MeshLib::IntegrationPoint, MeshLib::NodePartitionedMesh::isForSingleThread(), MeshLib::materialIDs(), MeshLib::Node, OGS_FATAL, MaterialLib::parseMaterialIdString(), MeshLib::Properties::removePropertyVector(), MeshLib::string2MeshItemType(), and MeshLib::toString().

Namespaces

Functions

Function Documentation

◆ parseOverwriteMeshData()