mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
remove files moved to opm-simulators-legacy
This commit is contained in:
Arne Morten Kvarving
parent
b6f8128260
commit
51da91c1ad
@ -1,285 +0,0 @@
|
||||
/*
|
||||
Copyright 2016 Statoil ASA
|
||||
Copyright 2016 IRIS
|
||||
Copyright 2017 SINTEF Digital, Mathematics and Cybernetics.
|
||||
|
||||
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/>.
|
||||
*/
|
||||
|
||||
#include <opm/autodiff/Compat.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include <opm/polymer/PolymerBlackoilState.hpp>
|
||||
#include <opm/common/data/SimulationDataContainer.hpp>
|
||||
#include <opm/core/props/BlackoilPhases.hpp>
|
||||
#include <opm/core/simulator/BlackoilState.hpp>
|
||||
#include <opm/autodiff/WellStateFullyImplicitBlackoil.hpp>
|
||||
#include <opm/output/data/Cells.hpp>
|
||||
#include <opm/output/data/Solution.hpp>
|
||||
#include <opm/output/data/Wells.hpp>
|
||||
|
||||
namespace Opm {
|
||||
|
||||
std::vector< double > destripe( const std::vector< double >& v,
|
||||
size_t stride,
|
||||
size_t offset ) {
|
||||
|
||||
std::vector< double > dst( v.size() / stride );
|
||||
|
||||
size_t di = 0;
|
||||
for( size_t i = offset; i < v.size(); i += stride ) {
|
||||
dst[ di++ ] = v[ i ];
|
||||
}
|
||||
|
||||
return dst;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
std::vector< double >& stripe( const std::vector< double >& v,
|
||||
size_t stride,
|
||||
size_t offset,
|
||||
std::vector< double >& dst ) {
|
||||
|
||||
/* does little range checking etc; for future revisions */
|
||||
size_t vi = 0;
|
||||
for( size_t i = offset; i < dst.size(); i += stride ) {
|
||||
dst[ i ] = v[ vi++ ];
|
||||
}
|
||||
|
||||
return dst;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
data::Solution simToSolution( const SimulationDataContainer& reservoir,
|
||||
const bool use_si_units,
|
||||
PhaseUsage phases ) {
|
||||
|
||||
// Set up unit system to use to suppress conversion if use_si_units is true.
|
||||
const UnitSystem::measure press_unit = use_si_units ? UnitSystem::measure::identity : UnitSystem::measure::pressure;
|
||||
const UnitSystem::measure temp_unit = use_si_units ? UnitSystem::measure::identity : UnitSystem::measure::temperature;
|
||||
const UnitSystem::measure rs_unit = use_si_units ? UnitSystem::measure::identity : UnitSystem::measure::gas_oil_ratio;
|
||||
const UnitSystem::measure rv_unit = use_si_units ? UnitSystem::measure::identity : UnitSystem::measure::oil_gas_ratio;
|
||||
|
||||
data::Solution sol;
|
||||
sol.insert( "PRESSURE", press_unit, reservoir.pressure() , data::TargetType::RESTART_SOLUTION);
|
||||
sol.insert( "TEMP" , temp_unit, reservoir.temperature() , data::TargetType::RESTART_SOLUTION );
|
||||
|
||||
const auto ph = reservoir.numPhases();
|
||||
const auto& sat = reservoir.saturation();
|
||||
|
||||
const auto aqua = BlackoilPhases::Aqua;
|
||||
const auto vapour = BlackoilPhases::Vapour;
|
||||
|
||||
if( phases.phase_used[ aqua ] ) {
|
||||
sol.insert( "SWAT", UnitSystem::measure::identity, destripe( sat, ph, phases.phase_pos[ aqua ] ) , data::TargetType::RESTART_SOLUTION );
|
||||
}
|
||||
|
||||
if( phases.phase_used[ vapour ] ) {
|
||||
sol.insert( "SGAS", UnitSystem::measure::identity, destripe( sat, ph, phases.phase_pos[ vapour ] ) , data::TargetType::RESTART_SOLUTION );
|
||||
}
|
||||
|
||||
if( reservoir.hasCellData( BlackoilState::GASOILRATIO ) ) {
|
||||
sol.insert( "RS", rs_unit, reservoir.getCellData( BlackoilState::GASOILRATIO ) , data::TargetType::RESTART_SOLUTION );
|
||||
}
|
||||
|
||||
if( reservoir.hasCellData( BlackoilState::RV ) ) {
|
||||
sol.insert( "RV", rv_unit, reservoir.getCellData( BlackoilState::RV ) , data::TargetType::RESTART_SOLUTION );
|
||||
}
|
||||
|
||||
if (phases.has_solvent) {
|
||||
sol.insert( "SSOL", UnitSystem::measure::identity, reservoir.getCellData( BlackoilState::SSOL ) , data::TargetType::RESTART_SOLUTION );
|
||||
}
|
||||
|
||||
if (phases.has_polymer) {
|
||||
if (reservoir.hasCellData( PolymerBlackoilState::CONCENTRATION )) { // compatibility with legacy polymer
|
||||
sol.insert( "POLYMER", UnitSystem::measure::identity, reservoir.getCellData( PolymerBlackoilState::CONCENTRATION ) , data::TargetType::RESTART_SOLUTION );
|
||||
} else {
|
||||
sol.insert( "POLYMER", UnitSystem::measure::identity, reservoir.getCellData( BlackoilState::POLYMER ) , data::TargetType::RESTART_SOLUTION );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return sol;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void solutionToSim( const RestartValue& restart_value,
|
||||
PhaseUsage phases,
|
||||
SimulationDataContainer& state ) {
|
||||
|
||||
const auto& sol = restart_value.solution;
|
||||
const auto stride = phases.num_phases;
|
||||
|
||||
if( sol.has( "SWAT" ) ) {
|
||||
stripe( sol.data( "SWAT" ),
|
||||
stride,
|
||||
phases.phase_pos[ BlackoilPhases::Aqua ],
|
||||
state.saturation() );
|
||||
}
|
||||
|
||||
if( sol.has( "SGAS" ) ) {
|
||||
stripe( sol.data( "SGAS" ),
|
||||
stride,
|
||||
phases.phase_pos[ BlackoilPhases::Vapour ],
|
||||
state.saturation() );
|
||||
}
|
||||
|
||||
for (size_t c = 0; c < state.numCells(); ++c) {
|
||||
double& so = state.saturation()[phases.num_phases*c + phases.phase_pos[ BlackoilPhases::Liquid ]];
|
||||
so = 1.0;
|
||||
if (phases.phase_used[ BlackoilPhases::Aqua]) {
|
||||
so -= state.saturation()[phases.num_phases*c + phases.phase_pos[ BlackoilPhases::Aqua ]];
|
||||
}
|
||||
if (phases.phase_used[ BlackoilPhases::Vapour]) {
|
||||
so -= state.saturation()[phases.num_phases*c + phases.phase_pos[ BlackoilPhases::Vapour ]];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if( sol.has( "PRESSURE" ) ) {
|
||||
state.pressure() = sol.data( "PRESSURE" );
|
||||
}
|
||||
|
||||
if( sol.has( "TEMP" ) ) {
|
||||
state.temperature() = sol.data( "TEMP" );
|
||||
}
|
||||
|
||||
if( sol.has( "RS" ) ) {
|
||||
state.registerCellData("GASOILRATIO", 1);
|
||||
state.getCellData( "GASOILRATIO" ) = sol.data( "RS" );
|
||||
}
|
||||
|
||||
if( sol.has( "RV" ) ) {
|
||||
state.registerCellData("RV", 1);
|
||||
state.getCellData( "RV" ) = sol.data( "RV" );
|
||||
}
|
||||
|
||||
if ( sol.has( "SSOL" ) ) {
|
||||
state.registerCellData("SSOL", 1);
|
||||
state.getCellData("SSOL") = sol.data("SSOL");
|
||||
}
|
||||
|
||||
if ( sol.has("SOMAX" ) ) {
|
||||
state.registerCellData("SOMAX", 1);
|
||||
state.getCellData("SOMAX") = sol.data("SOMAX");
|
||||
}
|
||||
|
||||
if ( sol.has("PCSWM_OW" ) ) {
|
||||
state.registerCellData("PCSWMDC_OW", 1);
|
||||
state.getCellData("PCSWMDC_OW") = sol.data("PCSWM_OW");
|
||||
}
|
||||
|
||||
if ( sol.has("KRNSW_OW" ) ) {
|
||||
state.registerCellData("KRNSWMDC_OW", 1);
|
||||
state.getCellData("KRNSWMDC_OW") = sol.data("KRNSW_OW");
|
||||
}
|
||||
|
||||
if ( sol.has("PCSWM_GO" ) ) {
|
||||
state.registerCellData("PCSWMDC_GO", 1);
|
||||
state.getCellData("PCSWMDC_GO") = sol.data("PCSWM_GO");
|
||||
}
|
||||
|
||||
if ( sol.has("KRNSW_GO" ) ) {
|
||||
state.registerCellData("KRNSWMDC_GO", 1);
|
||||
state.getCellData("KRNSWMDC_GO") = sol.data("KRNSW_GO");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void wellsToState( const data::Wells& wells,
|
||||
PhaseUsage phases,
|
||||
WellStateFullyImplicitBlackoil& state ) {
|
||||
|
||||
using rt = data::Rates::opt;
|
||||
|
||||
const auto np = phases.num_phases;
|
||||
|
||||
std::vector< rt > phs( np );
|
||||
if( phases.phase_used[BlackoilPhases::Aqua] ) {
|
||||
phs.at( phases.phase_pos[BlackoilPhases::Aqua] ) = rt::wat;
|
||||
}
|
||||
|
||||
if( phases.phase_used[BlackoilPhases::Liquid] ) {
|
||||
phs.at( phases.phase_pos[BlackoilPhases::Liquid] ) = rt::oil;
|
||||
}
|
||||
|
||||
if( phases.phase_used[BlackoilPhases::Vapour] ) {
|
||||
phs.at( phases.phase_pos[BlackoilPhases::Vapour] ) = rt::gas;
|
||||
}
|
||||
|
||||
for( const auto& wm : state.wellMap() ) {
|
||||
const auto well_index = wm.second[ 0 ];
|
||||
const auto& well = wells.at( wm.first );
|
||||
|
||||
state.bhp()[ well_index ] = well.bhp;
|
||||
state.temperature()[ well_index ] = well.temperature;
|
||||
state.currentControls()[ well_index ] = well.control;
|
||||
|
||||
const auto wellrate_index = well_index * np;
|
||||
for( size_t i = 0; i < phs.size(); ++i ) {
|
||||
assert( well.rates.has( phs[ i ] ) );
|
||||
state.wellRates()[ wellrate_index + i ] = well.rates.get( phs[ i ] );
|
||||
}
|
||||
|
||||
const auto perforation_pressure = []( const data::Connection& comp ) {
|
||||
return comp.pressure;
|
||||
};
|
||||
|
||||
const auto perforation_reservoir_rate = []( const data::Connection& comp ) {
|
||||
return comp.reservoir_rate;
|
||||
};
|
||||
|
||||
std::transform( well.connections.begin(),
|
||||
well.connections.end(),
|
||||
state.perfPress().begin() + wm.second[ 1 ],
|
||||
perforation_pressure );
|
||||
|
||||
std::transform( well.connections.begin(),
|
||||
well.connections.end(),
|
||||
state.perfRates().begin() + wm.second[ 1 ],
|
||||
perforation_reservoir_rate );
|
||||
|
||||
int local_comp_index = 0;
|
||||
for (const data::Connection& comp : well.connections) {
|
||||
const int global_comp_index = wm.second[1] + local_comp_index;
|
||||
for (int phase_index = 0; phase_index < np; ++phase_index) {
|
||||
state.perfPhaseRates()[global_comp_index*np + phase_index] = comp.rates.get(phs[phase_index]);
|
||||
}
|
||||
++local_comp_index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace Opm
|
||||
@ -1,75 +0,0 @@
|
||||
/*
|
||||
Copyright 2016 Statoil ASA
|
||||
2016 IRIS
|
||||
|
||||
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_SIMULATORS_COMPAT_HPP
|
||||
#define OPM_SIMULATORS_COMPAT_HPP
|
||||
|
||||
#include <opm/output/eclipse/RestartValue.hpp>
|
||||
#include <opm/output/data/Solution.hpp>
|
||||
#include <opm/output/data/Wells.hpp>
|
||||
#include <opm/core/props/BlackoilPhases.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace Opm {
|
||||
|
||||
// Forward declarations
|
||||
class SimulationDataContainer;
|
||||
class WellStateFullyImplicitBlackoil;
|
||||
|
||||
/// Extract single data vector from striped data.
|
||||
/// \return u such that u[i] = v[offset + i*stride].
|
||||
std::vector< double > destripe( const std::vector< double >& v,
|
||||
size_t stride,
|
||||
size_t offset );
|
||||
|
||||
/// Inject single data vector into striped data.
|
||||
/// \return reference to dst input, that is changed so that
|
||||
/// dst[offset + i*stride] = v[i]. This is done for
|
||||
/// i = 0..(dst.size()/stride).
|
||||
std::vector< double >& stripe( const std::vector< double >& v,
|
||||
size_t stride,
|
||||
size_t offset,
|
||||
std::vector< double >& dst );
|
||||
|
||||
/// Returns Solution with the following fields:
|
||||
/// PRESSURE, TEMP (unconditionally)
|
||||
/// SWAT, SGAS, RS, RV, SSOL (if appropriate fields present in input)
|
||||
/// If use_si_units is true, the fields will have the measure UnitSystem::measure::identity,
|
||||
/// and therefore *not* be converted to customary units (depending on family) upon output.
|
||||
data::Solution simToSolution( const SimulationDataContainer& reservoir,
|
||||
const bool use_si_units,
|
||||
PhaseUsage phases );
|
||||
|
||||
/// Copies the following fields from sol into state (all conditionally):
|
||||
/// PRESSURE, TEMP, SWAT, SGAS, RS, RV, SSOL
|
||||
/// Also handles extra data such as hysteresis parameters, SOMAX, etc.
|
||||
void solutionToSim( const RestartValue& restart_value,
|
||||
PhaseUsage phases,
|
||||
SimulationDataContainer& state );
|
||||
|
||||
/// Copies the following fields from wells into state.
|
||||
/// bhp, temperature, currentControls, wellRates, perfPress, perfRates, perfPhaseRates
|
||||
void wellsToState( const data::Wells& wells,
|
||||
PhaseUsage phases,
|
||||
WellStateFullyImplicitBlackoil& state );
|
||||
|
||||
}
|
||||
|
||||
#endif //OPM_SIMULATORS_COMPAT_HPP
|
||||
@ -1,776 +0,0 @@
|
||||
/*
|
||||
Copyright 2014, 2015 SINTEF ICT, Applied Mathematics.
|
||||
Copyright 2014, 2015 Statoil ASA.
|
||||
Copyright 2017, IRIS
|
||||
|
||||
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_RATECONVERTER_HPP_HEADER_INCLUDED
|
||||
#define OPM_RATECONVERTER_HPP_HEADER_INCLUDED
|
||||
|
||||
#include <opm/core/props/BlackoilPhases.hpp>
|
||||
#include <opm/core/simulator/BlackoilState.hpp>
|
||||
#include <opm/grid/utility/RegionMapping.hpp>
|
||||
#include <opm/core/linalg/ParallelIstlInformation.hpp>
|
||||
|
||||
#include <dune/grid/common/gridenums.hh>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <memory>
|
||||
#include <stdexcept>
|
||||
#include <type_traits>
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
/**
|
||||
* \file
|
||||
* Facility for converting component rates at surface conditions to
|
||||
* phase (voidage) rates at reservoir conditions.
|
||||
*
|
||||
* This uses the average hydrocarbon pressure to define fluid
|
||||
* properties. The facility is intended to support Reservoir Voidage
|
||||
* rates only ('RESV').
|
||||
*/
|
||||
|
||||
namespace Opm {
|
||||
namespace RateConverter {
|
||||
/**
|
||||
* Convenience tools for implementing the rate conversion
|
||||
* facility.
|
||||
*/
|
||||
namespace Details {
|
||||
namespace Select {
|
||||
template <class RegionID, bool>
|
||||
struct RegionIDParameter
|
||||
{
|
||||
using type =
|
||||
typename std::remove_reference<RegionID>::type &;
|
||||
};
|
||||
|
||||
template <class RegionID>
|
||||
struct RegionIDParameter<RegionID, true>
|
||||
{
|
||||
using type = RegionID;
|
||||
};
|
||||
} // Select
|
||||
|
||||
/**
|
||||
* \brief Computes the temperature, pressure, and counter increment.
|
||||
*
|
||||
* In a parallel run only cells owned contribute to the cell average.
|
||||
* \tparam is_parallel Whether this is a parallel run.
|
||||
*/
|
||||
template<bool is_parallel>
|
||||
struct AverageIncrementCalculator
|
||||
{
|
||||
/**
|
||||
* \brief Computes the temperature, pressure, and counter increment.
|
||||
* \param pressure The pressure.
|
||||
* \param temperature The temperature.
|
||||
* \param rs The rs.
|
||||
* \param rv The rv.
|
||||
* \param cell The current cell index.
|
||||
* \param ownership A vector indicating whether a cell is owned
|
||||
* by this process (value 1), or not (value 0).
|
||||
* \param cell The cell index.
|
||||
*/
|
||||
std::tuple<double, double, double, double, int>
|
||||
operator()(const std::vector<double>& pressure,
|
||||
const std::vector<double>& temperature,
|
||||
const std::vector<double>& rs,
|
||||
const std::vector<double>& rv,
|
||||
const std::vector<double>& ownership,
|
||||
std::size_t cell){
|
||||
if ( ownership[cell] )
|
||||
{
|
||||
return std::make_tuple(pressure[cell],
|
||||
temperature[cell],
|
||||
rs[cell],
|
||||
rv[cell],
|
||||
1);
|
||||
}
|
||||
else
|
||||
{
|
||||
return std::make_tuple(0, 0, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
template<>
|
||||
struct AverageIncrementCalculator<false>
|
||||
{
|
||||
std::tuple<double, double, double, double, int>
|
||||
operator()(const std::vector<double>& pressure,
|
||||
const std::vector<double>& temperature,
|
||||
const std::vector<double>& rs,
|
||||
const std::vector<double>& rv,
|
||||
const std::vector<double>&,
|
||||
std::size_t cell){
|
||||
return std::make_tuple(pressure[cell],
|
||||
temperature[cell],
|
||||
rs[cell],
|
||||
rv[cell],
|
||||
1);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Provide mapping from Region IDs to user-specified collection
|
||||
* of per-region attributes.
|
||||
*
|
||||
* \tparam RegionId Region identifier type. Must be hashable by
|
||||
* \code std::hash<> \endcode. Typically a built-in integer
|
||||
* type--e.g., \c int.
|
||||
*
|
||||
* \tparam Attributes User-defined type that represents
|
||||
* collection of attributes that have meaning in a per-region
|
||||
* aggregate sense. Must be copy-constructible.
|
||||
*/
|
||||
template <typename RegionId, class Attributes>
|
||||
class RegionAttributes
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Expose \c RegionId as a vocabulary type for use in query
|
||||
* methods.
|
||||
*/
|
||||
using RegionID =
|
||||
typename Select::RegionIDParameter
|
||||
<RegionId, std::is_integral<RegionId>::value>::type;
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* \tparam RMap Class type that implements the RegionMapping
|
||||
* protocol. Typically an instantiation of \code
|
||||
* Opm::RegionMapping<> \endcode.
|
||||
*
|
||||
* \param[in] rmap Specific region mapping that provides
|
||||
* reverse lookup from regions to cells.
|
||||
*
|
||||
* \param[in] attr Pre-constructed initialiser for \c
|
||||
* Attributes.
|
||||
*/
|
||||
template <class RMap>
|
||||
RegionAttributes(const RMap& rmap,
|
||||
const Attributes& attr)
|
||||
{
|
||||
using VT = typename AttributeMap::value_type;
|
||||
|
||||
for (const auto& r : rmap.activeRegions()) {
|
||||
auto v = std::unique_ptr<Value>(new Value(attr));
|
||||
|
||||
const auto stat = attr_.insert(VT(r, std::move(v)));
|
||||
|
||||
if (stat.second) {
|
||||
// New value inserted.
|
||||
const auto& cells = rmap.cells(r);
|
||||
|
||||
assert (! cells.empty());
|
||||
|
||||
// Region's representative cell.
|
||||
stat.first->second->cell_ = cells[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve representative cell in region.
|
||||
*
|
||||
* \param[in] reg Specific region.
|
||||
*
|
||||
* \return Representative cell in region \p reg.
|
||||
*/
|
||||
int cell(const RegionID reg) const
|
||||
{
|
||||
return this->find(reg).cell_;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request read-only access to region's attributes.
|
||||
*
|
||||
* \param[in] reg Specific region.
|
||||
*
|
||||
* \return Read-only access to region \p reg's per-region
|
||||
* attributes.
|
||||
*/
|
||||
const Attributes& attributes(const RegionID reg) const
|
||||
{
|
||||
return this->find(reg).attr_;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request modifiable access to region's attributes.
|
||||
*
|
||||
* \param[in] reg Specific region.
|
||||
*
|
||||
* \return Read-write access to region \p reg's per-region
|
||||
* attributes.
|
||||
*/
|
||||
Attributes& attributes(const RegionID reg)
|
||||
{
|
||||
return this->find(reg).attr_;
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* Aggregate per-region attributes along with region's
|
||||
* representative cell.
|
||||
*/
|
||||
struct Value {
|
||||
Value(const Attributes& attr)
|
||||
: attr_(attr)
|
||||
, cell_(-1)
|
||||
{}
|
||||
|
||||
Attributes attr_;
|
||||
int cell_;
|
||||
};
|
||||
|
||||
using ID =
|
||||
typename std::remove_reference<RegionId>::type;
|
||||
|
||||
using AttributeMap =
|
||||
std::unordered_map<ID, std::unique_ptr<Value>>;
|
||||
|
||||
AttributeMap attr_;
|
||||
|
||||
/**
|
||||
* Read-only access to region's properties.
|
||||
*/
|
||||
const Value& find(const RegionID reg) const
|
||||
{
|
||||
const auto& i = attr_.find(reg);
|
||||
|
||||
if (i == attr_.end()) {
|
||||
throw std::invalid_argument("Unknown region ID");
|
||||
}
|
||||
|
||||
return *i->second;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read-write access to region's properties.
|
||||
*/
|
||||
Value& find(const RegionID reg)
|
||||
{
|
||||
const auto& i = attr_.find(reg);
|
||||
|
||||
if (i == attr_.end()) {
|
||||
throw std::invalid_argument("Unknown region ID");
|
||||
}
|
||||
|
||||
return *i->second;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Convenience functions for querying presence/absence of
|
||||
* active phases.
|
||||
*/
|
||||
namespace PhaseUsed {
|
||||
/**
|
||||
* Active water predicate.
|
||||
*
|
||||
* \param[in] pu Active phase object.
|
||||
*
|
||||
* \return Whether or not water is an active phase.
|
||||
*/
|
||||
inline bool
|
||||
water(const PhaseUsage& pu)
|
||||
{
|
||||
return pu.phase_used[ BlackoilPhases::Aqua ] != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Active oil predicate.
|
||||
*
|
||||
* \param[in] pu Active phase object.
|
||||
*
|
||||
* \return Whether or not oil is an active phase.
|
||||
*/
|
||||
inline bool
|
||||
oil(const PhaseUsage& pu)
|
||||
{
|
||||
return pu.phase_used[ BlackoilPhases::Liquid ] != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Active gas predicate.
|
||||
*
|
||||
* \param[in] pu Active phase object.
|
||||
*
|
||||
* \return Whether or not gas is an active phase.
|
||||
*/
|
||||
inline bool
|
||||
gas(const PhaseUsage& pu)
|
||||
{
|
||||
return pu.phase_used[ BlackoilPhases::Vapour ] != 0;
|
||||
}
|
||||
} // namespace PhaseUsed
|
||||
|
||||
/**
|
||||
* Convenience functions for querying numerical IDs
|
||||
* ("positions") of active phases.
|
||||
*/
|
||||
namespace PhasePos {
|
||||
/**
|
||||
* Numerical ID of active water phase.
|
||||
*
|
||||
* \param[in] pu Active phase object.
|
||||
*
|
||||
* \return Non-negative index/position of water if
|
||||
* active, -1 if not.
|
||||
*/
|
||||
inline int
|
||||
water(const PhaseUsage& pu)
|
||||
{
|
||||
int p = -1;
|
||||
|
||||
if (PhaseUsed::water(pu)) {
|
||||
p = pu.phase_pos[ BlackoilPhases::Aqua ];
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Numerical ID of active oil phase.
|
||||
*
|
||||
* \param[in] pu Active phase object.
|
||||
*
|
||||
* \return Non-negative index/position of oil if
|
||||
* active, -1 if not.
|
||||
*/
|
||||
inline int
|
||||
oil(const PhaseUsage& pu)
|
||||
{
|
||||
int p = -1;
|
||||
|
||||
if (PhaseUsed::oil(pu)) {
|
||||
p = pu.phase_pos[ BlackoilPhases::Liquid ];
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Numerical ID of active gas phase.
|
||||
*
|
||||
* \param[in] pu Active phase object.
|
||||
*
|
||||
* \return Non-negative index/position of gas if
|
||||
* active, -1 if not.
|
||||
*/
|
||||
inline int
|
||||
gas(const PhaseUsage& pu)
|
||||
{
|
||||
int p = -1;
|
||||
|
||||
if (PhaseUsed::gas(pu)) {
|
||||
p = pu.phase_pos[ BlackoilPhases::Vapour ];
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
} // namespace PhasePos
|
||||
} // namespace Details
|
||||
|
||||
/**
|
||||
* Convert component rates at surface conditions to phase
|
||||
* (voidage) rates at reservoir conditions.
|
||||
*
|
||||
* The conversion uses fluid properties evaluated at average
|
||||
* hydrocarbon pressure in regions or field.
|
||||
*
|
||||
* \tparam FluidSystem Fluid system class. Expected to be a BlackOilFluidSystem
|
||||
*
|
||||
* \tparam Region Type of a forward region mapping. Expected
|
||||
* to provide indexed access through \code operator[]()
|
||||
* \endcode as well as inner types \c value_type, \c
|
||||
* size_type, and \c const_iterator. Typically \code
|
||||
* std::vector<int> \endcode.
|
||||
*/
|
||||
template <class FluidSystem, class Region>
|
||||
class SurfaceToReservoirVoidage {
|
||||
public:
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* \param[in] region Forward region mapping. Often
|
||||
* corresponds to the "FIPNUM" mapping of an ECLIPSE input
|
||||
* deck.
|
||||
*/
|
||||
SurfaceToReservoirVoidage(const PhaseUsage& phaseUsage,
|
||||
const Region& region)
|
||||
: phaseUsage_(phaseUsage)
|
||||
, rmap_ (region)
|
||||
, attr_ (rmap_, Attributes())
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute average hydrocarbon pressure and maximum
|
||||
* dissolution and evaporation at average hydrocarbon
|
||||
* pressure in all regions in field.
|
||||
*
|
||||
* Fluid properties are evaluated at average hydrocarbon
|
||||
* pressure for purpose of conversion from surface rate to
|
||||
* reservoir voidage rate.
|
||||
*
|
||||
* \param[in] state Dynamic reservoir state.
|
||||
* \param[in] any The information and communication utilities
|
||||
* about/of the parallelization. in any parallel
|
||||
* it wraps a ParallelISTLInformation. Parameter
|
||||
* is optional.
|
||||
*/
|
||||
void
|
||||
defineState(const BlackoilState& state,
|
||||
const boost::any& info = boost::any())
|
||||
{
|
||||
#if HAVE_MPI
|
||||
if( info.type() == typeid(ParallelISTLInformation) )
|
||||
{
|
||||
const auto& ownership =
|
||||
boost::any_cast<const ParallelISTLInformation&>(info)
|
||||
.updateOwnerMask(state.pressure());
|
||||
calcAverages<true>(state, info, ownership);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
std::vector<double> dummyOwnership; // not actually used
|
||||
calcAverages<false>(state, info, dummyOwnership);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Region identifier.
|
||||
*
|
||||
* Integral type.
|
||||
*/
|
||||
typedef typename RegionMapping<Region>::RegionId RegionId;
|
||||
|
||||
/**
|
||||
* Compute coefficients for surface-to-reservoir voidage
|
||||
* conversion.
|
||||
*
|
||||
* \tparam Input Type representing contiguous collection
|
||||
* of component rates at surface conditions. Must support
|
||||
* direct indexing through \code operator[]()\endcode.
|
||||
*
|
||||
* \tparam Coeff Type representing contiguous collection
|
||||
* of surface-to-reservoir conversion coefficients. Must
|
||||
* support direct indexing through \code operator[]()
|
||||
* \endcode.
|
||||
*
|
||||
*
|
||||
* \param[in] r Fluid-in-place region of the well
|
||||
* \param[in] pvtRegionIdx PVT region of the well
|
||||
*
|
||||
*
|
||||
* \param[out] coeff Surface-to-reservoir conversion
|
||||
* coefficients that can be used to compute total reservoir
|
||||
* volumes from surface volumes with the formula
|
||||
* q_{rT} = \sum_p coeff[p] q_{sp}.
|
||||
* However, individual phase reservoir volumes cannot be calculated from
|
||||
* these coefficients (i.e. q_{rp} is not equal to coeff[p] q_{sp})
|
||||
* since they can depend on more than one surface volume rate when
|
||||
* we have dissolved gas or vaporized oil.
|
||||
*/
|
||||
template <class Coeff>
|
||||
void
|
||||
calcCoeff(const RegionId r, const int pvtRegionIdx, Coeff& coeff) const
|
||||
{
|
||||
const auto& pu = phaseUsage_;
|
||||
const auto& ra = attr_.attributes(r);
|
||||
const double p = ra.pressure;
|
||||
const double T = ra.temperature;
|
||||
|
||||
const int iw = Details::PhasePos::water(pu);
|
||||
const int io = Details::PhasePos::oil (pu);
|
||||
const int ig = Details::PhasePos::gas (pu);
|
||||
|
||||
std::fill(& coeff[0], & coeff[0] + phaseUsage_.num_phases, 0.0);
|
||||
|
||||
if (Details::PhaseUsed::water(pu)) {
|
||||
// q[w]_r = q[w]_s / bw
|
||||
|
||||
const double bw = FluidSystem::waterPvt().inverseFormationVolumeFactor(pvtRegionIdx, T, p);
|
||||
|
||||
coeff[iw] = 1.0 / bw;
|
||||
}
|
||||
|
||||
// Actual Rs and Rv:
|
||||
double Rs = ra.rs;
|
||||
double Rv = ra.rv;
|
||||
|
||||
// Determinant of 'R' matrix
|
||||
const double detR = 1.0 - (Rs * Rv);
|
||||
|
||||
if (Details::PhaseUsed::oil(pu)) {
|
||||
// q[o]_r = 1/(bo * (1 - rs*rv)) * (q[o]_s - rv*q[g]_s)
|
||||
|
||||
const double bo = FluidSystem::oilPvt().inverseFormationVolumeFactor(pvtRegionIdx, T, p, Rs);
|
||||
const double den = bo * detR;
|
||||
|
||||
coeff[io] += 1.0 / den;
|
||||
|
||||
if (Details::PhaseUsed::gas(pu)) {
|
||||
coeff[ig] -= ra.rv / den;
|
||||
}
|
||||
}
|
||||
|
||||
if (Details::PhaseUsed::gas(pu)) {
|
||||
// q[g]_r = 1/(bg * (1 - rs*rv)) * (q[g]_s - rs*q[o]_s)
|
||||
|
||||
const double bg = FluidSystem::gasPvt().inverseFormationVolumeFactor(pvtRegionIdx, T, p, Rv);
|
||||
const double den = bg * detR;
|
||||
|
||||
coeff[ig] += 1.0 / den;
|
||||
|
||||
if (Details::PhaseUsed::oil(pu)) {
|
||||
coeff[io] -= ra.rs / den;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Converting surface volume rates to reservoir voidage rates
|
||||
*
|
||||
* \tparam Rates Type representing contiguous collection
|
||||
* of surface-to-reservoir conversion coefficients. Must
|
||||
* support direct indexing through \code operator[]()
|
||||
* \endcode.
|
||||
*
|
||||
*
|
||||
* \param[in] r Fluid-in-place region of the well
|
||||
* \param[in] pvtRegionIdx PVT region of the well
|
||||
* \param[in] surface_rates surface voluem rates for
|
||||
* all active phases
|
||||
*
|
||||
* \param[out] voidage_rates reservoir volume rates for
|
||||
* all active phases
|
||||
*/
|
||||
template <class Rates >
|
||||
void
|
||||
calcReservoirVoidageRates(const RegionId r, const int pvtRegionIdx, const Rates& surface_rates,
|
||||
Rates& voidage_rates) const
|
||||
{
|
||||
assert(voidage_rates.size() == surface_rates.size());
|
||||
|
||||
std::fill(voidage_rates.begin(), voidage_rates.end(), 0.0);
|
||||
|
||||
const auto& pu = phaseUsage_;
|
||||
const auto& ra = attr_.attributes(r);
|
||||
const double p = ra.pressure;
|
||||
const double T = ra.temperature;
|
||||
|
||||
const int iw = Details::PhasePos::water(pu);
|
||||
const int io = Details::PhasePos::oil (pu);
|
||||
const int ig = Details::PhasePos::gas (pu);
|
||||
|
||||
if (Details::PhaseUsed::water(pu)) {
|
||||
// q[w]_r = q[w]_s / bw
|
||||
|
||||
const double bw = FluidSystem::waterPvt().inverseFormationVolumeFactor(pvtRegionIdx, T, p);
|
||||
|
||||
voidage_rates[iw] = surface_rates[iw] / bw;
|
||||
}
|
||||
|
||||
// Use average Rs and Rv:
|
||||
auto a = ra.rs;
|
||||
auto b = a;
|
||||
if (io >= 0 && ig >= 0) {
|
||||
b = surface_rates[ig]/(surface_rates[io]+1.0e-15);
|
||||
}
|
||||
|
||||
double Rs = std::min(a, b);
|
||||
|
||||
a = ra.rv;
|
||||
b = a;
|
||||
if (io >= 0 && ig >= 0) {
|
||||
b = surface_rates[io]/(surface_rates[ig]+1.0e-15);
|
||||
}
|
||||
|
||||
double Rv = std::min(a, b);
|
||||
|
||||
// Determinant of 'R' matrix
|
||||
const double detR = 1.0 - (Rs * Rv);
|
||||
|
||||
if (Details::PhaseUsed::oil(pu)) {
|
||||
// q[o]_r = 1/(bo * (1 - rs*rv)) * (q[o]_s - rv*q[g]_s)
|
||||
|
||||
const double bo = FluidSystem::oilPvt().inverseFormationVolumeFactor(pvtRegionIdx, T, p, Rs);
|
||||
const double den = bo * detR;
|
||||
|
||||
voidage_rates[io] = surface_rates[io];
|
||||
|
||||
if (Details::PhaseUsed::gas(pu)) {
|
||||
voidage_rates[io] -= Rv * surface_rates[ig];
|
||||
}
|
||||
|
||||
voidage_rates[io] /= den;
|
||||
}
|
||||
|
||||
if (Details::PhaseUsed::gas(pu)) {
|
||||
// q[g]_r = 1/(bg * (1 - rs*rv)) * (q[g]_s - rs*q[o]_s)
|
||||
|
||||
const double bg = FluidSystem::gasPvt().inverseFormationVolumeFactor(pvtRegionIdx, T, p, Rv);
|
||||
const double den = bg * detR;
|
||||
|
||||
voidage_rates[ig] = surface_rates[ig];
|
||||
|
||||
if (Details::PhaseUsed::oil(pu)) {
|
||||
voidage_rates[ig] -= Rs * surface_rates[io];
|
||||
}
|
||||
|
||||
voidage_rates[ig] /= den;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Compute coefficients for surface-to-reservoir voidage
|
||||
* conversion for solvent.
|
||||
*
|
||||
*
|
||||
* \param[in] r Fluid-in-place region of the well
|
||||
* \param[in] pvtRegionIdx PVT region of the well
|
||||
*
|
||||
*
|
||||
* \param[out] double Surface-to-reservoir conversion
|
||||
* coefficients for solvent.
|
||||
*/
|
||||
template <class SolventModule>
|
||||
void
|
||||
calcCoeffSolvent(const RegionId r, const int pvtRegionIdx, double& coeff) const
|
||||
{
|
||||
const auto& ra = attr_.attributes(r);
|
||||
const double p = ra.pressure;
|
||||
const double T = ra.temperature;
|
||||
const auto& solventPvt = SolventModule::solventPvt();
|
||||
const double bs = solventPvt.inverseFormationVolumeFactor(pvtRegionIdx, T, p);
|
||||
coeff = 1.0 / bs;
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* Fluid property object.
|
||||
*/
|
||||
const PhaseUsage phaseUsage_;
|
||||
|
||||
/**
|
||||
* "Fluid-in-place" region mapping (forward and reverse).
|
||||
*/
|
||||
const RegionMapping<Region> rmap_;
|
||||
|
||||
/**
|
||||
* Derived property attributes for each active region.
|
||||
*/
|
||||
struct Attributes {
|
||||
Attributes()
|
||||
: pressure (0.0)
|
||||
, temperature(0.0)
|
||||
, rs(0.0)
|
||||
, rv(0.0)
|
||||
, pv(0.0)
|
||||
{}
|
||||
|
||||
double pressure;
|
||||
double temperature;
|
||||
double rs;
|
||||
double rv;
|
||||
double pv;
|
||||
};
|
||||
|
||||
Details::RegionAttributes<RegionId, Attributes> attr_;
|
||||
|
||||
|
||||
/**
|
||||
* Compute average hydrocarbon pressure and temperatures in all
|
||||
* regions.
|
||||
*
|
||||
* \param[in] state Dynamic reservoir state.
|
||||
* \param[in] info The information and communication utilities
|
||||
* about/of the parallelization.
|
||||
* \param[in] ownership In a parallel run this is vector containing
|
||||
* 1 for every owned unknown, zero otherwise.
|
||||
* Not used in a sequential run.
|
||||
* \tparam is_parallel True if the run is parallel. In this case
|
||||
* info has to contain a ParallelISTLInformation
|
||||
* object.
|
||||
*/
|
||||
template<bool is_parallel>
|
||||
void
|
||||
calcAverages(const BlackoilState& state, const boost::any& info,
|
||||
const std::vector<double>& ownerShip)
|
||||
{
|
||||
const auto& press = state.pressure();
|
||||
const auto& temp = state.temperature();
|
||||
const auto& Rv = state.rv();
|
||||
const auto& Rs = state.gasoilratio();
|
||||
|
||||
for (const auto& reg : rmap_.activeRegions()) {
|
||||
auto& ra = attr_.attributes(reg);
|
||||
auto& p = ra.pressure;
|
||||
auto& T = ra.temperature;
|
||||
auto& rs = ra.rs;
|
||||
auto& rv = ra.rv;
|
||||
|
||||
std::size_t n = 0;
|
||||
p = T = 0.0;
|
||||
for (const auto& cell : rmap_.cells(reg)) {
|
||||
auto increment = Details::
|
||||
AverageIncrementCalculator<is_parallel>()(press, temp, Rs, Rv,
|
||||
ownerShip,
|
||||
cell);
|
||||
p += std::get<0>(increment);
|
||||
T += std::get<1>(increment);
|
||||
rs += std::get<2>(increment);
|
||||
rv += std::get<3>(increment);
|
||||
n += std::get<4>(increment);
|
||||
}
|
||||
std::size_t global_n = n;
|
||||
double global_p = p;
|
||||
double global_T = T;
|
||||
double global_rs = rs;
|
||||
double global_rv = rv;
|
||||
#if HAVE_MPI
|
||||
if ( is_parallel )
|
||||
{
|
||||
const auto& real_info = boost::any_cast<const ParallelISTLInformation&>(info);
|
||||
global_n = real_info.communicator().sum(n);
|
||||
global_p = real_info.communicator().sum(p);
|
||||
global_rs = real_info.communicator().sum(rs);
|
||||
global_rv = real_info.communicator().sum(rv);
|
||||
global_T = real_info.communicator().sum(T);
|
||||
}
|
||||
#endif
|
||||
p = global_p / global_n;
|
||||
rs = global_rs / global_n;
|
||||
rv = global_rv / global_n;
|
||||
T = global_T / global_n;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
};
|
||||
} // namespace RateConverter
|
||||
} // namespace Opm
|
||||
|
||||
#endif /* OPM_RATECONVERTER_HPP_HEADER_INCLUDED */
|
||||
@ -1,184 +0,0 @@
|
||||
/*
|
||||
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_BLACKOILPROPERTIESINTERFACE_HEADER_INCLUDED
|
||||
#define OPM_BLACKOILPROPERTIESINTERFACE_HEADER_INCLUDED
|
||||
|
||||
namespace Opm
|
||||
{
|
||||
|
||||
struct PhaseUsage;
|
||||
|
||||
/// Abstract base class for blackoil fluid and reservoir properties.
|
||||
/// Supports variable number of spatial dimensions, called D.
|
||||
/// Supports variable number of phases, but assumes that
|
||||
/// the number of components is equal to the number of phases, called P.
|
||||
/// In general, when arguments call for n values of some vector or
|
||||
/// matrix property, such as saturation, they shall always be
|
||||
/// ordered cellwise:
|
||||
/// [s^1_0 s^2_0 s^3_0 s^1_1 s^2_2 ... ]
|
||||
/// in which s^i_j denotes saturation of phase i in cell j.
|
||||
class BlackoilPropertiesInterface
|
||||
{
|
||||
public:
|
||||
virtual ~BlackoilPropertiesInterface() {}
|
||||
|
||||
// ---- Rock interface ----
|
||||
|
||||
/// \return D, the number of spatial dimensions.
|
||||
virtual int numDimensions() const = 0;
|
||||
|
||||
/// \return N, the number of cells.
|
||||
virtual int numCells() const = 0;
|
||||
|
||||
/// Return an array containing the PVT table index for each
|
||||
/// grid cell
|
||||
virtual const int* cellPvtRegionIndex() const = 0;
|
||||
|
||||
/// \return Array of N porosity values.
|
||||
virtual const double* porosity() const = 0;
|
||||
|
||||
/// \return Array of ND^2 permeability values.
|
||||
/// The D^2 permeability values for a cell are organized as a matrix,
|
||||
/// which is symmetric (so ordering does not matter).
|
||||
virtual const double* permeability() const = 0;
|
||||
|
||||
|
||||
// ---- Fluid interface ----
|
||||
|
||||
/// \return P, the number of phases (also the number of components).
|
||||
virtual int numPhases() const = 0;
|
||||
|
||||
/// \return Object describing the active phases.
|
||||
virtual PhaseUsage phaseUsage() const = 0;
|
||||
|
||||
/// \param[in] n Number of data points.
|
||||
/// \param[in] p Array of n pressure values.
|
||||
/// \param[in] T Array of n temperature values.
|
||||
/// \param[in] z Array of nP surface volume values.
|
||||
/// \param[in] cells Array of n cell indices to be associated with the p and z values.
|
||||
/// \param[out] mu Array of nP viscosity values, array must be valid before calling.
|
||||
/// \param[out] dmudp If non-null: array of nP viscosity derivative values,
|
||||
/// array must be valid before calling.
|
||||
virtual void viscosity(const int n,
|
||||
const double* p,
|
||||
const double* T,
|
||||
const double* z,
|
||||
const int* cells,
|
||||
double* mu,
|
||||
double* dmudp) const = 0;
|
||||
|
||||
/// \param[in] n Number of data points.
|
||||
/// \param[in] p Array of n pressure values.
|
||||
/// \param[in] T Array of n temperature values.
|
||||
/// \param[in] z Array of nP surface volume values.
|
||||
/// \param[in] cells Array of n cell indices to be associated with the p and z values.
|
||||
/// \param[out] A Array of nP^2 values, array must be valid before calling.
|
||||
/// The P^2 values for a cell give the matrix A = RB^{-1} which
|
||||
/// relates z to u by z = Au. The matrices are output in Fortran order.
|
||||
/// \param[out] dAdp If non-null: array of nP^2 matrix derivative values,
|
||||
/// array must be valid before calling. The matrices are output
|
||||
/// in Fortran order.
|
||||
virtual void matrix(const int n,
|
||||
const double* p,
|
||||
const double* T,
|
||||
const double* z,
|
||||
const int* cells,
|
||||
double* A,
|
||||
double* dAdp) const = 0;
|
||||
|
||||
|
||||
/// Densities of stock components at reservoir conditions.
|
||||
/// \param[in] n Number of data points.
|
||||
/// \param[in] A Array of nP^2 values, where the P^2 values for a cell give the
|
||||
/// matrix A = RB^{-1} which relates z to u by z = Au. The matrices
|
||||
/// are assumed to be in Fortran order, and are typically the result
|
||||
/// of a call to the method matrix().
|
||||
/// \param[in] cells The index of the grid cell of each data point.
|
||||
/// \param[out] rho Array of nP density values, array must be valid before calling.
|
||||
virtual void density(const int n,
|
||||
const double* A,
|
||||
const int* cells,
|
||||
double* rho) const = 0;
|
||||
|
||||
/// Densities of stock components at surface conditions.
|
||||
/// \return Array of P density values.
|
||||
virtual const double* surfaceDensity(int regionIdx = 0) const = 0;
|
||||
|
||||
/// \param[in] n Number of data points.
|
||||
/// \param[in] s Array of nP saturation values.
|
||||
/// \param[in] cells Array of n cell indices to be associated with the s values.
|
||||
/// \param[out] kr Array of nP relperm values, array must be valid before calling.
|
||||
/// \param[out] dkrds If non-null: array of nP^2 relperm derivative values,
|
||||
/// array must be valid before calling.
|
||||
/// The P^2 derivative matrix is
|
||||
/// m_{ij} = \frac{dkr_i}{ds^j},
|
||||
/// and is output in Fortran order (m_00 m_10 m_20 m_01 ...)
|
||||
virtual void relperm(const int n,
|
||||
const double* s,
|
||||
const int* cells,
|
||||
double* kr,
|
||||
double* dkrds) const = 0;
|
||||
|
||||
|
||||
/// \param[in] n Number of data points.
|
||||
/// \param[in] s Array of nP saturation values.
|
||||
/// \param[in] cells Array of n cell indices to be associated with the s values.
|
||||
/// \param[out] pc Array of nP capillary pressure values, array must be valid before calling.
|
||||
/// \param[out] dpcds If non-null: array of nP^2 derivative values,
|
||||
/// array must be valid before calling.
|
||||
/// The P^2 derivative matrix is
|
||||
/// m_{ij} = \frac{dpc_i}{ds^j},
|
||||
/// and is output in Fortran order (m_00 m_10 m_20 m_01 ...)
|
||||
virtual void capPress(const int n,
|
||||
const double* s,
|
||||
const int* cells,
|
||||
double* pc,
|
||||
double* dpcds) const = 0;
|
||||
|
||||
|
||||
/// Obtain the range of allowable saturation values.
|
||||
/// In cell cells[i], saturation of phase p is allowed to be
|
||||
/// in the interval [smin[i*P + p], smax[i*P + p]].
|
||||
/// \param[in] n Number of data points.
|
||||
/// \param[in] cells Array of n cell indices.
|
||||
/// \param[out] smin Array of nP minimum s values, array must be valid before calling.
|
||||
/// \param[out] smax Array of nP maximum s values, array must be valid before calling.
|
||||
virtual void satRange(const int n,
|
||||
const int* cells,
|
||||
double* smin,
|
||||
double* smax) const = 0;
|
||||
|
||||
|
||||
/// Update capillary pressure scaling according to pressure diff. and initial water saturation.
|
||||
/// \param[in] cell Cell index.
|
||||
/// \param[in] pcow P_oil - P_water.
|
||||
/// \param[in/out] swat Water saturation. / Possibly modified Water saturation.
|
||||
virtual void swatInitScaling(const int cell,
|
||||
const double pcow,
|
||||
double & swat) = 0;
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // namespace Opm
|
||||
|
||||
|
||||
#endif // OPM_BLACKOILPROPERTIESINTERFACE_HEADER_INCLUDED
|
||||
@ -1,52 +0,0 @@
|
||||
#include "BlackoilState.hpp"
|
||||
#include <opm/common/utility/numeric/cmp.hpp>
|
||||
#include <opm/core/props/BlackoilPropertiesInterface.hpp>
|
||||
#include <opm/core/simulator/WellState.hpp>
|
||||
#include <opm/output/data/Wells.hpp>
|
||||
|
||||
|
||||
using namespace Opm;
|
||||
|
||||
|
||||
const std::string BlackoilState::GASOILRATIO = "GASOILRATIO";
|
||||
const std::string BlackoilState::RV = "RV";
|
||||
const std::string BlackoilState::SURFACEVOL = "SURFACEVOL";
|
||||
const std::string BlackoilState::SSOL = "SSOL";
|
||||
const std::string BlackoilState::POLYMER = "POLYMER";
|
||||
|
||||
|
||||
BlackoilState::BlackoilState( size_t num_cells , size_t num_faces , size_t num_phases)
|
||||
: SimulationDataContainer( num_cells , num_faces , num_phases)
|
||||
{
|
||||
registerCellData( GASOILRATIO , 1 );
|
||||
registerCellData( RV, 1 );
|
||||
registerCellData( SURFACEVOL, num_phases );
|
||||
registerCellData( SSOL , 1 );
|
||||
registerCellData( POLYMER , 1 );
|
||||
setBlackoilStateReferencePointers();
|
||||
}
|
||||
|
||||
BlackoilState::BlackoilState( const BlackoilState& other )
|
||||
: SimulationDataContainer(other),
|
||||
hydrocarbonstate_(other.hydroCarbonState())
|
||||
{
|
||||
setBlackoilStateReferencePointers();
|
||||
|
||||
}
|
||||
|
||||
BlackoilState& BlackoilState::operator=( const BlackoilState& other )
|
||||
{
|
||||
SimulationDataContainer::operator=(other);
|
||||
setBlackoilStateReferencePointers();
|
||||
hydrocarbonstate_ = other.hydroCarbonState();
|
||||
return *this;
|
||||
}
|
||||
|
||||
void BlackoilState::setBlackoilStateReferencePointers()
|
||||
{
|
||||
// This sets the reference pointers for the fast
|
||||
// accessors, the fields must have been created first.
|
||||
gasoilratio_ref_ = &getCellData(GASOILRATIO);
|
||||
rv_ref_ = &getCellData(RV);
|
||||
surfacevol_ref_ = &getCellData(SURFACEVOL);
|
||||
}
|
||||
@ -1,94 +0,0 @@
|
||||
/*
|
||||
Copyright 2012 SINTEF ICT, Applied Mathematics.
|
||||
Copyright 2015 IRIS AS
|
||||
|
||||
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_BLACKOILSTATE_HEADER_INCLUDED
|
||||
#define OPM_BLACKOILSTATE_HEADER_INCLUDED
|
||||
|
||||
#include <opm/common/data/SimulationDataContainer.hpp>
|
||||
|
||||
#include <opm/grid/UnstructuredGrid.h>
|
||||
#include <opm/core/props/BlackoilPropertiesInterface.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace Opm
|
||||
{
|
||||
|
||||
enum HydroCarbonState {
|
||||
GasOnly = 0,
|
||||
GasAndOil = 1,
|
||||
OilOnly = 2
|
||||
};
|
||||
|
||||
/// Simulator state for a blackoil simulator.
|
||||
class BlackoilState : public SimulationDataContainer
|
||||
{
|
||||
public:
|
||||
static const std::string GASOILRATIO;
|
||||
static const std::string RV;
|
||||
static const std::string SURFACEVOL;
|
||||
static const std::string SSOL;
|
||||
static const std::string POLYMER;
|
||||
|
||||
/// Main constructor setting the sizes for the contained data
|
||||
/// types.
|
||||
/// \param num_cells number of elements in cell data vectors
|
||||
/// \param num_faces number of elements in face data vectors
|
||||
/// \param num_phases number of phases, the number of components
|
||||
/// in any data vector must equal 1 or this
|
||||
/// number (this behaviour and argument is deprecated).
|
||||
BlackoilState(size_t num_cells, size_t num_faces, size_t num_phases);
|
||||
|
||||
/// Copy constructor.
|
||||
/// Must be defined explicitly because class contains non-value objects
|
||||
/// (the reference pointers rv_ref_ etc.) that should not simply
|
||||
/// be copied.
|
||||
BlackoilState(const BlackoilState& other);
|
||||
|
||||
/// Copy assignment operator.
|
||||
/// Must be defined explicitly because class contains non-value objects
|
||||
/// (the reference pointers rv_ref_ etc.) that should not simply
|
||||
/// be copied.
|
||||
BlackoilState& operator=(const BlackoilState& other);
|
||||
|
||||
std::vector<double>& surfacevol () { return *surfacevol_ref_; }
|
||||
std::vector<double>& gasoilratio () { return *gasoilratio_ref_; }
|
||||
std::vector<double>& rv () { return *rv_ref_; }
|
||||
std::vector<HydroCarbonState>& hydroCarbonState() { return hydrocarbonstate_; }
|
||||
|
||||
const std::vector<double>& surfacevol () const { return *surfacevol_ref_; }
|
||||
const std::vector<double>& gasoilratio () const { return *gasoilratio_ref_; }
|
||||
const std::vector<double>& rv () const { return *rv_ref_; }
|
||||
const std::vector<HydroCarbonState>& hydroCarbonState() const { return hydrocarbonstate_; }
|
||||
|
||||
private:
|
||||
void setBlackoilStateReferencePointers();
|
||||
std::vector<double>* surfacevol_ref_;
|
||||
std::vector<double>* gasoilratio_ref_;
|
||||
std::vector<double>* rv_ref_;
|
||||
|
||||
// A vector storing the hydro carbon state.
|
||||
std::vector<HydroCarbonState> hydrocarbonstate_;
|
||||
|
||||
|
||||
};
|
||||
} // namespace Opm
|
||||
|
||||
|
||||
#endif // OPM_BLACKOILSTATE_HEADER_INCLUDED
|
||||
@ -1,94 +0,0 @@
|
||||
/*
|
||||
Copyright 2015 Andreas Lauser
|
||||
|
||||
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_BLACKOIL_STATE_TO_FLUID_STATE_HEADER_INCLUDED
|
||||
#define OPM_BLACKOIL_STATE_TO_FLUID_STATE_HEADER_INCLUDED
|
||||
|
||||
#include <opm/core/simulator/BlackoilState.hpp>
|
||||
|
||||
namespace Opm
|
||||
{
|
||||
|
||||
/*!
|
||||
* \brief This is an light weight "impedance adaption" class with a well defined API for
|
||||
* saturation and PVT functions.
|
||||
*
|
||||
* It uses a stripped down version of opm-material's FluidState API and takes an
|
||||
* Opm::BlackoilState plus a cell index.
|
||||
*
|
||||
* Note that this class requires that is underlying BlackoilState must valid for at least
|
||||
* as long as an object of BlackoilStateToFluidState is used.
|
||||
*/
|
||||
class BlackoilStateToFluidState
|
||||
{
|
||||
public:
|
||||
typedef double Scalar;
|
||||
|
||||
enum { numPhases = 3 };
|
||||
enum { numComponents = 3 };
|
||||
|
||||
/*!
|
||||
* \brief Create a BlackoilState to Fluid state wrapper object.
|
||||
*
|
||||
* Note that this class requires that is underlying BlackoilState must valid for at least
|
||||
* as long as an object of BlackoilStateToFluidState is used.
|
||||
*/
|
||||
BlackoilStateToFluidState(const BlackoilState& blackoilState)
|
||||
: blackoilState_(blackoilState)
|
||||
{
|
||||
if (blackoilState_.numPhases() != numPhases) {
|
||||
OPM_THROW(std::runtime_error,
|
||||
"Only " << numPhases << " are supported, but the deck specifies " << blackoilState_.numPhases());
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Sets the index of the currently used cell.
|
||||
*
|
||||
* After calling this, the values returned by the other methods are specific for this
|
||||
* cell.
|
||||
*/
|
||||
void setCurrentCellIndex(unsigned cellIdx)
|
||||
{ cellIdx_ = cellIdx; }
|
||||
|
||||
/*!
|
||||
* \brief Returns the saturation of a phase for the current cell index.
|
||||
*/
|
||||
Scalar saturation(int phaseIdx) const
|
||||
{ return blackoilState_.saturation()[numPhases*cellIdx_ + phaseIdx]; }
|
||||
|
||||
/*!
|
||||
* \brief Returns the temperature [K] of a phase for the current cell index.
|
||||
*/
|
||||
Scalar temperature(int phaseIdx) const
|
||||
{ return blackoilState_.temperature()[cellIdx_]; }
|
||||
|
||||
// TODO (?) pressure, composition, etc
|
||||
|
||||
private:
|
||||
size_t numCells() const
|
||||
{ return blackoilState_.pressure().size(); }
|
||||
|
||||
const BlackoilState& blackoilState_;
|
||||
unsigned cellIdx_;
|
||||
}
|
||||
|
||||
} // namespace Opm
|
||||
|
||||
#endif // OPM_SIMULATORTIMER_HEADER_INCLUDED
|
||||
@ -1,44 +0,0 @@
|
||||
#ifndef INITHYDROCARBONSTATE_HPP
|
||||
#define INITHYDROCARBONSTATE_HPP
|
||||
|
||||
#include "opm/core/simulator/BlackoilState.hpp"
|
||||
|
||||
namespace Opm
|
||||
{
|
||||
|
||||
inline void initHydroCarbonState(BlackoilState& state, const PhaseUsage& pu, const int num_cells, const bool has_disgas, const bool has_vapoil) {
|
||||
enum { Oil = BlackoilPhases::Liquid, Gas = BlackoilPhases::Vapour, Water = BlackoilPhases::Aqua };
|
||||
// hydrocarbonstate is only used when gas and oil is present
|
||||
assert(pu.phase_used[Oil]);
|
||||
std::vector<HydroCarbonState>& hydroCarbonState = state.hydroCarbonState();
|
||||
hydroCarbonState.resize(num_cells);
|
||||
if (!pu.phase_used[Gas]) {
|
||||
// hydroCarbonState should only be used when oil and gas is present. Return OilOnly to avoid potential trouble.
|
||||
std::fill(hydroCarbonState.begin(), hydroCarbonState.end(), HydroCarbonState::OilOnly);
|
||||
return;
|
||||
}
|
||||
const int np = pu.num_phases;
|
||||
std::fill(hydroCarbonState.begin(), hydroCarbonState.end(), HydroCarbonState::GasAndOil);
|
||||
|
||||
// set hydrocarbon state
|
||||
const double epsilon = std::sqrt(std::numeric_limits<double>::epsilon());
|
||||
const std::vector<double>& saturation = state.saturation();
|
||||
for (int c = 0; c < num_cells; ++c) {
|
||||
if (pu.phase_used[Water]) {
|
||||
if ( saturation[c*np + pu.phase_pos[ Water ]] > (1.0 - epsilon)) {
|
||||
continue; // cases (almost) filled with water is treated as GasAndOil case;
|
||||
}
|
||||
}
|
||||
if ( saturation[c*np + pu.phase_pos[ Gas ]] == 0.0 && has_disgas) {
|
||||
hydroCarbonState[c] = HydroCarbonState::OilOnly;
|
||||
continue;
|
||||
}
|
||||
if ( saturation[c*np + pu.phase_pos[ Oil ]] == 0.0 && has_vapoil) {
|
||||
hydroCarbonState[c] = HydroCarbonState::GasOnly;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
} // namespace Opm
|
||||
#endif // INITHYDROCARBONSTATE_HPP
|
||||
@ -1,42 +0,0 @@
|
||||
/*
|
||||
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/>.
|
||||
*/
|
||||
|
||||
|
||||
#include <opm/common/data/SimulationDataContainer.hpp>
|
||||
|
||||
#include <opm/polymer/PolymerBlackoilState.hpp>
|
||||
|
||||
namespace Opm
|
||||
{
|
||||
const std::string PolymerBlackoilState::CONCENTRATION = "CONCENTRATION";
|
||||
const std::string PolymerBlackoilState::CMAX = "CMAX";
|
||||
|
||||
PolymerBlackoilState::PolymerBlackoilState(int number_of_cells, int number_of_faces, int num_phases) :
|
||||
BlackoilState( number_of_cells , number_of_faces, num_phases)
|
||||
{
|
||||
registerCellData(CONCENTRATION , 1 , 0 );
|
||||
registerCellData(CMAX , 1 , 0 );
|
||||
}
|
||||
|
||||
|
||||
} // namespace Opm
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,47 +0,0 @@
|
||||
/*
|
||||
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_POLYMERBLACKOILSTATE_HEADER_INCLUDED
|
||||
#define OPM_POLYMERBLACKOILSTATE_HEADER_INCLUDED
|
||||
|
||||
|
||||
#include <opm/core/simulator/BlackoilState.hpp>
|
||||
#include <opm/grid/UnstructuredGrid.h>
|
||||
#include <vector>
|
||||
|
||||
namespace Opm
|
||||
{
|
||||
|
||||
/// Simulator state for a compressible two-phase simulator with polymer.
|
||||
/// We use the Blackoil state parameters.
|
||||
class PolymerBlackoilState : public BlackoilState
|
||||
{
|
||||
public:
|
||||
static const std::string CONCENTRATION;
|
||||
static const std::string CMAX;
|
||||
|
||||
PolymerBlackoilState(int number_of_cells, int number_of_faces, int num_phases);
|
||||
};
|
||||
|
||||
} // namespace Opm
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // OPM_POLYMERBLACKOILSTATE_HEADER_INCLUDED
|
||||
@ -1,18 +0,0 @@
|
||||
DIMENS
|
||||
10 10 10 /
|
||||
|
||||
DXV
|
||||
10*10 /
|
||||
|
||||
DYV
|
||||
10*10 /
|
||||
|
||||
DZV
|
||||
10*10 /
|
||||
|
||||
ACTNUM
|
||||
1 998*2 3 /
|
||||
|
||||
|
||||
DEPTHZ
|
||||
121*2000 /
|
||||
@ -1,14 +0,0 @@
|
||||
DIMENS
|
||||
9 10 10 /
|
||||
|
||||
DXV
|
||||
9*10 /
|
||||
|
||||
DYV
|
||||
10*10 /
|
||||
|
||||
DZV
|
||||
10*10 /
|
||||
|
||||
DEPTHZ
|
||||
110*2000 /
|
||||
@ -1,140 +0,0 @@
|
||||
#include <config.h>
|
||||
|
||||
#include <opm/grid/GridManager.hpp>
|
||||
#include <opm/grid/GridHelpers.hpp>
|
||||
#include <opm/core/props/BlackoilPhases.hpp>
|
||||
|
||||
#include <opm/parser/eclipse/Parser/Parser.hpp>
|
||||
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
|
||||
#include <opm/parser/eclipse/Deck/Deck.hpp>
|
||||
|
||||
#define NVERBOSE // to suppress our messages when throwing
|
||||
#define BOOST_TEST_MODULE BlackoilStateTest
|
||||
#define BOOST_TEST_MAIN
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <memory>
|
||||
#include <iostream>
|
||||
#include <iterator>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#include "opm/grid/GridManager.hpp"
|
||||
#include "opm/core/simulator/BlackoilState.hpp"
|
||||
|
||||
using namespace Opm;
|
||||
using namespace std;
|
||||
|
||||
|
||||
// ACTNUM 1 998*2 3
|
||||
std::vector<int> get_testBlackoilStateActnum() {
|
||||
std::vector<int> actnum(10 * 10 * 10, 2);
|
||||
actnum.front() = 1;
|
||||
actnum.back() = 3;
|
||||
return actnum;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(EqualsDifferentDeckReturnFalse) {
|
||||
const string filename1 = "testBlackoilState1.DATA";
|
||||
const string filename2 = "testBlackoilState2.DATA";
|
||||
|
||||
const auto es1 = Opm::Parser::parse(filename1);
|
||||
auto eg1 = es1.getInputGrid();
|
||||
std::vector<int> actnum = get_testBlackoilStateActnum();
|
||||
eg1.resetACTNUM(actnum.data());
|
||||
|
||||
const auto es2 = Opm::Parser::parse(filename2);
|
||||
const auto& eg2 = es2.getInputGrid();
|
||||
|
||||
GridManager vanguard1(eg1);
|
||||
const UnstructuredGrid& grid1 = *vanguard1.c_grid();
|
||||
|
||||
GridManager vanguard2(eg2);
|
||||
const UnstructuredGrid& grid2 = *vanguard2.c_grid();
|
||||
|
||||
BlackoilState state1( UgGridHelpers::numCells( grid1 ) , UgGridHelpers::numFaces( grid1 ) , 3);
|
||||
BlackoilState state2( UgGridHelpers::numCells( grid2 ) , UgGridHelpers::numFaces( grid2 ) , 3);
|
||||
|
||||
BOOST_CHECK( ! state1.equal(state2) );
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(EqualsNumericalDifferenceReturnFalse) {
|
||||
|
||||
const string filename = "testBlackoilState1.DATA";
|
||||
|
||||
const auto es = Opm::Parser::parse(filename);
|
||||
auto eg = es.getInputGrid();
|
||||
|
||||
std::vector<int> actnum = get_testBlackoilStateActnum();
|
||||
eg.resetACTNUM(actnum.data());
|
||||
|
||||
GridManager vanguard(eg);
|
||||
const UnstructuredGrid& grid = *vanguard.c_grid();
|
||||
|
||||
BlackoilState state1( UgGridHelpers::numCells( grid ) , UgGridHelpers::numFaces( grid ) , 3);
|
||||
BlackoilState state2( UgGridHelpers::numCells( grid ) , UgGridHelpers::numFaces( grid ) , 3);
|
||||
|
||||
|
||||
BOOST_CHECK( state1.equal(state2) );
|
||||
{
|
||||
std::vector<double>& p1 = state1.pressure();
|
||||
std::vector<double>& p2 = state2.pressure();
|
||||
p1[0] = p1[0] * 2 + 1;
|
||||
|
||||
BOOST_CHECK( ! state1.equal(state2) );
|
||||
p1[0] = p2[0];
|
||||
BOOST_CHECK( state1.equal(state2) );
|
||||
}
|
||||
{
|
||||
std::vector<double>& gor1 = state1.gasoilratio();
|
||||
std::vector<double>& gor2 = state2.gasoilratio();
|
||||
gor1[0] = gor1[0] * 2 + 1;
|
||||
|
||||
BOOST_CHECK( ! state1.equal(state2) );
|
||||
gor1[0] = gor2[0];
|
||||
BOOST_CHECK( state1.equal(state2) );
|
||||
}
|
||||
{
|
||||
std::vector<double>& p1 = state1.facepressure();
|
||||
std::vector<double>& p2 = state2.facepressure();
|
||||
p1[0] = p1[0] * 2 + 1;
|
||||
|
||||
BOOST_CHECK( ! state1.equal(state2) );
|
||||
p1[0] = p2[0];
|
||||
BOOST_CHECK( state1.equal(state2) );
|
||||
}
|
||||
|
||||
{
|
||||
std::vector<double>& f1 = state1.faceflux();
|
||||
std::vector<double>& f2 = state2.faceflux();
|
||||
if (f1.size() > 0 ) {
|
||||
f1[0] = f1[0] * 2 + 1;
|
||||
|
||||
BOOST_CHECK( ! state1.equal(state2) );
|
||||
f1[0] = f2[0];
|
||||
BOOST_CHECK( state1.equal(state2) );
|
||||
}
|
||||
}
|
||||
{
|
||||
std::vector<double>& sv1 = state1.surfacevol();
|
||||
std::vector<double>& sv2 = state2.surfacevol();
|
||||
if (sv1.size() > 0) {
|
||||
sv1[0] = sv1[0] * 2 + 1;
|
||||
|
||||
BOOST_CHECK( ! state1.equal(state2) );
|
||||
sv1[0] = sv2[0];
|
||||
BOOST_CHECK( state1.equal(state2) );
|
||||
}
|
||||
}
|
||||
{
|
||||
std::vector<double>& sat1 = state1.saturation();
|
||||
std::vector<double>& sat2 = state2.saturation();
|
||||
sat1[0] = sat1[0] * 2 + 1;
|
||||
|
||||
BOOST_CHECK( ! state1.equal(state2) );
|
||||
sat1[0] = sat2[0];
|
||||
BOOST_CHECK( state1.equal(state2) );
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user