FileIO::Gocad::GocadSGridReader Class Reference

Detailed Description

Definition at line 33 of file GocadSGridReader.h.

#include <GocadSGridReader.h>

Collaboration diagram for FileIO::Gocad::GocadSGridReader:

Public Member Functions
	GocadSGridReader (std::string const &fname)
	~GocadSGridReader ()
	GocadSGridReader ()=delete
	GocadSGridReader (GocadSGridReader &&src)=delete
	GocadSGridReader (GocadSGridReader const &src)=delete
GocadSGridReader &	operator= (GocadSGridReader &&rhs)=delete
GocadSGridReader &	operator= (GocadSGridReader const &rhs)=delete
std::unique_ptr< MeshLib::Mesh >	getMesh () const
std::unique_ptr< MeshLib::Mesh >	getFaceSetMesh (std::size_t const face_set_number) const
std::vector< std::string >	getPropertyNames () const

Private Types
using	Bitset = boost::dynamic_bitset<>

Private Member Functions
void	parseDims (std::string const &line)
void	parseFileName (std::string const &line, std::string &result_string) const
void	parseHeader (std::istream &in)
void	parseFaceSet (std::string &line, std::istream &in)
void	readNodesBinary ()
std::vector< Bitset >	readRegionFlagsBinary () const
void	readElementPropertiesBinary ()
void	mapRegionFlagsToCellProperties (std::vector< Bitset > const &rf)
std::vector< MeshLib::Element * >	createElements (std::vector< MeshLib::Node * > const &nodes) const
void	readSplitInformation ()
void	applySplitInformation (std::vector< MeshLib::Node * > &nodes, std::vector< MeshLib::Element * > const &elements) const
void	addFaceSetQuad (GocadNode *face_set_node, std::size_t face_set_number, std::vector< MeshLib::Node * > &face_set_nodes, std::vector< MeshLib::Element * > &face_set_elements) const
Gocad::Property const *	getProperty (std::string const &name) const
void	addGocadPropertiesToMesh (MeshLib::Mesh &mesh) const

Static Private Member Functions
static void	modifyElement (MeshLib::Element const *hex, MeshLib::Node const *node2sub, MeshLib::Node *substitute_node)

Private Attributes
std::string const &	_fname
std::string const	_path
Gocad::IndexCalculator	_index_calculator
Gocad::CoordinateSystem	_coordinate_system
std::string	_pnts_fname
std::string	_flags_fname
std::string	_region_flags_fname
std::vector< Gocad::Region >	regions
std::vector< Gocad::Layer >	layers
std::size_t	_n_face_sets
bool	_double_precision_binary
bool	_bin_pnts_in_double_precision
std::vector< GocadNode * >	_nodes
std::vector< GocadSplitNode * >	_split_nodes
std::vector< Gocad::Property >	_property_meta_data_vecs

Member Typedef Documentation

Bitset

using FileIO::Gocad::GocadSGridReader::Bitset = boost::dynamic_bitset<>

private

Definition at line 56 of file GocadSGridReader.h.

Constructor & Destructor Documentation

GocadSGridReader() [1/4]

FileIO::Gocad::GocadSGridReader::GocadSGridReader ( std::string const & fname )

explicit

Constructor takes as argument the Gocad .sg text file.

Parameters

fname

file name

