BlackoilPropsAdFromDeck.hpp

Go to the documentation of this file.

/*
  Copyright 2013 SINTEF ICT, Applied Mathematics.
  Copyright 2015 Dr. Blatt - HPC-Simulation-Software & Services.
  Copyright 2015 NTNU.

  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_BLACKOILPROPSADFROMDECK_HEADER_INCLUDED
#define OPM_BLACKOILPROPSADFROMDECK_HEADER_INCLUDED

#include <opm/autodiff/BlackoilPropsAdInterface.hpp>
#include <opm/autodiff/AutoDiffBlock.hpp>

#include <opm/core/props/BlackoilPhases.hpp>
#include <opm/core/props/satfunc/SaturationPropsFromDeck.hpp>
#include <opm/core/props/rock/RockFromDeck.hpp>

#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>

#include <memory>
#include <array>
#include <vector>

#ifdef HAVE_DUNE_CORNERPOINT
#include <opm/common/utility/platform_dependent/disable_warnings.h>
#include <dune/grid/CpGrid.hpp>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#endif

namespace Opm
{
    class PvtInterface;

    class BlackoilPropsAdFromDeck : public BlackoilPropsAdInterface
    {
        friend class BlackoilPropsDataHandle;
    public:
        typedef typename SaturationPropsFromDeck::MaterialLawManager MaterialLawManager;

        BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
                                Opm::EclipseStateConstPtr eclState,
                                std::shared_ptr<MaterialLawManager> materialLawManager,
                                const UnstructuredGrid& grid,
                                const bool init_rock = true );

#ifdef HAVE_DUNE_CORNERPOINT
        BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
                                Opm::EclipseStateConstPtr eclState,
                                std::shared_ptr<MaterialLawManager> materialLawManager,
                                const Dune::CpGrid& grid,
                                const bool init_rock = true );
#endif

        BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
                                Opm::EclipseStateConstPtr eclState,
                                const UnstructuredGrid& grid,
                                const bool init_rock = true );

#ifdef HAVE_DUNE_CORNERPOINT
        BlackoilPropsAdFromDeck(Opm::DeckConstPtr deck,
                                Opm::EclipseStateConstPtr eclState,
                                const Dune::CpGrid& grid,
                                const bool init_rock = true );
#endif

        BlackoilPropsAdFromDeck(const BlackoilPropsAdFromDeck& props,
                                const int number_of_cells);


        //      Rock interface    //

        int numDimensions() const;

        int numCells() const;

        virtual const int* cellPvtRegionIndex() const
        { return &cellPvtRegionIdx_[0]; }

        const double* porosity() const;

        const double* permeability() const;


        //      Fluid interface   //

        typedef AutoDiffBlock<double> ADB;
        typedef ADB::V V;
        typedef std::vector<int> Cells;

        int numPhases() const;

        PhaseUsage phaseUsage() const;

        // ------ Density ------

        const double* surfaceDensity(const int cellIdx = 0) const;


        // ------ Viscosity ------

        ADB muWat(const ADB& pw,
                  const ADB& T,
                  const Cells& cells) const;

        ADB muOil(const ADB& po,
                  const ADB& T,
                  const ADB& rs,
                  const std::vector<PhasePresence>& cond,
                  const Cells& cells) const;

        ADB muGas(const ADB& pg,
                  const ADB& T,
                  const ADB& rv,
                  const std::vector<PhasePresence>& cond,
                  const Cells& cells) const;

        // ------ Formation volume factor (b) ------

        ADB bWat(const ADB& pw,
                 const ADB& T,
                 const Cells& cells) const;

        ADB bOil(const ADB& po,
                 const ADB& T,
                 const ADB& rs,
                 const std::vector<PhasePresence>& cond,
                 const Cells& cells) const;

        ADB bGas(const ADB& pg,
                 const ADB& T,
                 const ADB& rv,
                 const std::vector<PhasePresence>& cond,
                 const Cells& cells) const;

        // ------ Rs bubble point curve ------

        V rsSat(const V& po,
                const Cells& cells) const;

        V rsSat(const V& po,
                const V& so,
                const Cells& cells) const;

        ADB rsSat(const ADB& po,
                  const Cells& cells) const;

        ADB rsSat(const ADB& po,
                  const ADB& so,
                  const Cells& cells) const;

        // ------ Rv condensation curve ------

        ADB rvSat(const ADB& po,
                  const Cells& cells) const;

        ADB rvSat(const ADB& po,
                  const ADB& so,
                  const Cells& cells) const;

        // ------ Relative permeability ------

        std::vector<ADB> relperm(const ADB& sw,
                                 const ADB& so,
                                 const ADB& sg,
                                 const Cells& cells) const;

        std::vector<ADB> capPress(const ADB& sw,
                                  const ADB& so,
                                  const ADB& sg,
                                  const Cells& cells) const;
                                  
        void updateSatHyst(const std::vector<double>& saturation,
                           const std::vector<int>& cells);

        void updateSatOilMax(const std::vector<double>& saturation);

        void setSwatInitScaling(const std::vector<double>& saturation,
                      const std::vector<double>& pc);


    private:
        void init(Opm::DeckConstPtr deck,
                  Opm::EclipseStateConstPtr eclState,
                  std::shared_ptr<MaterialLawManager> materialLawManager,
                  int number_of_cells,
                  const int* global_cell,
                  const int* cart_dims,
                  const bool init_rock);

        void applyVap(V& r,
                      const V& so,
                      const std::vector<int>& cells,
                      const double vap) const;

        void applyVap(ADB& r,
                      const ADB& so,
                      const std::vector<int>& cells,
                      const double vap) const;

        // Fills pvt_region_ with cellPvtRegionIdx_[cells].
        void mapPvtRegions(const std::vector<int>& cells) const;

        RockFromDeck rock_;

        // This has to be a shared pointer as we must
        // be able to make a copy of *this in the parallel case.
        std::shared_ptr<MaterialLawManager> materialLawManager_;
        std::shared_ptr<SaturationPropsFromDeck> satprops_;

        PhaseUsage phase_usage_;
        // bool has_vapoil_;
        // bool has_disgas_;

        // The PVT region which is to be used for each cell
        std::vector<int> cellPvtRegionIdx_;

        // Used for storing the region-per-cell array computed in calls
        // to pvt functions.
        mutable std::vector<int> pvt_region_;

        // The PVT properties. One object per active fluid phase.
        std::vector<std::shared_ptr<Opm::PvtInterface> > props_;

        // Densities, one std::array per PVT region.
        std::vector<std::array<double, BlackoilPhases::MaxNumPhases> > densities_;

        // VAPPARS
        double vap1_;
        double vap2_;
        std::vector<double> satOilMax_;
        double vap_satmax_guard_;  //Threshold value to promote stability

    };
} // namespace Opm

#endif // OPM_BLACKOILPROPSADFROMDECK_HEADER_INCLUDED