ECLGraph.hpp

Go to the documentation of this file.

/*
  Copyright 2016, 2017 Statoil ASA.
 
  This file is part of the Open Porous Media Project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef OPM_ECLGRAPH_HEADER_INCLUDED
#define OPM_ECLGRAPH_HEADER_INCLUDED
 
#include <opm/utility/ECLPhaseIndex.hpp>
#include <opm/utility/ECLResultData.hpp>
#include <opm/utility/ECLUnitHandling.hpp>
 
#include <array>
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
 
#include <boost/filesystem.hpp>
 
 
extern "C" {
    struct ecl_grid_struct;
    typedef ecl_grid_struct ecl_grid_type;
} // extern "C"
 
namespace Opm {
 
    class ECLGraph
    {
    public:
        ECLGraph() = delete;
 
        ~ECLGraph();
 
        ECLGraph(ECLGraph&& rhs);
 
        ECLGraph(const ECLGraph& rhs) = delete;
 
        ECLGraph& operator=(ECLGraph&& rhs);
 
        ECLGraph& operator=(const ECLGraph& rhs) = delete;
 
        static ECLGraph
        load(const boost::filesystem::path& gridFile,
             const ECLInitFileData&         init);
 
        static ECLGraph
        load(const ecl_grid_type*   grid,
             const ECLInitFileData& init);
 
        int numGrids() const;
 
        int activeCell(const std::array<int,3>& ijk,
                       const std::string&       gridID = "") const;
 
        std::size_t numCells() const;
 
        std::size_t numCells(const std::string& gridID) const;
 
        std::size_t numConnections() const;
 
        std::vector<int> localCellID() const;
 
        const std::vector<ECLPhaseIndex>& activePhases() const;
 
        const std::vector<std::string>& activeGrids() const;
 
        std::vector<int> neighbours() const;
 
        std::vector<double> poreVolume() const;
 
        std::vector<double> transmissibility() const;
 
        std::vector<double>
        flux(const ECLRestartData& rstrt,
             const ECLPhaseIndex   phase) const;
 
        template <typename T, class ResultSet>
        std::vector<T>
        rawLinearisedCellData(const ResultSet&   rset,
                              const std::string& vector) const;
 
        template <typename T, class ResultSet>
        std::vector<T>
        rawLinearisedCellData(const ResultSet&   rset,
                              const std::string& vector,
                              const std::string& gridID) const;
 
        typedef double (ECLUnits::UnitSystem::*UnitConvention)() const;
 
        std::vector<double>
        linearisedCellData(const ECLRestartData& rstrt,
                           const std::string&    vector,
                           UnitConvention        unit) const;
 
        struct ECLGeometryGrid {
            std::array<int, 3> size;
            std::vector<double> zcorn;
            std::vector<double> coord;
            std::vector<int> actnum;
        };
 
        const ECLGeometryGrid& getGeometryGrid() const;
 
    private:
        class Impl;
 
        using ImplPtr = std::unique_ptr<Impl>;
 
        ECLGraph(ImplPtr pImpl);
 
        ImplPtr pImpl_;
    };
 
} // namespace Opm
 
#endif // OPM_ECLGRAPH_HEADER_INCLUDED