Definition at line 31 of file GocadSGridReader.cpp.

    : _fname(fname),
      _path(BaseLib::extractPath(fname)),
      _n_face_sets(0),
      _double_precision_binary(false),
      _bin_pnts_in_double_precision(false)
{
    // check if file exists
    std::ifstream in(_fname.c_str());
    if (!in)
    {
        ERR("Could not open '{:s}'.", _fname);
        in.close();
        return;
    }
 
    bool pnts_read(false);
 
    // read information in the stratigraphic grid file
    std::string line;
    while (std::getline(in, line))
    {
        if (line.empty())  // skip empty lines
        {
            continue;
        }
        if (line.back() == '\r')  // check dos line ending
        {
            line.pop_back();
        }
        if (line.substr(0, 8) == "HEADER {")
        {
            parseHeader(in);
        }
        if (line.substr(0, 32) == "GOCAD_ORIGINAL_COORDINATE_SYSTEM")
        {
            _coordinate_system.parse(in);
            continue;
        }
        if (line.substr(0, 7) == "AXIS_N ")
        {
            parseDims(line);
        }
        else if (line.substr(0, 12) == "POINTS_FILE ")
        {
            parseFileName(line, _pnts_fname);
        }
        else if (line.substr(0, 9) == "PROPERTY ")
        {
            _property_meta_data_vecs.push_back(
                Gocad::parseGocadPropertyMetaData(line, in, _path));
        }
        else if (line.substr(0, 35) == "BINARY_POINTS_IN_DOUBLE_PRECISION 1")
        {
            _bin_pnts_in_double_precision = true;
        }
        else if (line.substr(0, 11) == "FLAGS_FILE ")
        {
            parseFileName(line, _flags_fname);
        }
        else if (line.substr(0, 18) == "REGION_FLAGS_FILE ")
        {
            parseFileName(line, _region_flags_fname);
        }
        else if (line.substr(0, 7) == "REGION " ||
                 line.substr(0, 13) == "MODEL_REGION ")
        {
            regions.push_back(Gocad::parseRegion(line));
        }
        else if (line.substr(0, 12) == "MODEL_LAYER ")
        {
            layers.push_back(Gocad::parseLayer(line, regions));
        }
        else if (line.substr(0, 24) == "REGION_FLAGS_BIT_LENGTH ")
        {
            std::istringstream iss(line);
            std::istream_iterator<std::string> it(iss);
            it++;
            std::size_t bit_length = std::atoi(it->c_str());
            if (regions.size() != bit_length)
            {
                ERR("{:d} regions read but {:d} expected.\n", regions.size(),
                    bit_length);
                throw std::runtime_error(
                    "Number of read regions differs from expected.\n");
            }
        }
        else if (line.substr(0, 9) == "FACE_SET ")
        {
            // first read the points
            if (!pnts_read)
            {
                readNodesBinary();
                pnts_read = true;
            }
            parseFaceSet(line, in);
        }
    }
 
#ifndef NDEBUG
    std::stringstream regions_ss;
    regions_ss << regions.size() << " regions read:\n";
    std::copy(regions.begin(), regions.end(),
              std::ostream_iterator<Gocad::Region>(regions_ss, "\t"));
    DBUG("{:s}", regions_ss.str());
 
    std::stringstream layers_ss;
    layers_ss << layers.size() << " layers read:\n";
    std::copy(layers.begin(), layers.end(),
              std::ostream_iterator<Gocad::Layer>(layers_ss, "\n"));
    DBUG("{:s}", layers_ss.str());
 
    std::stringstream properties_ss;
    properties_ss << "meta data for " << _property_meta_data_vecs.size()
                  << " properties read:\n";
    std::copy(_property_meta_data_vecs.begin(), _property_meta_data_vecs.end(),
              std::ostream_iterator<Gocad::Property>(properties_ss, "\n"));
    DBUG("{:s}", properties_ss.str());
#endif
 
    // if not done already read the points
    if (!pnts_read)
    {
        readNodesBinary();
    }
    readElementPropertiesBinary();
    std::vector<Bitset> region_flags = readRegionFlagsBinary();
    mapRegionFlagsToCellProperties(region_flags);
 
    readSplitInformation();
 
    in.close();
}

References _bin_pnts_in_double_precision, _coordinate_system, _flags_fname, _fname, _path, _pnts_fname, _property_meta_data_vecs, _region_flags_fname, DBUG(), ERR(), layers, mapRegionFlagsToCellProperties(), FileIO::Gocad::CoordinateSystem::parse(), parseDims(), parseFaceSet(), parseFileName(), FileIO::Gocad::parseGocadPropertyMetaData(), parseHeader(), FileIO::Gocad::parseLayer(), FileIO::Gocad::parseRegion(), readElementPropertiesBinary(), readNodesBinary(), readRegionFlagsBinary(), readSplitInformation(), and regions.

~GocadSGridReader()

FileIO::Gocad::GocadSGridReader::~GocadSGridReader

(

)

Definition at line 165 of file GocadSGridReader.cpp.

{
    for (auto node : _nodes)
    {
        delete node;
    }
    for (auto node : _split_nodes)
    {
        delete node;
    }
}

References _nodes, and _split_nodes.

GocadSGridReader() [2/4]

FileIO::Gocad::GocadSGridReader::GocadSGridReader ( )

delete

GocadSGridReader() [3/4]

FileIO::Gocad::GocadSGridReader::GocadSGridReader ( GocadSGridReader && src )

delete

GocadSGridReader() [4/4]

FileIO::Gocad::GocadSGridReader::GocadSGridReader ( GocadSGridReader const & src )

delete

Member Function Documentation

addFaceSetQuad()

void FileIO::Gocad::GocadSGridReader::addFaceSetQuad ( GocadNode * face_set_node, std::size_t face_set_number, std::vector< MeshLib::Node * > & face_set_nodes, std::vector< MeshLib::Element * > & face_set_elements ) const

private

Definition at line 794 of file GocadSGridReader.cpp.

{
    std::array<MeshLib::Node*, 4> quad_nodes{};
    quad_nodes[0] = new GocadNode(*face_set_node);
    const std::size_t id(face_set_node->getID());
    std::array<std::size_t, 3> const c(_index_calculator.getCoordsForID(id));
 
    const FaceDirection dir(face_set_node->getFaceDirection(face_set_number));
    switch (dir)
    {
        case FaceDirection::U:
            quad_nodes[1] = new GocadNode(
                *_nodes[_index_calculator({c[0], c[1] + 1, c[2]})]);
            quad_nodes[2] = new GocadNode(
                *_nodes[_index_calculator({c[0], c[1] + 1, c[2] + 1})]);
            quad_nodes[3] = new GocadNode(
                *_nodes[_index_calculator({c[0], c[1], c[2] + 1})]);
            break;
        case FaceDirection::V:
            quad_nodes[1] = new GocadNode(
                *_nodes[_index_calculator({c[0] + 1, c[1], c[2]})]);
            quad_nodes[2] = new GocadNode(
                *_nodes[_index_calculator({c[0] + 1, c[1], c[2] + 1})]);
            quad_nodes[3] = new GocadNode(
                *_nodes[_index_calculator({c[0], c[1], c[2] + 1})]);
            break;
        case FaceDirection::W:
            quad_nodes[1] = new GocadNode(
                *_nodes[_index_calculator({c[0] + 1, c[1], c[2]})]);
            quad_nodes[2] = new GocadNode(
                *_nodes[_index_calculator({c[0] + 1, c[1] + 1, c[2]})]);
            quad_nodes[3] = new GocadNode(
                *_nodes[_index_calculator({c[0], c[1] + 1, c[2]})]);
            break;
        default:
            ERR("Could not create face for node with id {:d}.", id);
    }
    std::copy(begin(quad_nodes), end(quad_nodes),
              back_inserter(face_set_nodes));
    face_set_elements.push_back(new MeshLib::Quad(quad_nodes));
}

