BlackoilModelBase.hpp

Go to the documentation of this file.

/*
  Copyright 2013, 2015 SINTEF ICT, Applied Mathematics.
  Copyright 2014, 2015 Statoil ASA.
  Copyright 2014, 2015 Dr. Markus 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_BLACKOILMODELBASE_HEADER_INCLUDED
#define OPM_BLACKOILMODELBASE_HEADER_INCLUDED

#include <cassert>

#include <opm/autodiff/AutoDiffBlock.hpp>
#include <opm/autodiff/AutoDiffHelpers.hpp>
#include <opm/autodiff/BlackoilPropsAdInterface.hpp>
#include <opm/autodiff/LinearisedBlackoilResidual.hpp>
#include <opm/autodiff/NewtonIterationBlackoilInterface.hpp>
#include <opm/autodiff/BlackoilModelEnums.hpp>
#include <opm/autodiff/VFPProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>

#include <array>

struct Wells;

namespace Opm {

    namespace parameter { class ParameterGroup; }
    class DerivedGeology;
    class RockCompressibility;
    class NewtonIterationBlackoilInterface;
    class VFPProperties;


    struct DefaultBlackoilSolutionState
    {
        typedef AutoDiffBlock<double> ADB;
        explicit DefaultBlackoilSolutionState(const int np)
            : pressure  (    ADB::null())
            , temperature(   ADB::null())
            , saturation(np, ADB::null())
            , rs        (    ADB::null())
            , rv        (    ADB::null())
            , qs        (    ADB::null())
            , bhp       (    ADB::null())
            , canonical_phase_pressures(3, ADB::null())
        {
        }
        ADB              pressure;
        ADB              temperature;
        std::vector<ADB> saturation;
        ADB              rs;
        ADB              rv;
        ADB              qs;
        ADB              bhp;
        // Below are quantities stored in the state for optimization purposes.
        std::vector<ADB> canonical_phase_pressures; // Always has 3 elements, even if only 2 phases active.
    };




    template <class ConcreteModel>
    struct ModelTraits;


    template<class Grid, class Implementation>
    class BlackoilModelBase
    {
    public:
        // ---------  Types and enums  ---------
        typedef AutoDiffBlock<double> ADB;
        typedef ADB::V V;
        typedef ADB::M M;

        typedef typename ModelTraits<Implementation>::ReservoirState ReservoirState;
        typedef typename ModelTraits<Implementation>::WellState WellState;
        typedef typename ModelTraits<Implementation>::ModelParameters ModelParameters;
        typedef typename ModelTraits<Implementation>::SolutionState SolutionState;

        // ---------  Public methods  ---------

        BlackoilModelBase(const ModelParameters&          param,
                          const Grid&                     grid ,
                          const BlackoilPropsAdInterface& fluid,
                          const DerivedGeology&           geo  ,
                          const RockCompressibility*      rock_comp_props,
                          const Wells*                    wells,
                          const NewtonIterationBlackoilInterface& linsolver,
                          Opm::EclipseStateConstPtr eclState,
                          const bool has_disgas,
                          const bool has_vapoil,
                          const bool terminal_output);

        void setThresholdPressures(const std::vector<double>& threshold_pressures_by_face);

        void prepareStep(const double dt,
                         ReservoirState& reservoir_state,
                         WellState& well_state);

        void afterStep(const double dt,
                       ReservoirState& reservoir_state,
                       WellState& well_state);

        void assemble(const ReservoirState& reservoir_state,
                      WellState& well_state,
                      const bool initial_assembly);

        std::vector<double> computeResidualNorms() const;

        int sizeNonLinear() const;

        int linearIterationsLastSolve() const;

        V solveJacobianSystem() const;

        void updateState(const V& dx,
                         ReservoirState& reservoir_state,
                         WellState& well_state);

        bool terminalOutputEnabled() const;

        bool getConvergence(const double dt, const int iteration);

        int numPhases() const;

        int numMaterials() const;

        const std::string& materialName(int material_index) const;

        void updateEquationsScaling();

    protected:

        // ---------  Types and enums  ---------

        typedef Eigen::Array<double,
                             Eigen::Dynamic,
                             Eigen::Dynamic,
                             Eigen::RowMajor> DataBlock;

        struct ReservoirResidualQuant {
            ReservoirResidualQuant();
            std::vector<ADB> accum; // Accumulations
            ADB              mflux; // Mass flux (surface conditions)
            ADB              b;     // Reciprocal FVF
            ADB              dh;    // Pressure drop across int. interfaces
            ADB              mob;   // Phase mobility (per cell)
        };

        struct WellOps {
            WellOps(const Wells* wells);
            Eigen::SparseMatrix<double> w2p;              // well -> perf (scatter)
            Eigen::SparseMatrix<double> p2w;              // perf -> well (gather)
        };

        // ---------  Data members  ---------

        const Grid&         grid_;
        const BlackoilPropsAdInterface& fluid_;
        const DerivedGeology&           geo_;
        const RockCompressibility*      rock_comp_props_;
        const Wells*                    wells_;
        VFPProperties                   vfp_properties_;
        const NewtonIterationBlackoilInterface&    linsolver_;
        // For each canonical phase -> true if active
        const std::vector<bool>         active_;
        // Size = # active phases. Maps active -> canonical phase indices.
        const std::vector<int>          canph_;
        const std::vector<int>          cells_;  // All grid cells
        HelperOps                       ops_;
        const WellOps                   wops_;
        const bool has_disgas_;
        const bool has_vapoil_;

        ModelParameters                 param_;
        bool use_threshold_pressure_;
        bool wells_active_;
        V threshold_pressures_by_interior_face_;

        std::vector<ReservoirResidualQuant> rq_;
        std::vector<PhasePresence> phaseCondition_;
        V isRs_;
        V isRv_;
        V isSg_;
        V well_perforation_densities_; //Density of each well perforation
        V well_perforation_pressure_diffs_; // Diff to bhp for each well perforation.

        LinearisedBlackoilResidual residual_;

        bool terminal_output_;

        std::vector<int>         primalVariable_;
        V pvdt_;
        std::vector<std::string> material_name_;

        // ---------  Protected methods  ---------

        Implementation& asImpl()
        {
            return static_cast<Implementation&>(*this);
        }

        const Implementation& asImpl() const
        {
            return static_cast<const Implementation&>(*this);
        }

        // return true if wells are available in the reservoir
        bool wellsActive() const { return wells_active_; }
        // return true if wells are available on this process
        bool localWellsActive() const { return wells_ ? (wells_->number_of_wells > 0 ) : false; }
        // return wells object
        const Wells& wells () const { assert( bool(wells_ != 0) ); return *wells_; }

        void
        makeConstantState(SolutionState& state) const;

        SolutionState
        variableState(const ReservoirState& x,
                      const WellState& xw) const;

        std::vector<V>
        variableStateInitials(const ReservoirState& x,
                              const WellState& xw) const;
        void
        variableReservoirStateInitials(const ReservoirState& x,
                                       std::vector<V>& vars0) const;
        void
        variableWellStateInitials(const WellState& xw,
                                  std::vector<V>& vars0) const;

        std::vector<int>
        variableStateIndices() const;

        std::vector<int>
        variableWellStateIndices() const;

        SolutionState
        variableStateExtractVars(const ReservoirState& x,
                                 const std::vector<int>& indices,
                                 std::vector<ADB>& vars) const;

        void
        variableStateExtractWellsVars(const std::vector<int>& indices,
                                      std::vector<ADB>& vars,
                                      SolutionState& state) const;

        void
        computeAccum(const SolutionState& state,
                     const int            aix  );

        void computeWellConnectionPressures(const SolutionState& state,
                                            const WellState& xw);

        void
        assembleMassBalanceEq(const SolutionState& state);

        void
        solveWellEq(const std::vector<ADB>& mob_perfcells,
                    const std::vector<ADB>& b_perfcells,
                    SolutionState& state,
                    WellState& well_state);

        void
        computeWellFlux(const SolutionState& state,
                        const std::vector<ADB>& mob_perfcells,
                        const std::vector<ADB>& b_perfcells,
                        V& aliveWells,
                        std::vector<ADB>& cq_s);

        void
        updatePerfPhaseRatesAndPressures(const std::vector<ADB>& cq_s,
                                         const SolutionState& state,
                                         WellState& xw);

        void
        addWellFluxEq(const std::vector<ADB>& cq_s,
                      const SolutionState& state);

        void
        addWellContributionToMassBalanceEq(const std::vector<ADB>& cq_s,
                                           const SolutionState& state,
                                           const WellState& xw);

        void
        addWellControlEq(const SolutionState& state,
                         const WellState& xw,
                         const V& aliveWells);

        void updateWellControls(WellState& xw) const;

        void updateWellState(const V& dwells,
                             WellState& well_state);

        bool getWellConvergence(const int iteration);

        bool isVFPActive() const;

        std::vector<ADB>
        computePressures(const ADB& po,
                         const ADB& sw,
                         const ADB& so,
                         const ADB& sg) const;

        V
        computeGasPressure(const V& po,
                           const V& sw,
                           const V& so,
                           const V& sg) const;

        std::vector<ADB>
        computeRelPerm(const SolutionState& state) const;

        void
        computeMassFlux(const int               actph ,
                        const V&                transi,
                        const ADB&              kr    ,
                        const ADB&              p     ,
                        const SolutionState&    state );

        void applyThresholdPressures(ADB& dp);

        ADB
        fluidViscosity(const int               phase,
                       const ADB&              p    ,
                       const ADB&              temp ,
                       const ADB&              rs   ,
                       const ADB&              rv   ,
                       const std::vector<PhasePresence>& cond) const;

        ADB
        fluidReciprocFVF(const int               phase,
                         const ADB&              p    ,
                         const ADB&              temp ,
                         const ADB&              rs   ,
                         const ADB&              rv   ,
                         const std::vector<PhasePresence>& cond) const;

        ADB
        fluidDensity(const int  phase,
                     const ADB& b,
                     const ADB& rs,
                     const ADB& rv) const;

        V
        fluidRsSat(const V&                p,
                   const V&                so,
                   const std::vector<int>& cells) const;

        ADB
        fluidRsSat(const ADB&              p,
                   const ADB&              so,
                   const std::vector<int>& cells) const;

        V
        fluidRvSat(const V&                p,
                   const V&                so,
                   const std::vector<int>& cells) const;

        ADB
        fluidRvSat(const ADB&              p,
                   const ADB&              so,
                   const std::vector<int>& cells) const;

        ADB
        poroMult(const ADB& p) const;

        ADB
        transMult(const ADB& p) const;

        const std::vector<PhasePresence>
        phaseCondition() const {return phaseCondition_;}

        void
        classifyCondition(const ReservoirState& state);


        void
        updatePrimalVariableFromState(const ReservoirState& state);

        void
        updatePhaseCondFromPrimalVariable();

        double
        convergenceReduction(const Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic>& B,
                             const Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic>& tempV,
                             const Eigen::Array<double, Eigen::Dynamic, Eigen::Dynamic>& R,
                             std::vector<double>& R_sum,
                             std::vector<double>& maxCoeff,
                             std::vector<double>& B_avg,
                             std::vector<double>& maxNormWell,
                             int nc,
                             int nw) const;

        double dpMaxRel() const { return param_.dp_max_rel_; }
        double dsMax() const { return param_.ds_max_; }
        double drMaxRel() const { return param_.dr_max_rel_; }
        double maxResidualAllowed() const { return param_.max_residual_allowed_; }

    };
} // namespace Opm

#include "BlackoilModelBase_impl.hpp"

#endif // OPM_BLACKOILMODELBASE_HEADER_INCLUDED