Detailed Description

Implementation of the project data class.

Author: Karsten Rink

Date: 2010-08-25

Copyright: Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

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

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

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

std::optional< ParameterLib::CoordinateSystem >	parseLocalCoordinateSystem (std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)

Function Documentation

◆ parseLocalCoordinateSystem()

std::optional<ParameterLib::CoordinateSystem> anonymous_namespace{ProjectData.cpp}::parseLocalCoordinateSystem	(	std::optional< BaseLib::ConfigTree > const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:: prj__local_coordinate_system__basis_vector_0

Input File Parameter:: prj__local_coordinate_system__basis_vector_1

Input File Parameter:: prj__local_coordinate_system__basis_vector_2

Definition at line 224 of file ProjectData.cpp.

 {
     if (!config)
     {
         return {};
     }
  
     DBUG("Reading coordinate system configuration.");
  
     //
     // Fetch the first basis vector; its length defines the dimension.
     //
     auto const& basis_vector_0 = ParameterLib::findParameter<double>(
         *config,
         "basis_vector_0", parameters, 0 /* any dimension */);
     int const dimension = basis_vector_0.getNumberOfGlobalComponents();
  
     // check dimension
     if (dimension != 2 && dimension != 3)
     {
         OGS_FATAL(
             "Basis vector parameter '{:s}' must have two or three components, "
             "but it has {:d}.",
             basis_vector_0.name, dimension);
     }
  
     //
     // Fetch the second basis vector, which must be of the same dimension as the
     // first one.
     //
     auto const& basis_vector_1 = ParameterLib::findParameter<double>(
         *config,
         "basis_vector_1", parameters, dimension);
  
     //
     // For two dimensions, we are done; construct coordinate system;
     //
     if (dimension == 2)
     {
         return ParameterLib::CoordinateSystem{basis_vector_0, basis_vector_1};
     }
  
     //
     // Parse the third vector, for three dimensions.
     //
     auto const& basis_vector_2 = ParameterLib::findParameter<double>(
         *config,
         "basis_vector_2", parameters, dimension);
     return ParameterLib::CoordinateSystem{basis_vector_0, basis_vector_1,
                                           basis_vector_2};
 }

References DBUG(), and OGS_FATAL.

Referenced by ProjectData::ProjectData().

◆ readGeometry()

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

Definition at line 133 of file ProjectData.cpp.

 {
     DBUG("Reading geometry file '{:s}'.", fname);
     GeoLib::IO::BoostXmlGmlInterface gml_reader(geo_objects);
     gml_reader.readFile(fname);
 }

References DBUG(), and GeoLib::IO::BoostXmlGmlInterface::readFile().

◆ readMeshes()

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

Input File Parameter:: prj__meshes

Input File Parameter:: prj__meshes__mesh

Input File Parameter:: prj__mesh

Input File Parameter:: prj__geometry

Definition at line 172 of file ProjectData.cpp.

 {
     std::vector<std::unique_ptr<MeshLib::Mesh>> meshes;
  
     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),
             [&project_directory](auto const& mesh_config)
             { return readSingleMesh(mesh_config, project_directory); });
     }
     else
     {  // Read single mesh with geometry.
         WARN(
             "Consider switching from mesh and geometry input to multiple "
             "meshes input. See "
             "https://www.opengeosys.org/docs/tools/meshing-submeshes/"
             "constructmeshesfromgeometry/ tool for conversion.");
         meshes.push_back(readSingleMesh(config.getConfigParameter("mesh"),
                                         project_directory));
  
         std::string const geometry_file = BaseLib::copyPathToFileName(
             config.getConfigParameter<std::string>("geometry"),
             project_directory);
         GeoLib::GEOObjects geoObjects;
         readGeometry(geometry_file, geoObjects);
  
         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));
     }
  
     MeshLib::setMeshSpaceDimension(meshes);
  
     return meshes;
 }

References MeshGeoToolsLib::constructAdditionalMeshesFromGeoObjects(), BaseLib::copyPathToFileName(), MeshGeoToolsLib::createSearchLengthAlgorithm(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtreeOptional(), anonymous_namespace{FileTools.cpp}::project_directory, readGeometry(), readSingleMesh(), MeshLib::setMeshSpaceDimension(), and WARN().

◆ readSingleMesh()

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

Input File Parameter:: prj__meshes__mesh__axially_symmetric

Input File Parameter:: prj__mesh__axially_symmetric

Definition at line 140 of file ProjectData.cpp.

 {
     std::string const mesh_file = BaseLib::copyPathToFileName(
         mesh_config_parameter.getValue<std::string>(), project_directory);
     DBUG("Reading mesh file '{:s}'.", mesh_file);
  
     auto mesh = std::unique_ptr<MeshLib::Mesh>(
         MeshLib::IO::readMeshFromFile(mesh_file));
     if (!mesh)
     {
         OGS_FATAL("Could not read mesh from '{:s}' file. No mesh added.",
                   mesh_file);
     }
  
 #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);
     }
  
     return mesh;
 }

References BaseLib::copyPathToFileName(), DBUG(), BaseLib::ConfigTree::getConfigAttributeOptional(), BaseLib::ConfigTree::getValue(), OGS_FATAL, anonymous_namespace{FileTools.cpp}::project_directory, and MeshLib::IO::readMeshFromFile().