References _index_calculator, _nodes, ERR(), FileIO::Gocad::IndexCalculator::getCoordsForID(), FileIO::Gocad::GocadNode::getFaceDirection(), MathLib::Point3dWithID::getID(), FileIO::Gocad::U, FileIO::Gocad::V, and FileIO::Gocad::W.

Referenced by getFaceSetMesh().

addGocadPropertiesToMesh()

void FileIO::Gocad::GocadSGridReader::addGocadPropertiesToMesh ( MeshLib::Mesh & mesh ) const

private

Definition at line 197 of file GocadSGridReader.cpp.

{
    std::vector<std::string> const& prop_names(getPropertyNames());
    for (auto const& name : prop_names)
    {
        auto prop = getProperty(name);
        if (!prop)
        {
            continue;
        }
 
        DBUG("Adding Gocad property '{:s}' with {:d} values.", name,
             prop->_property_data.size());
 
        auto pv = MeshLib::getOrCreateMeshProperty<double>(
            mesh, name, MeshLib::MeshItemType::Cell, 1);
        if (pv == nullptr)
        {
            ERR("Could not create mesh property '{:s}'.", name);
            continue;
        }
 
        pv->resize(prop->_property_data.size());
        std::copy(prop->_property_data.cbegin(), prop->_property_data.cend(),
                  pv->begin());
    }
}

References MeshLib::Cell, DBUG(), ERR(), MeshLib::getOrCreateMeshProperty(), getProperty(), and getPropertyNames().

Referenced by getMesh().

applySplitInformation()

void FileIO::Gocad::GocadSGridReader::applySplitInformation ( std::vector< MeshLib::Node * > & nodes, std::vector< MeshLib::Element * > const & elements ) const

private

Definition at line 637 of file GocadSGridReader.cpp.

{
    for (auto split_node : _split_nodes)
    {
        std::size_t const new_node_pos(nodes.size());
        nodes.push_back(new MeshLib::Node(split_node->data(), new_node_pos));
 
        // get grid coordinates
        std::array<std::size_t, 3> const& gc(split_node->getGridCoords());
        // get affected cells
        auto const& affected_cells(split_node->getAffectedCells());
        // get mesh node to substitute in elements
        MeshLib::Node const* const node2sub(nodes[_index_calculator(gc)]);
 
        if (affected_cells[0] && gc[0] < _index_calculator._x_dim - 1 &&
            gc[1] < _index_calculator._y_dim - 1 &&
            gc[2] < _index_calculator._z_dim - 1)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0], gc[1], gc[2]));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
        if (affected_cells[1] && gc[0] > 0 &&
            gc[1] < _index_calculator._y_dim - 1 &&
            gc[2] < _index_calculator._z_dim - 1)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0] - 1, gc[1], gc[2]));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
        if (affected_cells[2] && gc[1] > 0 &&
            gc[0] < _index_calculator._x_dim - 1 &&
            gc[2] < _index_calculator._z_dim - 1)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0], gc[1] - 1, gc[2]));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
        if (affected_cells[3] && gc[0] > 0 && gc[1] > 0 &&
            gc[2] < _index_calculator._z_dim - 1)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0] - 1, gc[1] - 1, gc[2]));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
        if (affected_cells[4] && gc[2] > 0 &&
            gc[0] < _index_calculator._x_dim - 1 &&
            gc[1] < _index_calculator._y_dim - 1)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0], gc[1], gc[2] - 1));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
        if (affected_cells[5] && gc[0] > 0 && gc[2] > 0 &&
            gc[1] < _index_calculator._y_dim - 1)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0] - 1, gc[1], gc[2] - 1));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
        if (affected_cells[6] && gc[1] > 0 && gc[2] > 0 &&
            gc[0] < _index_calculator._x_dim - 1)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0], gc[1] - 1, gc[2] - 1));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
        if (affected_cells[7] && gc[0] > 0 && gc[1] > 0 && gc[2] > 0)
        {
            const std::size_t idx(
                _index_calculator.getCellIdx(gc[0] - 1, gc[1] - 1, gc[2] - 1));
            modifyElement(elements[idx], node2sub, nodes[new_node_pos]);
        }
    }
}

References _index_calculator, _split_nodes, FileIO::Gocad::IndexCalculator::_x_dim, FileIO::Gocad::IndexCalculator::_y_dim, FileIO::Gocad::IndexCalculator::_z_dim, FileIO::Gocad::IndexCalculator::getCellIdx(), and modifyElement().

Referenced by getMesh().

createElements()

