SimulatorState.hpp

Go to the documentation of this file.

// Copyright (C) 2013 Uni Research AS
// Copyright (C) 2015 IRIS AS
// This file is licensed under the GNU General Public License v3.0

#ifndef OPM_SIMULATORSTATE_HEADER_INCLUDED
#define OPM_SIMULATORSTATE_HEADER_INCLUDED

#include <vector>
#include <string>

// forward declaration
struct UnstructuredGrid;

namespace Opm
{
    class SimulatorState
    {
    public:

        virtual void init(const UnstructuredGrid& g, int num_phases);

        virtual void init(int number_of_cells, int number_of_faces, int num_phases);

        enum ExtremalSat { MinSat, MaxSat };

    protected:
        static const int pressureId_ = 0;
        static const int temperatureId_ = 1;
        static const int saturationId_ = 2;

        static const int facePressureId_ = 0;
        static const int faceFluxId_ = 1;

        template <typename Props>
        void setFirstSat(const std::vector<int>& cells,
                         const Props& props,
                         ExtremalSat es);
    public:
        int numPhases() const { return num_phases_; }
        int numCells () const { return num_cells_; }
        int numFaces () const { return num_faces_; }

        std::vector<double>& pressure    () { return cellData_[ pressureId_ ]; }
        std::vector<double>& temperature () { return cellData_[ temperatureId_ ]; }
        std::vector<double>& facepressure() { return faceData_[ facePressureId_]; }
        std::vector<double>& faceflux    () { return faceData_[ faceFluxId_ ];        }
        std::vector<double>& saturation  () { return cellData_[ saturationId_ ];  }

        const std::vector<double>& pressure    () const { return cellData_[ pressureId_ ];    }
        const std::vector<double>& temperature () const { return cellData_[ temperatureId_ ]; }
        const std::vector<double>& facepressure() const { return faceData_[ facePressureId_]; }
        const std::vector<double>& faceflux    () const { return faceData_[ faceFluxId_ ];        }
        const std::vector<double>& saturation  () const { return cellData_[ saturationId_ ];  }

        virtual bool equals(const SimulatorState& other,
                            double epsilon = 1e-8) const;

        std::vector< std::vector<double> >& cellData() { return cellData_; }
        const std::vector< std::vector<double> >& cellData() const { return cellData_; }

        std::vector< std::vector<double> >& faceData() { return faceData_; }
        const std::vector< std::vector<double> >& faceData() const { return faceData_; }

        const std::vector< std::string >& cellDataNames() const { return cellDataNames_; }
        const std::vector< std::string >& faceDataNames() const { return faceDataNames_; }

        size_t registerCellData( const std::string& name, const int components, const double initialValue = 0.0 );
        size_t registerFaceData( const std::string& name, const int components, const double initialValue = 0.0 );
    private:
        int num_cells_;
        int num_faces_;
        int num_phases_;

        std::vector< std::vector< double > > cellData_;
        std::vector< std::vector< double > > faceData_;

        std::vector< std::string > cellDataNames_;
        std::vector< std::string > faceDataNames_;

    protected:
        static bool vectorApproxEqual(const std::vector<double>& v1,
                                      const std::vector<double>& v2,
                                      double epsilon);
    };

} // namespace Opm

#endif // OPM_SIMULATORSTATE_HEADER_INCLUDED