SimulationDataContainer.hpp

Go to the documentation of this file.

/*
  Copyright 2016 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 SIMULATION_DATA_CONTAINER_HPP
#define SIMULATION_DATA_CONTAINER_HPP
 
#include <cstddef>
#include <string>
#include <map>
#include <vector>
 
namespace Opm {
 
 
    class SimulationDataContainer
    {
    public:
        SimulationDataContainer(size_t num_cells, size_t num_faces, size_t num_phases);
 
        SimulationDataContainer(const SimulationDataContainer&);
 
        SimulationDataContainer& operator=(const SimulationDataContainer&);
 
        void swap(SimulationDataContainer& other);
 
        size_t numPhases() const;
        size_t numFaces() const;
        size_t numCells() const;
 
        bool hasCellData( const std::string& name ) const;
 
        void registerCellData( const std::string& name , size_t components , double initialValue = 0.0 );
        std::vector<double>& getCellData( const std::string& name );
        const std::vector<double>& getCellData( const std::string& name ) const;
 
        bool hasFaceData( const std::string& name ) const;
        void registerFaceData( const std::string& name , size_t components , double initialValue = 0.0 );
        std::vector<double>& getFaceData( const std::string& name );
        const std::vector<double>& getFaceData( const std::string& name ) const;
 
        size_t numCellDataComponents( const std::string& name ) const;
        bool equal(const SimulationDataContainer& other) const;
 
 
        void setCellDataComponent( const std::string& key , size_t component , const std::vector<int>& cells , const std::vector<double>& values);
 
        // Direct explicit field access for certain default fields.
        // These methods are all deprecated, and will eventually be moved to
        // concrete subclasses.
 
        std::vector<double>& pressure    ();
        std::vector<double>& temperature ();
        std::vector<double>& saturation  ();
 
        std::vector<double>& facepressure();
        std::vector<double>& faceflux    ();
 
        const std::vector<double>& pressure    () const;
        const std::vector<double>& temperature () const;
        const std::vector<double>& saturation  () const;
 
        const std::vector<double>& facepressure() const;
        const std::vector<double>& faceflux    () const;
 
        const std::map<std::string, std::vector<double>>& cellData() const;
        std::map<std::string, std::vector<double>>& cellData();
 
    private:
        void addDefaultFields();
        void setReferencePointers();
 
        size_t m_num_cells;
        size_t m_num_faces;
        size_t m_num_phases;
 
        std::map< std::string , std::vector<double> > m_cell_data;
        std::map< std::string , std::vector<double> > m_face_data;
 
        std::vector<double>* pressure_ref_;
        std::vector<double>* temperature_ref_;
        std::vector<double>* saturation_ref_;
        std::vector<double>* facepressure_ref_;
        std::vector<double>* faceflux_ref_;
    };
 
 
    // Inline implementations of the direct accessors required to guarantee
    // performance.
 
 
    inline std::vector<double>& SimulationDataContainer::pressure( ) {
        return *pressure_ref_;
    }
 
    inline std::vector<double>& SimulationDataContainer::temperature() {
        return *temperature_ref_;
    }
 
    inline std::vector<double>& SimulationDataContainer::saturation() {
        return *saturation_ref_;
    }
 
    inline std::vector<double>& SimulationDataContainer::facepressure() {
        return *facepressure_ref_;
    }
 
    inline std::vector<double>& SimulationDataContainer::faceflux() {
        return *faceflux_ref_;
    }
 
    inline const std::vector<double>& SimulationDataContainer::pressure( ) const {
        return *pressure_ref_;
    }
 
    inline const std::vector<double>& SimulationDataContainer::temperature() const {
        return *temperature_ref_;
    }
 
    inline const std::vector<double>& SimulationDataContainer::saturation() const {
        return *saturation_ref_;
    }
 
    inline const std::vector<double>& SimulationDataContainer::facepressure() const {
        return *facepressure_ref_;
    }
 
    inline const std::vector<double>& SimulationDataContainer::faceflux() const {
        return *faceflux_ref_;
    }
 
 
 
}
 
#endif