std::vector< MeshLib::Element * > FileIO::Gocad::GocadSGridReader::createElements ( std::vector< MeshLib::Node * > const & nodes ) const

private

Definition at line 557 of file GocadSGridReader.cpp.

{
    std::vector<MeshLib::Element*> elements;
    elements.resize(_index_calculator._n_cells);
    std::array<MeshLib::Node*, 8> element_nodes{};
    std::size_t cnt(0);
    for (std::size_t k(0); k < _index_calculator._z_dim - 1; k++)
    {
        for (std::size_t j(0); j < _index_calculator._y_dim - 1; j++)
        {
            for (std::size_t i(0); i < _index_calculator._x_dim - 1; i++)
            {
                element_nodes[0] = nodes[_index_calculator({i, j, k})];
                element_nodes[1] = nodes[_index_calculator({i + 1, j, k})];
                element_nodes[2] = nodes[_index_calculator({i + 1, j + 1, k})];
                element_nodes[3] = nodes[_index_calculator({i, j + 1, k})];
                element_nodes[4] = nodes[_index_calculator({i, j, k + 1})];
                element_nodes[5] = nodes[_index_calculator({i + 1, j, k + 1})];
                element_nodes[6] =
                    nodes[_index_calculator({i + 1, j + 1, k + 1})];
                element_nodes[7] = nodes[_index_calculator({i, j + 1, k + 1})];
                elements[cnt] = new MeshLib::Hex(
                    element_nodes, _index_calculator.getCellIdx(i, j, k));
                cnt++;
            }
        }
    }
    return elements;
}

References _index_calculator, FileIO::Gocad::IndexCalculator::_n_cells, FileIO::Gocad::IndexCalculator::_x_dim, FileIO::Gocad::IndexCalculator::_y_dim, FileIO::Gocad::IndexCalculator::_z_dim, and FileIO::Gocad::IndexCalculator::getCellIdx().

Referenced by getMesh().

getFaceSetMesh()

std::unique_ptr< MeshLib::Mesh > FileIO::Gocad::GocadSGridReader::getFaceSetMesh

(

std::size_t const

face_set_number

)

const

Definition at line 756 of file GocadSGridReader.cpp.

{
    std::vector<MeshLib::Node*> face_set_nodes;
    std::vector<MeshLib::Element*> face_set_elements;
 
    for (auto const node : _nodes)
    {
        if (node->isMemberOfFaceSet(face_set_number))
        {
            addFaceSetQuad(node, face_set_number, face_set_nodes,
                           face_set_elements);
        }
    }
 
    if (face_set_nodes.empty())
    {
        return nullptr;
    }
 
    for (auto const node : _split_nodes)
    {
        if (node->isMemberOfFaceSet(face_set_number))
        {
            if (node->getAffectedCells()[0])
            {
                addFaceSetQuad(node, face_set_number, face_set_nodes,
                               face_set_elements);
            }
        }
    }
 
    std::string const mesh_name("FaceSet-" + std::to_string(face_set_number));
    return std::make_unique<MeshLib::Mesh>(
        mesh_name, face_set_nodes, face_set_elements,
        true /* compute_element_neighbors */);
}

References _nodes, _split_nodes, and addFaceSetQuad().

Referenced by FileIO::Gocad::generateFaceSets().

getMesh()

std::unique_ptr< MeshLib::Mesh > FileIO::Gocad::GocadSGridReader::getMesh

(

)

const

Definition at line 177 of file GocadSGridReader.cpp.

{
    std::vector<MeshLib::Node*> nodes;
    std::transform(_nodes.cbegin(), _nodes.cend(), std::back_inserter(nodes),
                   [](MeshLib::Node const* const node)
                   { return new MeshLib::Node(*node); });
 
    std::vector<MeshLib::Element*> elements(createElements(nodes));
    applySplitInformation(nodes, elements);
 
    DBUG("Creating mesh from Gocad SGrid.");
    std::unique_ptr<MeshLib::Mesh> mesh(new MeshLib::Mesh(
        BaseLib::extractBaseNameWithoutExtension(_fname), nodes, elements,
        true /* compute_element_neighbors */));
    addGocadPropertiesToMesh(*mesh);
    DBUG("Mesh created.");
 
    return mesh;
}

References _fname, _nodes, addGocadPropertiesToMesh(), applySplitInformation(), createElements(), DBUG(), and BaseLib::extractBaseNameWithoutExtension().

Referenced by main().

getProperty()

Gocad::Property const * FileIO::Gocad::GocadSGridReader::getProperty ( std::string const & name ) const

private

Definition at line 732 of file GocadSGridReader.cpp.

{
    auto const it(std::find_if(_property_meta_data_vecs.begin(),
                               _property_meta_data_vecs.end(),
                               [&name](Gocad::Property const& p)
                               { return p._property_name == name; }));
    if (it == _property_meta_data_vecs.end())
    {
        return nullptr;
    }
    return &*it;
}

References _property_meta_data_vecs.

Referenced by addGocadPropertiesToMesh().

getPropertyNames()

std::vector< std::string > FileIO::Gocad::GocadSGridReader::getPropertyNames

(

)

const

Definition at line 746 of file GocadSGridReader.cpp.

{
    std::vector<std::string> names;
    std::transform(_property_meta_data_vecs.begin(),
                   _property_meta_data_vecs.end(),
                   std::back_inserter(names),
                   [](Gocad::Property const& p) { return p._property_name; });
    return names;
}

