Functions
void	readGeometry (std::string const &fname, GeoLib::GEOObjects &geo_objects, std::string const &dir_first, std::string const &dir_second)

std::unique_ptr< MeshLib::Mesh >	readSingleMesh (BaseLib::ConfigTree const &mesh_config_parameter, std::string const &directory)

std::vector< std::unique_ptr< MeshLib::Mesh > >	readMeshes (BaseLib::ConfigTree const &config, std::string const &directory, std::string const &project_directory)

std::vector< GeoLib::NamedRaster >	readRasters (BaseLib::ConfigTree const &config, std::string const &raster_directory, GeoLib::MinMaxPoints const &min_max_points)

Function Documentation

◆ readGeometry()

void anonymous_namespace{ProjectData.cpp}::readGeometry	(	std::string const &	fname,
		GeoLib::GEOObjects &	geo_objects,
		std::string const &	dir_first,
		std::string const &	dir_second )

Definition at line 165 of file ProjectData.cpp.

{
    DBUG("Reading geometry file '{:s}'.", fname);
    GeoLib::IO::BoostXmlGmlInterface gml_reader(geo_objects);
    std::string geometry_file = BaseLib::joinPaths(dir_first, fname);
    if (!BaseLib::IsFileExisting(geometry_file))
    {
        // Fallback to reading gml from prj-file directory
        geometry_file = BaseLib::joinPaths(dir_second, fname);
        WARN("File {:s} not found in {:s}! Trying reading from {:s}.", fname,
             dir_first, dir_second);
        if (!BaseLib::IsFileExisting(geometry_file))
        {
            OGS_FATAL("Could not read geometry file {:s} in {:s}.", fname,
                      dir_second);
        }
    }
    gml_reader.readFile(geometry_file);
}

References DBUG(), BaseLib::IsFileExisting(), BaseLib::joinPaths(), OGS_FATAL, GeoLib::IO::BoostXmlGmlInterface::readFile(), and WARN().

Referenced by readMeshes().

◆ readMeshes()

std::vector< std::unique_ptr< MeshLib::Mesh > > anonymous_namespace{ProjectData.cpp}::readMeshes	(	BaseLib::ConfigTree const &	config,
		std::string const &	directory,
		std::string const &	project_directory )

Input File Parameter: prj__meshes

Input File Parameter: prj__meshes__mesh

Input File Parameter: prj__geometry

Input File Parameter: prj__mesh

Input File Parameter: prj__geometry

Input File Parameter: prj__zero_mesh_field_data_by_material_ids

Definition at line 233 of file ProjectData.cpp.

{
    std::vector<std::unique_ptr<MeshLib::Mesh>> meshes;
 
    GeoLib::GEOObjects geoObjects;
 
    auto optional_meshes = config.getConfigSubtreeOptional("meshes");
    if (optional_meshes)
    {
        DBUG("Reading multiple meshes.");
        auto const configs = optional_meshes->getConfigParameterList("mesh");
        std::transform(configs.begin(), configs.end(),
                       std::back_inserter(meshes),
                       [&directory](auto const& mesh_config)
                       { return readSingleMesh(mesh_config, directory); });
        if (auto const geometry_file_name =
            config.getConfigParameterOptional<std::string>("geometry"))
        {
            readGeometry(*geometry_file_name, geoObjects, directory,
                         project_directory);
        }
    }
    else
    {  // Read single mesh with geometry.
        meshes.push_back(
            readSingleMesh(config.getConfigParameter("mesh"), directory));
 
        auto const geometry_file_name =
            config.getConfigParameter<std::string>("geometry");
        readGeometry(geometry_file_name, geoObjects, directory,
                     project_directory);
    }
 
    if (!geoObjects.getPoints().empty() || !geoObjects.getPolylines().empty() ||
        !geoObjects.getSurfaces().empty())
    {  // generate meshes from geometries
        std::unique_ptr<MeshGeoToolsLib::SearchLength> search_length_algorithm =
            MeshGeoToolsLib::createSearchLengthAlgorithm(config, *meshes[0]);
        bool const multiple_nodes_allowed = false;
        auto additional_meshes =
            MeshGeoToolsLib::constructAdditionalMeshesFromGeoObjects(
                geoObjects, *meshes[0], std::move(search_length_algorithm),
                multiple_nodes_allowed);
 
        std::move(begin(additional_meshes), end(additional_meshes),
                  std::back_inserter(meshes));
    }
 
    auto mesh_names = MeshLib::views::names | ranges::to<std::vector>() |
                      ranges::actions::sort;
    auto const sorted_names = meshes | mesh_names;
    auto const unique_names = meshes | mesh_names | ranges::actions::unique;
    if (unique_names.size() < sorted_names.size())
    {
        WARN(
            "Mesh names aren't unique. From project file read mesh names are:");
        for (auto const& name : meshes | MeshLib::views::names)
        {
            INFO("- {}", name);
        }
    }
 
    auto const zero_mesh_field_data_by_material_ids =
        config.getConfigParameterOptional<std::vector<int>>(
            "zero_mesh_field_data_by_material_ids");
    if (zero_mesh_field_data_by_material_ids)
    {
        WARN(
            "Tag 'zero_mesh_field_data_by_material_ids` is experimental. Its "
            "name may be changed, or it may be removed due to its "
            "corresponding feature becomes a single tool. Please use it with "
            "care!");
        MeshToolsLib::zeroMeshFieldDataByMaterialIDs(
            *meshes[0], *zero_mesh_field_data_by_material_ids);
    }
 
    MeshLib::setMeshSpaceDimension(meshes);
 
    return meshes;
}

