FEFLOWMeshInterface.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <iosfwd>
#include <string>
#include <vector>
 
#include "MeshLib/PropertyVector.h"
 
namespace GeoLib
{
class Point;
class Polyline;
}
 
namespace MeshLib
{
class Mesh;
class Element;
class Node;
enum class MeshElemType;
}
 
namespace FileIO
{
class FEFLOWMeshInterface
{
public:
    MeshLib::Mesh* readFEFLOWFile(const std::string& filename);
 
private:
    // CLASS
    struct FEM_CLASS
    {
        unsigned problem_class = 0;
        unsigned time_mode = 0;
        unsigned orientation = 0;
        unsigned dimension = 0;
        unsigned n_layers3d = 0;
        unsigned saturation_flag = 0;
        unsigned save_fsize_rreal = 0;
        unsigned save_fsize_creal = 0;
    };
 
    // DIMENSION
    struct FEM_DIM
    {
        std::size_t n_nodes = 0;
        std::size_t n_elements = 0;
        std::size_t obs = 0;
        std::size_t np_cor = 0;
        unsigned n_nodes_of_element = 0;
        unsigned n_steps = 0;
        unsigned icrank = 0;
        unsigned upwind = 0;
        unsigned optim = 0;
        unsigned aquifer_type = 0;
        unsigned nwca = 0;
        unsigned adaptive_mesh = 0;
        unsigned sp_fem_pcs_id = 0;
        unsigned sorption_type = 0;
        unsigned reaction_type = 0;
        unsigned dispersion_type = 0;
    };

    MeshLib::Element* readElement(std::string const& line,
                                  std::vector<MeshLib::Node*> const& nodes);

    MeshLib::Element* readElement(const FEM_DIM& fem_dim,
                                  const MeshLib::MeshElemType elem_type,
                                  const std::string& line,
                                  const std::vector<MeshLib::Node*>& nodes);

    void readNodeCoordinates(std::ifstream& in,
                             std::vector<MeshLib::Node*>& nodes);

    void readNodeCoordinates(std::ifstream& in,
                             const FEM_CLASS& fem_class,
                             const FEM_DIM& fem_dim,
                             std::vector<MeshLib::Node*> const& nodes);

    void readElevation(std::ifstream& in,
                       const FEM_CLASS& fem_class,
                       const FEM_DIM& fem_dim,
                       std::vector<MeshLib::Node*>& vec_nodes);

    std::vector<std::size_t> getIndexList(const std::string& str_ranges);

    void readELEMENTALSETS(
        std::ifstream& in,
        std::vector<std::vector<std::size_t>>& vec_elementsets);

    void readMAT_I_FLOW(
        std::ifstream& in,
        const FEM_DIM& fem_dim,
        std::vector<std::string>& vec_element_property_names,
        std::vector<std::vector<double>>& vec_element_property_values);

    std::vector<double> readMaterialPropertyValues(std::ifstream& in,
                                                   std::size_t n_elements);
 
    void setMaterialIDs(
        FEM_CLASS const& fem_class,
        FEM_DIM const& fem_dim,
        std::vector<GeoLib::Polyline*> const& lines,
        std::vector<std::vector<std::size_t>> const& vec_elementsets,
        std::vector<MeshLib::Element*> const& vec_elements,
        MeshLib::PropertyVector<int>& material_ids);
};
}  // namespace FileIO