References _property_meta_data_vecs.

Referenced by addGocadPropertiesToMesh().

mapRegionFlagsToCellProperties()

void FileIO::Gocad::GocadSGridReader::mapRegionFlagsToCellProperties ( std::vector< Bitset > const & rf )

private

Definition at line 451 of file GocadSGridReader.cpp.

{
    DBUG(
        "GocadSGridReader::mapRegionFlagsToCellProperties region_flags.size: "
        "{:d}",
        rf.size());
 
    Gocad::Property region_flags;
    region_flags._property_id = 0;
    region_flags._property_name = "RegionFlags";
    region_flags._property_class_name = "RegionFlags";
    region_flags._property_unit = "unitless";
    region_flags._property_data_type = "int";
    region_flags._property_data_fname = "";
    region_flags._property_no_data_value = -1;
    std::size_t const n = _index_calculator._n_cells;
    region_flags._property_data.resize(n);
    std::fill(region_flags._property_data.begin(),
              region_flags._property_data.end(), -1);
 
    // region flags are stored in each node ijk and give the region index for
    // the ijk-th cell.
    for (std::size_t i(0); i < _index_calculator._x_dim - 1; i++)
    {
        for (std::size_t j(0); j < _index_calculator._y_dim - 1; j++)
        {
            for (std::size_t k(0); k < _index_calculator._z_dim - 1; k++)
            {
                std::size_t const cell_id(
                    _index_calculator.getCellIdx(i, j, k));
                std::size_t const node_id(_index_calculator({i, j, k}));
                for (auto& region : regions)
                {
                    if (rf[node_id].test(region.bit))
                    {
                        region_flags._property_data[cell_id] += region.bit + 1;
                    }
                }
            }
        }
    }
 
    _property_meta_data_vecs.push_back(region_flags);
}

References _index_calculator, FileIO::Gocad::IndexCalculator::_n_cells, FileIO::Gocad::Property::_property_class_name, FileIO::Gocad::Property::_property_data, FileIO::Gocad::Property::_property_data_fname, FileIO::Gocad::Property::_property_data_type, FileIO::Gocad::Property::_property_id, _property_meta_data_vecs, FileIO::Gocad::Property::_property_name, FileIO::Gocad::Property::_property_no_data_value, FileIO::Gocad::Property::_property_unit, FileIO::Gocad::IndexCalculator::_x_dim, FileIO::Gocad::IndexCalculator::_y_dim, FileIO::Gocad::IndexCalculator::_z_dim, DBUG(), FileIO::Gocad::IndexCalculator::getCellIdx(), and regions.

Referenced by GocadSGridReader().

modifyElement()

void FileIO::Gocad::GocadSGridReader::modifyElement ( MeshLib::Element const * hex, MeshLib::Node const * node2sub, MeshLib::Node * substitute_node )

staticprivate

Definition at line 715 of file GocadSGridReader.cpp.

{
    // get the node pointers of the cell
    MeshLib::Node* const* hex_nodes(hex->getNodes());
    // search for the position the split node will be set to
    MeshLib::Node* const* node_pos(
        std::find(hex_nodes, hex_nodes + 8, node2sub));
    // set the split node instead of the node2sub
    if (node_pos != hex_nodes + 8)
    {
        const_cast<MeshLib::Node**>(
            hex_nodes)[std::distance(hex_nodes, node_pos)] = substitute_node;
    }
}

References MeshLib::Element::getNodes().

Referenced by applySplitInformation().

operator=() [1/2]

GocadSGridReader & FileIO::Gocad::GocadSGridReader::operator= ( GocadSGridReader && rhs )

delete

operator=() [2/2]

GocadSGridReader & FileIO::Gocad::GocadSGridReader::operator= ( GocadSGridReader const & rhs )

delete

parseDims()

void FileIO::Gocad::GocadSGridReader::parseDims ( std::string const & line )

private

Definition at line 247 of file GocadSGridReader.cpp.

{
    std::size_t x_dim(0);
    std::size_t y_dim(0);
    std::size_t z_dim(0);
    boost::tokenizer<> tok(line);
    auto it(tok.begin());
    it++;  // overread token "AXIS"
    it++;  // overread "N"
    std::stringstream ssx(*(it),
                          std::stringstream::in | std::stringstream::out);
    ssx >> x_dim;
    it++;
    std::stringstream ssy(*it, std::stringstream::in | std::stringstream::out);
    ssy >> y_dim;
    it++;
    std::stringstream ssz(*it, std::stringstream::in | std::stringstream::out);
    ssz >> z_dim;
    _index_calculator = Gocad::IndexCalculator(x_dim, y_dim, z_dim);
    DBUG(
        "x_dim = {:d}, y_dim = {:d}, z_dim = {:d} => #nodes = {:d}, #cells = "
        "{:d}",
        x_dim, y_dim, z_dim, _index_calculator._n_nodes,
        _index_calculator._n_cells);
}

References _index_calculator, FileIO::Gocad::IndexCalculator::_n_cells, FileIO::Gocad::IndexCalculator::_n_nodes, and DBUG().

Referenced by GocadSGridReader().

parseFaceSet()

