mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
Merge pull request #1662 from akva2/remove_files
remove files moved to opm-simulators-legacy
This commit is contained in:
Atgeirr Flø Rasmussen
GitHub
commit
7b550ba06c
@ -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