ECLPropertyUnitConversion.hpp

Go to the documentation of this file.

/*
  Copyright 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_ECLPROPERTYUNITCONVERSION_HEADER_INCLUDED
#define OPM_ECLPROPERTYUNITCONVERSION_HEADER_INCLUDED
 
#include <memory>
#include <vector>
 
namespace Opm {
 
    class ECLRestartData;
    class ECLInitFileData;
 
    namespace ECLUnits {
 
        struct UnitSystem;
 
        std::unique_ptr<const UnitSystem>
        serialisedUnitConventions(const ECLRestartData& rstrt);
 
        std::unique_ptr<const UnitSystem>
        serialisedUnitConventions(const ECLInitFileData& init);
 
        std::unique_ptr<const UnitSystem> internalUnitConventions();
 
        std::unique_ptr<const UnitSystem> metricUnitConventions();
 
        std::unique_ptr<const UnitSystem> fieldUnitConventions();
 
        std::unique_ptr<const UnitSystem> labUnitConventions();
 
        std::unique_ptr<const UnitSystem> pvtmUnitConventions();
 
        struct Convert
        {
            class PhysicalQuantity
            {
            public:
                PhysicalQuantity();
 
                virtual ~PhysicalQuantity();
 
                PhysicalQuantity(const PhysicalQuantity& rhs);
 
                PhysicalQuantity(PhysicalQuantity&& rhs);
 
                PhysicalQuantity& operator=(const PhysicalQuantity& rhs);
 
                PhysicalQuantity& operator=(PhysicalQuantity&& rhs);
 
                PhysicalQuantity& from(const UnitSystem& usys);
 
                PhysicalQuantity& to(const UnitSystem& usys);
 
                virtual void appliedTo(std::vector<double>& x) const = 0;
 
            protected:
                const UnitSystem* from() const;
 
                const UnitSystem* to() const;
 
            private:
                class Impl;
 
                std::unique_ptr<Impl> pImpl_;
            };
 
            class Pressure : public PhysicalQuantity {
            public:
                void appliedTo(std::vector<double>& press) const override;
            };
 
            class Viscosity : public PhysicalQuantity {
            public:
                void appliedTo(std::vector<double>& mu) const override;
            };
 
            class GasFVF : public PhysicalQuantity {
            public:
                void appliedTo(std::vector<double>& Bg) const override;
            };
 
            class OilFVF : public PhysicalQuantity {
            public:
                void appliedTo(std::vector<double>& Bo) const override;
            };
 
            class DissolvedGasOilRatio : public PhysicalQuantity {
            public:
                void appliedTo(std::vector<double>& Rs) const override;
            };
 
            class VaporisedOilGasRatio : public PhysicalQuantity {
            public:
                void appliedTo(std::vector<double>& Rv) const override;
            };
        };
 
    } // namespace ECLUnits
} // namespace Opm
 
#endif  // OPM_ECLPROPERTYUNITCONVERSION_HEADER_INCLUDED