void FileIO::Gocad::GocadSGridReader::parseFaceSet ( std::string & line, std::istream & in )

private

Parameters

line	input/output
in	input stream containing the face set

Definition at line 287 of file GocadSGridReader.cpp.

{
    // create and initialize a Gocad::Property object for storing face set data
    Gocad::Property face_set_property;
    face_set_property._property_id = _n_face_sets;
    face_set_property._property_name = "FaceSet";
    face_set_property._property_class_name = "FaceSetData";
    face_set_property._property_unit = "unitless";
    face_set_property._property_data_type = "double";
    face_set_property._property_data_fname = "";
    face_set_property._property_no_data_value = -1.0;
    face_set_property._property_data.resize(_index_calculator._n_cells);
    std::fill(face_set_property._property_data.begin(),
              face_set_property._property_data.end(),
              face_set_property._property_no_data_value);
 
    std::istringstream iss(line);
    std::istream_iterator<std::string> it(iss);
    // Check first word is FACE_SET
    if (*it != std::string("FACE_SET"))
    {
        ERR("Expected FACE_SET keyword but '{:s}' found.", it->c_str());
        throw std::runtime_error(
            "In GocadSGridReader::parseFaceSet() expected FACE_SET keyword not "
            "found.");
    }
    ++it;
    face_set_property._property_name += *it;
    ++it;
    auto const n_of_face_set_ids(
        static_cast<std::size_t>(std::atoi(it->c_str())));
    std::size_t face_set_id_cnt(0);
 
    while (std::getline(in, line) && face_set_id_cnt < n_of_face_set_ids)
    {
        if (line.back() == '\r')
        {
            line.pop_back();
        }
        boost::char_separator<char> sep("\t ");
        boost::tokenizer<boost::char_separator<char>> tokens(line, sep);
 
        for (auto tok_it = tokens.begin(); tok_it != tokens.end();)
        {
            auto const id(static_cast<std::size_t>(std::atoi(tok_it->c_str())));
            tok_it++;
            auto const face_indicator(
                static_cast<std::size_t>(std::atoi(tok_it->c_str())));
            tok_it++;
 
            if (id >= _index_calculator._n_nodes)
            {
                ERR("Face set id {:d} is greater than the number of nodes "
                    "({:d}).",
                    id, _index_calculator._n_nodes);
            }
            else
            {
                static_cast<GocadNode*>(_nodes[id])
                    ->setFaceSet(_n_face_sets, face_indicator);
                std::array<std::size_t, 3> const c(
                    _index_calculator.getCoordsForID(id));
                if (c[0] >= _index_calculator._x_dim - 1)
                {
                    ERR("****** i coord {:d} to big for id {:d}.", c[0], id);
                }
                if (c[1] >= _index_calculator._y_dim - 1)
                {
                    ERR("****** j coord {:d} to big for id {:d}.", c[1], id);
                }
                if (c[2] >= _index_calculator._z_dim - 1)
                {
                    ERR("****** k coord {:d} to big for id {:d}.", c[2], id);
                }
                std::size_t const cell_id(
                    _index_calculator.getCellIdx(c[0], c[1], c[2]));
                face_set_property._property_data[cell_id] =
                    static_cast<double>(face_indicator);
            }
            face_set_id_cnt++;
        }
    }
 
    if (face_set_id_cnt != n_of_face_set_ids)
    {
        ERR("Expected {:d} number of face set ids, read {:d}.",
            n_of_face_set_ids, face_set_id_cnt);
        throw std::runtime_error(
            "Expected number of face set points does not match number of read "
            "points.");
    }
    _n_face_sets++;
 
    // pre condition: split nodes are read already
    for (auto split_node : _split_nodes)
    {
        std::size_t const id(_index_calculator(split_node->getGridCoords()));
        split_node->transmitFaceDirections(*_nodes[id]);
    }
 
    _property_meta_data_vecs.push_back(face_set_property);
}

References _index_calculator, FileIO::Gocad::IndexCalculator::_n_cells, _n_face_sets, FileIO::Gocad::IndexCalculator::_n_nodes, _nodes, FileIO::Gocad::Property::_property_class_name, FileIO::Gocad::Property::_property_data, FileIO::Gocad::Property::_property_data_fname, FileIO::Gocad::Property::_property_data_type, FileIO::Gocad::Property::_property_id, _property_meta_data_vecs, FileIO::Gocad::Property::_property_name, FileIO::Gocad::Property::_property_no_data_value, FileIO::Gocad::Property::_property_unit, _split_nodes, FileIO::Gocad::IndexCalculator::_x_dim, FileIO::Gocad::IndexCalculator::_y_dim, FileIO::Gocad::IndexCalculator::_z_dim, ERR(), FileIO::Gocad::IndexCalculator::getCellIdx(), and FileIO::Gocad::IndexCalculator::getCoordsForID().

Referenced by GocadSGridReader().

parseFileName()

void FileIO::Gocad::GocadSGridReader::parseFileName ( std::string const & line, std::string & result_string ) const

private

Definition at line 273 of file GocadSGridReader.cpp.

{
    boost::char_separator<char> sep(" \r");
    boost::tokenizer<boost::char_separator<char>> tok(line, sep);
    auto it(tok.begin());
    ++it;  // overread POINTS_FILE or FLAGS_FILE or REGION_FLAGS_FILE
    result_string = _path + *it;
}