References MeshGeoToolsLib::constructAdditionalMeshesFromGeoObjects(), MeshGeoToolsLib::createSearchLengthAlgorithm(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtreeOptional(), GeoLib::GEOObjects::getPoints(), GeoLib::GEOObjects::getPolylines(), GeoLib::GEOObjects::getSurfaces(), INFO(), MeshLib::views::names, readGeometry(), readSingleMesh(), MeshLib::setMeshSpaceDimension(), WARN(), and MeshToolsLib::zeroMeshFieldDataByMaterialIDs().

◆ readRasters()

std::vector< GeoLib::NamedRaster > anonymous_namespace{ProjectData.cpp}::readRasters	(	BaseLib::ConfigTree const &	config,
		std::string const &	raster_directory,
		GeoLib::MinMaxPoints const &	min_max_points )

Input File Parameter: prj__rasters

Input File Parameter: prj__rasters__raster

Definition at line 322 of file ProjectData.cpp.

{
    INFO("readRasters ...");
    std::vector<GeoLib::NamedRaster> named_rasters;
 
    auto optional_rasters = config.getConfigSubtreeOptional("rasters");
    if (optional_rasters)
    {
        auto const configs = optional_rasters->getConfigSubtreeList("raster");
        std::transform(
            configs.begin(), configs.end(), std::back_inserter(named_rasters),
            [&raster_directory, &min_max_points](auto const& raster_config)
            {
                return GeoLib::IO::readRaster(raster_config, raster_directory,
                                              min_max_points);
            });
    }
    INFO("readRasters done");
    return named_rasters;
}

References BaseLib::ConfigTree::getConfigSubtreeOptional(), and INFO().

◆ readSingleMesh()

std::unique_ptr< MeshLib::Mesh > anonymous_namespace{ProjectData.cpp}::readSingleMesh	(	BaseLib::ConfigTree const &	mesh_config_parameter,
		std::string const &	directory )

Input File Parameter: prj__meshes__mesh__axially_symmetric

Input File Parameter: prj__mesh__axially_symmetric

Definition at line 186 of file ProjectData.cpp.

{
    std::string const mesh_file = BaseLib::joinPaths(
        directory, mesh_config_parameter.getValue<std::string>());
    DBUG("Reading mesh file '{:s}'.", mesh_file);
 
    auto mesh = std::unique_ptr<MeshLib::Mesh>(MeshLib::IO::readMeshFromFile(
        mesh_file, true /* compute_element_neighbors */));
    if (!mesh)
    {
        std::filesystem::path abspath{mesh_file};
        try
        {
            abspath = std::filesystem::absolute(mesh_file);
        }
        catch (std::filesystem::filesystem_error const& e)
        {
            ERR("Determining the absolute path of '{}' failed: {}", mesh_file,
                e.what());
        }
 
        OGS_FATAL("Could not read mesh from '{:s}' file. No mesh added.",
                  abspath.string());
    }
 
#ifdef DOXYGEN_DOCU_ONLY
    mesh_config_parameter.getConfigAttributeOptional<bool>("axially_symmetric");
#endif  // DOXYGEN_DOCU_ONLY
 
    if (auto const axially_symmetric =
        mesh_config_parameter.getConfigAttributeOptional<bool>(
            "axially_symmetric"))
    {
        mesh->setAxiallySymmetric(*axially_symmetric);
        if (mesh->getDimension() == 3 && mesh->isAxiallySymmetric())
        {
            OGS_FATAL("3D mesh cannot be axially symmetric.");
        }
    }
 
    return mesh;
}