TwoPhaseLETCurvesParams.hpp

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  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/>.
 
  Consult the COPYING file in the top-level source directory of this
  module for the precise wording of the license and the list of
  copyright holders.
*/
#ifndef OPM_TWO_PHASE_LET_CURVES_PARAMS_HPP
#define OPM_TWO_PHASE_LET_CURVES_PARAMS_HPP
 
#include <opm/material/common/Valgrind.hpp>
#include <opm/material/common/EnsureFinalized.hpp>
 
namespace Opm {

template <class TraitsT>
class TwoPhaseLETCurvesParams : public EnsureFinalized
{
    using Scalar = typename TraitsT::Scalar;
 
public:
    using Traits = TraitsT;
 
    static constexpr int wIdx = 0; //wetting phase index for two phase let
    static constexpr int nwIdx = 1; //non-wetting phase index for two phase let
 
    TwoPhaseLETCurvesParams()
    {
        Valgrind::SetUndefined(*this);
    }
 
    virtual ~TwoPhaseLETCurvesParams() {}

    void finalize()
    {
        EnsureFinalized :: finalize ();
 
        // printLETCoeffs();
    }

    Scalar Smin(const unsigned phaseIdx) const
    { EnsureFinalized::check(); if (phaseIdx<Traits::numPhases) return Smin_[phaseIdx]; return 0.0;}

    Scalar dS(const unsigned phaseIdx) const
    { EnsureFinalized::check(); if (phaseIdx<Traits::numPhases) return dS_[phaseIdx]; return 0.0;}

    Scalar Sminpc() const
    { EnsureFinalized::check(); return Sminpc_; }

    Scalar dSpc() const
    { EnsureFinalized::check(); return dSpc_; }

    Scalar L(const unsigned phaseIdx) const
    { EnsureFinalized::check(); if (phaseIdx<Traits::numPhases) return L_[phaseIdx]; return 0.0;}

    Scalar E(const unsigned phaseIdx) const
    { EnsureFinalized::check(); if (phaseIdx<Traits::numPhases) return E_[phaseIdx]; return 0.0;}

    Scalar T(const unsigned phaseIdx) const
    { EnsureFinalized::check(); if (phaseIdx<Traits::numPhases) return T_[phaseIdx]; return 0.0;}

    Scalar Krt(const unsigned phaseIdx) const
    { EnsureFinalized::check(); if (phaseIdx<Traits::numPhases) return Krt_[phaseIdx]; return 0.0;}

    Scalar Lpc() const
    { EnsureFinalized::check(); return Lpc_; }

    Scalar Epc() const
    { EnsureFinalized::check(); return Epc_; }

    Scalar Tpc() const
    { EnsureFinalized::check(); return Tpc_; }

    Scalar Pcir() const
    { EnsureFinalized::check(); return Pcir_; }

    Scalar Pct() const
    { EnsureFinalized::check(); return Pct_; }

    template <class Container>
    void setKrwSamples(const Container& letProp, const Container& )
    {
        setLETCoeffs(wIdx, letProp[2], letProp[3], letProp[4], letProp[5]);
        //Smin_[wIdx] = letProp[1];
        //dS_[nwIdx] = 1.0 - letProp[0];
        Smin_[wIdx] = letProp[0];
        dS_[wIdx] = letProp[1] - letProp[0];
    }

    template <class Container>
    void setKrnSamples(const Container& letProp, const Container& )
    {
        setLETCoeffs(nwIdx, letProp[2], letProp[3], letProp[4], letProp[5]);
        //Smin_[nwIdx] = letProp[1];
        //dS_[wIdx] = 1.0 - letProp[0];
        Smin_[nwIdx] = letProp[0];
        dS_[nwIdx] = letProp[1] - letProp[0];
    }
 

    template <class Container>
    void setPcnwSamples(const Container& letProp, const Container& )
    {
        setLETPcCoeffs(letProp[2], letProp[3], letProp[4], letProp[5], letProp[6]);