References _path.

Referenced by GocadSGridReader().

parseHeader()

void FileIO::Gocad::GocadSGridReader::parseHeader ( std::istream & in )

private

Definition at line 225 of file GocadSGridReader.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (line.front() == '}')
        {
            return;
        }
        if (line.substr(0, 27) == "double_precision_binary: on")
        {
            _double_precision_binary = true;
        }
    }
    if (_double_precision_binary)
    {
        DBUG(
            "GocadSGridReader::parseHeader(): _double_precision_binary == "
            "true.");
    }
}

References _double_precision_binary, and DBUG().

Referenced by GocadSGridReader().

readElementPropertiesBinary()

void FileIO::Gocad::GocadSGridReader::readElementPropertiesBinary ( )

private

Definition at line 497 of file GocadSGridReader.cpp.

{
    for (auto& property : _property_meta_data_vecs)
    {
        std::string const& fname(property._property_data_fname);
        if (property._property_data_fname.empty())
        {
            WARN("Empty filename for property {:s}.", property._property_name);
            continue;
        }
        std::vector<float> float_properties = BaseLib::readBinaryVector<float>(
            fname, 0, _index_calculator._n_cells);
        DBUG(
            "GocadSGridReader::readElementPropertiesBinary(): Read {:d} float "
            "properties from binary file.",
            _index_calculator._n_cells);
 
        std::transform(float_properties.cbegin(), float_properties.cend(),
                       float_properties.begin(),
                       [](float const& val)
                       { return BaseLib::swapEndianness(val); });
 
        property._property_data.resize(float_properties.size());
        std::copy(float_properties.begin(), float_properties.end(),
                  property._property_data.begin());
        if (property._property_data.empty())
        {
            ERR("Reading of element properties file '{:s}' failed.", fname);
        }
    }
}

References _index_calculator, FileIO::Gocad::IndexCalculator::_n_cells, _property_meta_data_vecs, DBUG(), ERR(), BaseLib::readBinaryVector< float >(), and WARN().

Referenced by GocadSGridReader().

readNodesBinary()

void FileIO::Gocad::GocadSGridReader::readNodesBinary ( )

private

Definition at line 408 of file GocadSGridReader.cpp.

{
    std::ifstream in(_pnts_fname.c_str(), std::ios::binary);
    if (!in)
    {
        ERR("Could not open points file '{:s}'.", _pnts_fname);
        throw std::runtime_error("Could not open points file.");
    }
 
    std::size_t const n = _index_calculator._n_nodes;
    _nodes.resize(n);
 
    double coords[3];
 
    std::size_t k = 0;
    while (in && k < n * 3)
    {
        if (_bin_pnts_in_double_precision)
        {
            coords[k % 3] =
                BaseLib::swapEndianness(BaseLib::readBinaryValue<double>(in));
        }
        else
        {
            coords[k % 3] =
                BaseLib::swapEndianness(BaseLib::readBinaryValue<float>(in));
        }
        if ((k + 1) % 3 == 0)
        {
            const std::size_t layer_transition_idx(
                _index_calculator.getCoordsForID(k / 3)[2]);
            _nodes[k / 3] = new GocadNode(coords, k / 3, layer_transition_idx);
        }
        k++;
    }
    if (k != n * 3 && !in.eof())
    {
        ERR("Read different number of points. Expected {:d} floats, got "
            "{:d}.\n",
            n * 3, k);
    }
}

References _bin_pnts_in_double_precision, _index_calculator, FileIO::Gocad::IndexCalculator::_n_nodes, _nodes, _pnts_fname, ERR(), FileIO::Gocad::IndexCalculator::getCoordsForID(), BaseLib::readBinaryValue< double >(), BaseLib::readBinaryValue< float >(), and BaseLib::swapEndianness().

Referenced by GocadSGridReader().

readRegionFlagsBinary()

std::vector< Bitset > FileIO::Gocad::GocadSGridReader::readRegionFlagsBinary ( ) const

private

Definition at line 529 of file GocadSGridReader.cpp.

{
    std::vector<Bitset> result;
 
    std::ifstream in(_region_flags_fname.c_str());
    if (!in)
    {
        ERR("readRegionFlagsBinary(): Could not open file '{:s}' for input.\n",
            _region_flags_fname);
        in.close();
        return result;
    }
 
    std::size_t const n = _index_calculator._n_nodes;
    result.resize(n);
 
    std::size_t k = 0;
    while (in && k < n)
    {
        result[k++] = readBits(in, regions.size());
    }
    if (k != n && !in.eof())
    {
        ERR("Read different number of values. Expected {:d}, got {:d}.\n", n,
            k);
    }
    return result;
}

References _index_calculator, FileIO::Gocad::IndexCalculator::_n_nodes, _region_flags_fname, ERR(), FileIO::Gocad::readBits(), and regions.

Referenced by GocadSGridReader().

readSplitInformation()

void FileIO::Gocad::GocadSGridReader::readSplitInformation ( )

private

Definition at line 588 of file GocadSGridReader.cpp.

