miscUtilities.hpp

Go to the documentation of this file.

/*
  Copyright 2012 SINTEF ICT, Applied Mathematics.

  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_MISCUTILITIES_HEADER_INCLUDED
#define OPM_MISCUTILITIES_HEADER_INCLUDED

#include <vector>
#include <iosfwd>

struct Wells;
struct UnstructuredGrid;

namespace Opm
{

    class IncompPropertiesInterface;
    class BlackoilPropertiesInterface;
    class RockCompressibility;

    void computePorevolume(const UnstructuredGrid& grid,
                           const double* porosity,
               std::vector<double>& porevol);

    template<class T>
    void computePorevolume(int number_of_cells,
                           T begin_cell_volume,
                           const double* porosity,
                           std::vector<double>& porevol);

    void computePorevolume(const UnstructuredGrid& grid,
                           const double* porosity,
                           const RockCompressibility& rock_comp,
                           const std::vector<double>& pressure,
                           std::vector<double>& porevol);

    template<class T>
    void computePorevolume(int number_of_cells,
                           T begin_cell_volume,
                           const double* porosity,
                           const RockCompressibility& rock_comp,
                           const std::vector<double>& pressure,
                           std::vector<double>& porevol);

    void computePorosity(const UnstructuredGrid& grid,
                         const double* porosity_standard,
                         const RockCompressibility& rock_comp,
                         const std::vector<double>& pressure,
                         std::vector<double>& porosity);

    void computeSaturatedVol(const std::vector<double>& pv,
                 const std::vector<double>& s,
                 double* sat_vol);


    void computeAverageSat(const std::vector<double>& pv,
               const std::vector<double>& s,
               double* aver_sat);


    void computeInjectedProduced(const IncompPropertiesInterface& props,
                 const std::vector<double>& s,
                 const std::vector<double>& src,
                 const double dt,
                 double* injected,
                 double* produced);

    void computeTotalMobility(const Opm::IncompPropertiesInterface& props,
                  const std::vector<int>& cells,
                  const std::vector<double>& s,
                  std::vector<double>& totmob);

    void computeTotalMobilityOmega(const Opm::IncompPropertiesInterface& props,
                   const std::vector<int>& cells,
                   const std::vector<double>& s,
                   std::vector<double>& totmob,
                   std::vector<double>& omega);


    void computePhaseMobilities(const Opm::IncompPropertiesInterface& props,
                                const std::vector<int>&               cells,
                                const std::vector<double>&            s    ,
                                std::vector<double>&                  pmobc);


    void computeFractionalFlow(const Opm::IncompPropertiesInterface& props,
                               const std::vector<int>& cells,
                               const std::vector<double>& saturations,
                               std::vector<double>& fractional_flows);


    void computeTransportSource(const UnstructuredGrid& grid,
                const std::vector<double>& src,
                const std::vector<double>& faceflux,
                const double inflow_frac,
                                const Wells* wells,
                                const std::vector<double>& well_perfrates,
                std::vector<double>& transport_src);


    void estimateCellVelocity(const UnstructuredGrid& grid,
                  const std::vector<double>& face_flux,
                  std::vector<double>& cell_velocity);

    template<class CC, class FC, class FC1, class CV>
    void estimateCellVelocity(int number_of_cells,
                              int number_of_faces,
                              FC begin_face_centroids,
                              FC1 face_cells,
                              CC begin_cell_centroids,
                              CV begin_cell_volumes,
                              int dimension,
                              const std::vector<double>& face_flux,
                              std::vector<double>& cell_velocity);

    void toWaterSat(const std::vector<double>& sboth,
            std::vector<double>& sw);

    void toBothSat(const std::vector<double>& sw,
           std::vector<double>& sboth);

    void wellsToSrc(const Wells& wells, const int num_cells, std::vector<double>& src);

    void computeWDP(const Wells& wells, const UnstructuredGrid& grid, const std::vector<double>& saturations,
                    const double* densities, const double gravity, const bool per_grid_cell,
                    std::vector<double>& wdp);

    template<class T>
    void computeWDP(const Wells& wells, int number_of_cells, T begin_cell_centroids,
                    const std::vector<double>& saturations,
                    const double* densities, const double gravity, const bool per_grid_cell,
                    std::vector<double>& wdp);

    void computeFlowRatePerWell(const Wells& wells, const std::vector<double>& flow_rates_per_cell,
                                std::vector<double>& flow_rates_per_well);

    void computePhaseFlowRatesPerWell(const Wells& wells,
                                      const std::vector<double>& flow_rates_per_well_cell,
                                      const std::vector<double>& fractional_flows,
                                      std::vector<double>& phase_flow_per_well);




    class Watercut
    {
    public:
        void push(double time, double fraction, double produced);
        void write(std::ostream& os) const;
    private:
        std::vector<double> data_;
    };




    class WellReport
    {
    public:
        void push(const IncompPropertiesInterface& props,
                  const Wells& wells,
                  const std::vector<double>& saturation,
                  const double time,
                  const std::vector<double>& well_bhp,
                  const std::vector<double>& well_perfrates);
        void push(const BlackoilPropertiesInterface& props,
                  const Wells& wells,
                  const std::vector<double>& p,
                  const std::vector<double>& z,
                  const std::vector<double>& s,
                  const double time,
                  const std::vector<double>& well_bhp,
                  const std::vector<double>& well_perfrates);
        void write(std::ostream& os) const;
    private:
        std::vector<std::vector<double> > data_;
    };

} // namespace Opm

#include "miscUtilities_impl.hpp"
#endif // OPM_MISCUTILITIES_HEADER_INCLUDED