Units.hpp

Go to the documentation of this file.

//===========================================================================
//
// File: Units.hpp
//
// Created: Thu Jul  2 09:19:08 2009
//
// Author(s): Halvor M Nilsen <hnil@sintef.no>
//
// $Date$
//
// $Revision$
//
//===========================================================================

/*
  Copyright 2009, 2010, 2011, 2012 SINTEF ICT, Applied Mathematics.
  Copyright 2009, 2010, 2011, 2012 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_UNITS_HEADER
#define OPM_UNITS_HEADER

namespace Opm
{
    namespace prefix
    {
        const double micro = 1.0e-6;  
        const double milli = 1.0e-3;  
        const double centi = 1.0e-2;  
        const double deci  = 1.0e-1;  
        const double kilo  = 1.0e3;   
        const double mega  = 1.0e6;   
        const double giga  = 1.0e9;   
    } // namespace prefix

    namespace unit
    {
        inline double square(double v) { return v * v;     }
        inline double cubic (double v) { return v * v * v; }

        // --------------------------------------------------------------
        // Basic (fundamental) units and conversions
        // --------------------------------------------------------------

        const double meter =  1;
        const double inch  =  2.54 * prefix::centi*meter;
        const double feet  = 12    * inch;

        const double second =   1;
        const double minute =  60 * second;
        const double hour   =  60 * minute;
        const double day    =  24 * hour;
        const double year   = 365 * day;

        const double gallon = 231 * cubic(inch);
        const double stb    =  42 * gallon;
        const double liter  =   1 * cubic(prefix::deci*meter);

        const double kilogram = 1;
        // http://en.wikipedia.org/wiki/Pound_(mass)#Avoirdupois_pound
        const double pound    = 0.45359237 * kilogram;

        // --------------------------------------------------------------
        // Standardised constants
        // --------------------------------------------------------------

        const double gravity = 9.80665 * meter/square(second);

        // --------------------------------------------------------------
        // Derived units and conversions
        // --------------------------------------------------------------

        const double Newton = kilogram*meter / square(second); // == 1
        const double lbf    = pound * gravity; // Pound-force

        const double Pascal = Newton / square(meter); // == 1
        const double barsa  = 100000 * Pascal;
        const double atm    = 101325 * Pascal;
        const double psia   = lbf / square(inch);

        const double Pas   = Pascal * second; // == 1
        const double Poise = prefix::deci*Pas;

        namespace perm_details {
            const double p_grad   = atm / (prefix::centi*meter);
            const double area     = square(prefix::centi*meter);
            const double flux     = cubic (prefix::centi*meter) / second;
            const double velocity = flux / area;
            const double visc     = prefix::centi*Poise;
            const double darcy    = (velocity * visc) / p_grad;
            //                    == 1e-7 [m^2] / 101325
            //                    == 9.869232667160130e-13 [m^2]
        }
        const double darcy = perm_details::darcy;

        namespace convert {
            inline double from(const double q, const double unit)
            {
                return q * unit;
            }

            inline double to(const double q, const double unit)
            {
                return q / unit;
            }
        } // namespace convert
    } // namespace unit
} // namespace Opm
#endif // OPM_UNITS_HEADER