{
    std::ifstream in(_fname.c_str());
    if (!in)
    {
        ERR("Could not open '{:s}'.", _fname);
        in.close();
        return;
    }
 
    // read split information from the stratigraphic grid file
    std::string line;
    std::stringstream ss;
    while (std::getline(in, line))
    {
        std::size_t pos(line.find("SPLIT "));
        if (pos != std::string::npos)
        {
            ss << line.substr(pos + 6, line.size() - (pos + 6));
            // read position in grid
            std::array<std::size_t, 3> grid_coords{};
            ss >> grid_coords[0];
            ss >> grid_coords[1];
            ss >> grid_coords[2];
            // read coordinates for the split node
            double coords[3];
            ss >> coords[0];
            ss >> coords[1];
            ss >> coords[2];
            // read the id
            std::size_t id;
            ss >> id;
            // read the affected cells
            std::bitset<8> affected_cells{};
            for (std::size_t ac = 0; ac < 8; ++ac)
            {
                char bit;
                ss >> bit;
                affected_cells[ac] = bit != '0';
            }
            const std::size_t layer_transition_index(
                _nodes[id]->getLayerTransitionIndex());
            _split_nodes.push_back(new GocadSplitNode(coords, id, grid_coords,
                                                      affected_cells,
                                                      layer_transition_index));
        }
    }
}

References _fname, _nodes, _split_nodes, and ERR().

Referenced by GocadSGridReader().

Member Data Documentation

_bin_pnts_in_double_precision

bool FileIO::Gocad::GocadSGridReader::_bin_pnts_in_double_precision

private

Definition at line 103 of file GocadSGridReader.h.

Referenced by GocadSGridReader(), and readNodesBinary().

_coordinate_system

Gocad::CoordinateSystem FileIO::Gocad::GocadSGridReader::_coordinate_system

private

Definition at line 93 of file GocadSGridReader.h.

Referenced by GocadSGridReader().

_double_precision_binary

bool FileIO::Gocad::GocadSGridReader::_double_precision_binary

private

Definition at line 102 of file GocadSGridReader.h.

Referenced by parseHeader().

_flags_fname

std::string FileIO::Gocad::GocadSGridReader::_flags_fname

private

Definition at line 95 of file GocadSGridReader.h.

Referenced by GocadSGridReader().

_fname

std::string const& FileIO::Gocad::GocadSGridReader::_fname

private

Definition at line 89 of file GocadSGridReader.h.

Referenced by GocadSGridReader(), getMesh(), and readSplitInformation().

_index_calculator

Gocad::IndexCalculator FileIO::Gocad::GocadSGridReader::_index_calculator

private

Definition at line 92 of file GocadSGridReader.h.

Referenced by addFaceSetQuad(), applySplitInformation(), createElements(), mapRegionFlagsToCellProperties(), parseDims(), parseFaceSet(), readElementPropertiesBinary(), readNodesBinary(), and readRegionFlagsBinary().

_n_face_sets

std::size_t FileIO::Gocad::GocadSGridReader::_n_face_sets

private

Definition at line 100 of file GocadSGridReader.h.

Referenced by parseFaceSet().

_nodes

std::vector<GocadNode*> FileIO::Gocad::GocadSGridReader::_nodes

private

Definition at line 106 of file GocadSGridReader.h.

Referenced by ~GocadSGridReader(), addFaceSetQuad(), getFaceSetMesh(), getMesh(), parseFaceSet(), readNodesBinary(), and readSplitInformation().

_path

std::string const FileIO::Gocad::GocadSGridReader::_path

private

Definition at line 90 of file GocadSGridReader.h.

Referenced by GocadSGridReader(), and parseFileName().

_pnts_fname

std::string FileIO::Gocad::GocadSGridReader::_pnts_fname

private

Definition at line 94 of file GocadSGridReader.h.

Referenced by GocadSGridReader(), and readNodesBinary().

_property_meta_data_vecs

std::vector<Gocad::Property> FileIO::Gocad::GocadSGridReader::_property_meta_data_vecs

private

Definition at line 109 of file GocadSGridReader.h.

Referenced by GocadSGridReader(), getProperty(), getPropertyNames(), mapRegionFlagsToCellProperties(), parseFaceSet(), and readElementPropertiesBinary().

_region_flags_fname

std::string FileIO::Gocad::GocadSGridReader::_region_flags_fname

private

Definition at line 96 of file GocadSGridReader.h.

Referenced by GocadSGridReader(), and readRegionFlagsBinary().

_split_nodes

std::vector<GocadSplitNode*> FileIO::Gocad::GocadSGridReader::_split_nodes

private

Definition at line 107 of file GocadSGridReader.h.

Referenced by ~GocadSGridReader(), applySplitInformation(), getFaceSetMesh(), parseFaceSet(), and readSplitInformation().

layers

std::vector<Gocad::Layer> FileIO::Gocad::GocadSGridReader::layers

private

Definition at line 99 of file GocadSGridReader.h.

Referenced by GocadSGridReader().

regions

std::vector<Gocad::Region> FileIO::Gocad::GocadSGridReader::regions

private

Definition at line 98 of file GocadSGridReader.h.

Referenced by GocadSGridReader(), mapRegionFlagsToCellProperties(), and readRegionFlagsBinary().

---

The documentation for this class was generated from the following files:

• Applications/FileIO/GocadIO/GocadSGridReader.h
• Applications/FileIO/GocadIO/GocadSGridReader.cpp