OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #4691 from bska/wbp-comm-api-change

Browse Source 
Prepare for Revised Implementation of WBPn
This commit is contained in:
Bård Skaflestad 2023-06-09 15:15:32 +02:00 committed by GitHub
commit 9fde77079e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 307 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
ebos/collecttoiorank.cc
View File

@ -531,55 +531,48 @@ public:
class PackUnPackWBPData : public P2PCommunicatorType::DataHandleInterface class PackUnPackWBPData : public P2PCommunicatorType::DataHandleInterface
{ {
const std::map<std::size_t, double>& localWBPData_; const data::WellBlockAveragePressures& localWBPData_;
std::map<std::size_t, double>& globalWBPValues_; data::WellBlockAveragePressures& globalWBPValues_;
public: public:
PackUnPackWBPData(const std::map<std::size_t, double>& localWBPData, PackUnPackWBPData(const data::WellBlockAveragePressures& localWBPData,
std::map<std::size_t, double>& globalWBPValues, data::WellBlockAveragePressures& globalWBPValues,
bool isIORank) const bool isIORank)
: localWBPData_(localWBPData) : localWBPData_ (localWBPData)
, globalWBPValues_(globalWBPValues) , globalWBPValues_(globalWBPValues)
{ {
if (isIORank) { if (! isIORank) {
MessageBufferType buffer; return;
pack(0, buffer);
// pass a dummyLink to satisfy virtual class
int dummyLink = -1;
unpack(dummyLink, buffer);
} }
MessageBufferType buffer;
pack(0, buffer);
// Pass a dummy link to satisfy base class API requirement
const int dummyLink = -1;
unpack(dummyLink, buffer);
} }
// pack all data associated with link // Pack all data associated with link
void pack(int link, MessageBufferType& buffer) void pack(int link, MessageBufferType& buffer)
{ {
// we should only get one link // We should only get one link
if (link != 0) if (link != 0) {
throw std::logic_error("link in method pack is not 0 as expected"); throw std::logic_error {
"link (" + std::to_string(link) +
// write all block data ") in method pack() is not 0 as expected"
unsigned int size = localWBPData_.size(); };
buffer.write(size);
for (const auto& [global_index, wbp_value] : localWBPData_) {
buffer.write(global_index);
buffer.write(wbp_value);
} }
// Write all local, per-well, WBP data
this->localWBPData_.write(buffer);
} }
// unpack all data associated with link // Unpack all data associated with link
void unpack(int /*link*/, MessageBufferType& buffer) void unpack([[maybe_unused]] const int link,
MessageBufferType& buffer)
{ {
// read all block data this->globalWBPValues_.read(buffer);
unsigned int size = 0;
buffer.read(size);
for (size_t i = 0; i < size; ++i) {
std::size_t idx;
double data;
buffer.read(idx);
buffer.read(data);
globalWBPValues_[idx] = data;
}
} }
}; };
@ -984,21 +977,21 @@ CollectDataToIORank(const Grid& grid, const EquilGrid* equilGrid,
template <class Grid, class EquilGrid, class GridView> template <class Grid, class EquilGrid, class GridView>
void CollectDataToIORank<Grid,EquilGrid,GridView>:: void CollectDataToIORank<Grid,EquilGrid,GridView>::
collect(const data::Solution& localCellData, collect(const data::Solution& localCellData,
const std::map<std::pair<std::string, int>, double>& localBlockData, const std::map<std::pair<std::string, int>, double>& localBlockData,
const std::map<std::size_t, double>& localWBPData, const data::Wells& localWellData,
const data::Wells& localWellData, const data::WellBlockAveragePressures& localWBPData,
const data::GroupAndNetworkValues& localGroupAndNetworkData, const data::GroupAndNetworkValues& localGroupAndNetworkData,
const data::Aquifers& localAquiferData, const data::Aquifers& localAquiferData,
const WellTestState& localWellTestState, const WellTestState& localWellTestState,
const EclInterRegFlowMap& localInterRegFlows, const EclInterRegFlowMap& localInterRegFlows,
const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFlowsn, const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFlowsn,
const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFloresn) const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFloresn)
{ {
globalCellData_ = {}; globalCellData_ = {};
globalBlockData_.clear(); globalBlockData_.clear();
globalWBPData_.clear();
globalWellData_.clear(); globalWellData_.clear();
globalWBPData_.values.clear();
globalGroupAndNetworkData_.clear(); globalGroupAndNetworkData_.clear();
globalAquiferData_.clear(); globalAquiferData_.clear();
globalWellTestState_.clear(); globalWellTestState_.clear();
@ -1055,8 +1048,8 @@ collect(const data::Solution& localCellData,
PackUnPackWBPData packUnpackWBPData { PackUnPackWBPData packUnpackWBPData {
localWBPData, localWBPData,
this->globalWBPData_, this->globalWBPData_,
this->isIORank() this->isIORank()
}; };
PackUnPackAquiferData packUnpackAquiferData { PackUnPackAquiferData packUnpackAquiferData {
@ -1110,28 +1103,37 @@ template <class Grid, class EquilGrid, class GridView>
int CollectDataToIORank<Grid,EquilGrid,GridView>:: int CollectDataToIORank<Grid,EquilGrid,GridView>::
localIdxToGlobalIdx(unsigned localIdx) const localIdxToGlobalIdx(unsigned localIdx) const
{ {
if (!isParallel()) if (!isParallel()) {
return localIdx; return localIdx;
}
if (localIdxToGlobalIdx_.empty()) if (this->localIdxToGlobalIdx_.empty()) {
throw std::logic_error("index map is not created on this rank"); throw std::logic_error("index map is not created on this rank");
}
if (localIdx > localIdxToGlobalIdx_.size()) if (localIdx > this->localIdxToGlobalIdx_.size()) {
throw std::logic_error("local index is outside map range"); throw std::logic_error("local index is outside map range");
}
return localIdxToGlobalIdx_[localIdx]; return this->localIdxToGlobalIdx_[localIdx];
} }
template <class Grid, class EquilGrid, class GridView> template <class Grid, class EquilGrid, class GridView>
bool CollectDataToIORank<Grid,EquilGrid,GridView>:: bool CollectDataToIORank<Grid,EquilGrid,GridView>::
isCartIdxOnThisRank(int cartIdx) const isCartIdxOnThisRank(int cartIdx) const
{ {
if (!isParallel()) if (! this->isParallel()) {
return true; return true;
}
assert(!needsReordering); assert (! needsReordering);
auto candidate = std::lower_bound(sortedCartesianIdx_.begin(), sortedCartesianIdx_.end(), cartIdx);
return (candidate != sortedCartesianIdx_.end() && *candidate == cartIdx); auto candidate = std::lower_bound(this->sortedCartesianIdx_.begin(),
this->sortedCartesianIdx_.end(),
cartIdx);
return (candidate != sortedCartesianIdx_.end())
&& (*candidate == cartIdx);
} }

34
ebos/collecttoiorank.hh
View File

@ -25,15 +25,21 @@
#include <opm/output/data/Aquifer.hpp> #include <opm/output/data/Aquifer.hpp>
#include <opm/output/data/Cells.hpp> #include <opm/output/data/Cells.hpp>
#include <opm/output/data/Groups.hpp>
#include <opm/output/data/Solution.hpp> #include <opm/output/data/Solution.hpp>
#include <opm/output/data/Wells.hpp> #include <opm/output/data/Wells.hpp>
#include <opm/output/data/Groups.hpp>
#include <opm/input/eclipse/Schedule/Well/WellTestState.hpp> #include <opm/input/eclipse/Schedule/Well/WellTestState.hpp>
#include <opm/grid/common/p2pcommunicator.hh> #include <opm/grid/common/p2pcommunicator.hh>
#include <ebos/eclinterregflows.hh> #include <ebos/eclinterregflows.hh>
#include <array>
#include <map> #include <map>
#include <set>
#include <string>
#include <type_traits>
#include <utility> #include <utility>
#include <vector> #include <vector>
@ -67,20 +73,17 @@ public:
const std::set<std::string>& fipRegionsInterregFlow = {}); const std::set<std::string>& fipRegionsInterregFlow = {});
// gather solution to rank 0 for EclipseWriter // gather solution to rank 0 for EclipseWriter
void collect(const data::Solution& localCellData, void collect(const data::Solution& localCellData,
const std::map<std::pair<std::string, int>, double>& localBlockData, const std::map<std::pair<std::string, int>, double>& localBlockData,
const std::map<std::size_t, double>& localWBPData, const data::Wells& localWellData,
const data::Wells& localWellData, const data::WellBlockAveragePressures& localWBPData,
const data::GroupAndNetworkValues& localGroupAndNetworkData, const data::GroupAndNetworkValues& localGroupAndNetworkData,
const data::Aquifers& localAquiferData, const data::Aquifers& localAquiferData,
const WellTestState& localWellTestState, const WellTestState& localWellTestState,
const EclInterRegFlowMap& interRegFlows, const EclInterRegFlowMap& interRegFlows,
const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFlowsn, const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFlowsn,
const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFloresn); const std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>& localFloresn);
const std::map<std::size_t, double>& globalWBPData() const
{ return this->globalWBPData_; }
const std::map<std::pair<std::string, int>, double>& globalBlockData() const const std::map<std::pair<std::string, int>, double>& globalBlockData() const
{ return globalBlockData_; } { return globalBlockData_; }
@ -90,8 +93,8 @@ public:
const data::Wells& globalWellData() const const data::Wells& globalWellData() const
{ return globalWellData_; } { return globalWellData_; }
const WellTestState& globalWellTestState() const const data::WellBlockAveragePressures& globalWBPData() const
{ return this->globalWellTestState_; } { return this->globalWBPData_; }
const data::GroupAndNetworkValues& globalGroupAndNetworkData() const const data::GroupAndNetworkValues& globalGroupAndNetworkData() const
{ return globalGroupAndNetworkData_; } { return globalGroupAndNetworkData_; }
@ -99,6 +102,9 @@ public:
const data::Aquifers& globalAquiferData() const const data::Aquifers& globalAquiferData() const
{ return globalAquiferData_; } { return globalAquiferData_; }
const WellTestState& globalWellTestState() const
{ return this->globalWellTestState_; }
EclInterRegFlowMap& globalInterRegFlows() EclInterRegFlowMap& globalInterRegFlows()
{ return this->globalInterRegFlows_; } { return this->globalInterRegFlows_; }
@ -144,8 +150,8 @@ protected:
std::vector<int> globalRanks_; std::vector<int> globalRanks_;
data::Solution globalCellData_; data::Solution globalCellData_;
std::map<std::pair<std::string, int>, double> globalBlockData_; std::map<std::pair<std::string, int>, double> globalBlockData_;
std::map<std::size_t, double> globalWBPData_;
data::Wells globalWellData_; data::Wells globalWellData_;
data::WellBlockAveragePressures globalWBPData_;
data::GroupAndNetworkValues globalGroupAndNetworkData_; data::GroupAndNetworkValues globalGroupAndNetworkData_;
data::Aquifers globalAquiferData_; data::Aquifers globalAquiferData_;
WellTestState globalWellTestState_; WellTestState globalWellTestState_;

6
ebos/eclgenericoutputblackoilmodule.hh
View File

@ -234,11 +234,6 @@ public:
return this->interRegionFlows_.wantInterRegflowSummary(); return this->interRegionFlows_.wantInterRegflowSummary();
} }
const std::map<std::size_t, double>& getWBPData() const
{
return this->wbpData_;
}
const std::map<std::pair<std::string, int>, double>& getBlockData() const std::map<std::pair<std::string, int>, double>& getBlockData()
{ {
return blockData_; return blockData_;
@ -552,7 +547,6 @@ protected:
std::map<size_t, Scalar> waterConnectionSaturations_; std::map<size_t, Scalar> waterConnectionSaturations_;
std::map<size_t, Scalar> gasConnectionSaturations_; std::map<size_t, Scalar> gasConnectionSaturations_;
std::map<std::pair<std::string, int>, double> blockData_; std::map<std::pair<std::string, int>, double> blockData_;
std::map<std::size_t , double> wbpData_;
std::optional<Inplace> initialInplace_; std::optional<Inplace> initialInplace_;
bool local_data_valid_; bool local_data_valid_;

140
ebos/eclgenericwriter.cc
View File

@ -22,12 +22,14 @@
*/ */
#include <config.h> #include <config.h>
#include <ebos/eclgenericwriter.hh> #include <ebos/eclgenericwriter.hh>
#include <opm/grid/CpGrid.hpp> #include <opm/grid/CpGrid.hpp>
#include <opm/grid/cpgrid/GridHelpers.hpp> #include <opm/grid/cpgrid/GridHelpers.hpp>
#include <opm/grid/polyhedralgrid.hh> #include <opm/grid/polyhedralgrid.hh>
#include <opm/grid/utility/cartesianToCompressed.hpp> #include <opm/grid/utility/cartesianToCompressed.hpp>
#if HAVE_DUNE_ALUGRID #if HAVE_DUNE_ALUGRID
#include "eclalugridvanguard.hh" #include "eclalugridvanguard.hh"
#include <dune/alugrid/grid.hh> #include <dune/alugrid/grid.hh>
@ -40,13 +42,14 @@
#include <opm/input/eclipse/EclipseState/EclipseState.hpp> #include <opm/input/eclipse/EclipseState/EclipseState.hpp>
#include <opm/input/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp> #include <opm/input/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
#include <opm/input/eclipse/Schedule/Action/State.hpp> #include <opm/input/eclipse/Schedule/Action/State.hpp>
#include <opm/input/eclipse/Schedule/Schedule.hpp> #include <opm/input/eclipse/Schedule/Schedule.hpp>
#include <opm/input/eclipse/Schedule/SummaryState.hpp> #include <opm/input/eclipse/Schedule/SummaryState.hpp>
#include <opm/input/eclipse/Schedule/UDQ/UDQConfig.hpp> #include <opm/input/eclipse/Schedule/UDQ/UDQConfig.hpp>
#include <opm/input/eclipse/Schedule/UDQ/UDQState.hpp> #include <opm/input/eclipse/Schedule/UDQ/UDQState.hpp>
#include <opm/input/eclipse/Schedule/Well/PAvgCalculatorCollection.hpp>
#include <opm/input/eclipse/Schedule/Well/WellMatcher.hpp> #include <opm/input/eclipse/Schedule/Well/WellMatcher.hpp>
#include <opm/input/eclipse/Units/UnitSystem.hpp> #include <opm/input/eclipse/Units/UnitSystem.hpp>
#include <dune/grid/common/mcmgmapper.hh> #include <dune/grid/common/mcmgmapper.hh>
@ -65,7 +68,12 @@
#include <mpi.h> #include <mpi.h>
#endif #endif
#include <algorithm>
#include <array> #include <array>
#include <cassert>
#include <functional>
#include <map>
#include <memory>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <utility> #include <utility>
@ -169,22 +177,22 @@ struct EclWriteTasklet : public Opm::TaskletInterface
, reportStepNum_(reportStepNum) , reportStepNum_(reportStepNum)
, isSubStep_(isSubStep) , isSubStep_(isSubStep)
, secondsElapsed_(secondsElapsed) , secondsElapsed_(secondsElapsed)
, restartValue_(restartValue) , restartValue_(std::move(restartValue))
, writeDoublePrecision_(writeDoublePrecision) , writeDoublePrecision_(writeDoublePrecision)
{ } {}
// callback to eclIO serial writeTimeStep method // callback to eclIO serial writeTimeStep method
void run() void run()
{ {
eclIO_.writeTimeStep(actionState_, this->eclIO_.writeTimeStep(this->actionState_,
wtestState_, this->wtestState_,
summaryState_, this->summaryState_,
udqState_, this->udqState_,
reportStepNum_, this->reportStepNum_,
isSubStep_, this->isSubStep_,
secondsElapsed_, this->secondsElapsed_,
restartValue_, std::move(this->restartValue_),
writeDoublePrecision_); this->writeDoublePrecision_);
} }
}; };
@ -210,38 +218,30 @@ EclGenericWriter(const Schedule& schedule,
cartMapper, cartMapper,
equilCartMapper, equilCartMapper,
summaryConfig.fip_regions_interreg_flow()) summaryConfig.fip_regions_interreg_flow())
, grid_(grid) , grid_ (grid)
, gridView_(gridView) , gridView_ (gridView)
, schedule_(schedule) , schedule_ (schedule)
, eclState_(eclState) , eclState_ (eclState)
, summaryConfig_(summaryConfig) , summaryConfig_ (summaryConfig)
, cartMapper_(cartMapper) , cartMapper_ (cartMapper)
, equilCartMapper_(equilCartMapper) , equilCartMapper_(equilCartMapper)
, equilGrid_(equilGrid) , equilGrid_ (equilGrid)
{ {
if (collectToIORank_.isIORank()) { if (this->collectToIORank_.isIORank()) {
eclIO_.reset(new EclipseIO(eclState_, this->eclIO_ = std::make_unique<EclipseIO>
UgGridHelpers::createEclipseGrid(*equilGrid, eclState_.getInputGrid()), (this->eclState_,
schedule_, UgGridHelpers::createEclipseGrid(*equilGrid, eclState_.getInputGrid()),
summaryConfig_, "", enableEsmry)); this->schedule_, this->summaryConfig_, "", enableEsmry);
}
const auto& wbp_calculators = eclIO_->summary().wbp_calculators( schedule.size() - 1 );
wbp_index_list_ = wbp_calculators.index_list();
}
if (collectToIORank_.isParallel()) {
const auto& comm = grid_.comm();
unsigned long size = wbp_index_list_.size();
comm.broadcast(&size, 1, collectToIORank_.ioRank);
if (!collectToIORank_.isIORank())
wbp_index_list_.resize( size );
comm.broadcast(wbp_index_list_.data(), size, collectToIORank_.ioRank);
}
// create output thread if enabled and rank is I/O rank // create output thread if enabled and rank is I/O rank
// async output is enabled by default if pthread are enabled // async output is enabled by default if pthread are enabled
int numWorkerThreads = 0; int numWorkerThreads = 0;
if (enableAsyncOutput && collectToIORank_.isIORank()) if (enableAsyncOutput && collectToIORank_.isIORank()) {
numWorkerThreads = 1; numWorkerThreads = 1;
taskletRunner_.reset(new TaskletRunner(numWorkerThreads)); }
this->taskletRunner_.reset(new TaskletRunner(numWorkerThreads));
} }
template<class Grid, class EquilGrid, class GridView, class ElementMapper, class Scalar> template<class Grid, class EquilGrid, class GridView, class ElementMapper, class Scalar>
@ -257,12 +257,18 @@ void EclGenericWriter<Grid,EquilGrid,GridView,ElementMapper,Scalar>::
writeInit(const std::function<unsigned int(unsigned int)>& map) writeInit(const std::function<unsigned int(unsigned int)>& map)
{ {
if (collectToIORank_.isIORank()) { if (collectToIORank_.isIORank()) {
std::map<std::string, std::vector<int> > integerVectors; std::map<std::string, std::vector<int>> integerVectors;
if (collectToIORank_.isParallel()) if (collectToIORank_.isParallel()) {
integerVectors.emplace("MPI_RANK", collectToIORank_.globalRanks()); integerVectors.emplace("MPI_RANK", collectToIORank_.globalRanks());
}
auto cartMap = cartesianToCompressed(equilGrid_->size(0), UgGridHelpers::globalCell(*equilGrid_)); auto cartMap = cartesianToCompressed(equilGrid_->size(0), UgGridHelpers::globalCell(*equilGrid_));
eclIO_->writeInitial(computeTrans_(cartMap, map), integerVectors, exportNncStructure_(cartMap, map));
eclIO_->writeInitial(computeTrans_(cartMap, map),
integerVectors,
exportNncStructure_(cartMap, map));
} }
#if HAVE_MPI #if HAVE_MPI
if (collectToIORank_.isParallel()) { if (collectToIORank_.isParallel()) {
const auto& comm = grid_.comm(); const auto& comm = grid_.comm();
@ -450,8 +456,9 @@ doWriteOutput(const int reportStepNum,
const bool needsReordering = this->collectToIORank_.doesNeedReordering(); const bool needsReordering = this->collectToIORank_.doesNeedReordering();
RestartValue restartValue { RestartValue restartValue {
(isParallel || needsReordering) ? this->collectToIORank_.globalCellData() (isParallel || needsReordering)
: std::move(localCellData), ? this->collectToIORank_.globalCellData()
: std::move(localCellData),
isParallel ? this->collectToIORank_.globalWellData() isParallel ? this->collectToIORank_.globalWellData()
: std::move(localWellData), : std::move(localWellData),
@ -515,32 +522,32 @@ doWriteOutput(const int reportStepNum,
template<class Grid, class EquilGrid, class GridView, class ElementMapper, class Scalar> template<class Grid, class EquilGrid, class GridView, class ElementMapper, class Scalar>
void EclGenericWriter<Grid,EquilGrid,GridView,ElementMapper,Scalar>:: void EclGenericWriter<Grid,EquilGrid,GridView,ElementMapper,Scalar>::
evalSummary(const int reportStepNum, evalSummary(const int reportStepNum,
const Scalar curTime, const Scalar curTime,
const std::map<std::size_t, double>& wbpData, const data::Wells& localWellData,
const data::Wells& localWellData, const data::WellBlockAveragePressures& localWBPData,
const data::GroupAndNetworkValues& localGroupAndNetworkData, const data::GroupAndNetworkValues& localGroupAndNetworkData,
const std::map<int,data::AquiferData>& localAquiferData, const std::map<int,data::AquiferData>& localAquiferData,
const std::map<std::pair<std::string, int>, double>& blockData, const std::map<std::pair<std::string, int>, double>& blockData,
const std::map<std::string, double>& miscSummaryData, const std::map<std::string, double>& miscSummaryData,
const std::map<std::string, std::vector<double>>& regionData, const std::map<std::string, std::vector<double>>& regionData,
const Inplace& inplace, const Inplace& inplace,
const Inplace& initialInPlace, const Inplace& initialInPlace,
const EclInterRegFlowMap& interRegionFlowMap, const EclInterRegFlowMap& interRegFlows,
SummaryState& summaryState, SummaryState& summaryState,
UDQState& udqState) UDQState& udqState)
{ {
if (collectToIORank_.isIORank()) { if (collectToIORank_.isIORank()) {
const auto& summary = eclIO_->summary(); const auto& summary = eclIO_->summary();
auto wbp_calculators = summary.wbp_calculators(reportStepNum);
for (const auto& [global_index, pressure] : wbpData)
wbp_calculators.add_pressure( global_index, pressure );
const auto& wellData = this->collectToIORank_.isParallel() const auto& wellData = this->collectToIORank_.isParallel()
? this->collectToIORank_.globalWellData() ? this->collectToIORank_.globalWellData()
: localWellData; : localWellData;
const auto& wbpData = this->collectToIORank_.isParallel()
? this->collectToIORank_.globalWBPData()
: localWBPData;
const auto& groupAndNetworkData = this->collectToIORank_.isParallel() const auto& groupAndNetworkData = this->collectToIORank_.isParallel()
? this->collectToIORank_.globalGroupAndNetworkData() ? this->collectToIORank_.globalGroupAndNetworkData()
: localGroupAndNetworkData; : localGroupAndNetworkData;
@ -553,24 +560,29 @@ evalSummary(const int reportStepNum,
reportStepNum, reportStepNum,
curTime, curTime,
wellData, wellData,
wbpData,
groupAndNetworkData, groupAndNetworkData,
miscSummaryData, miscSummaryData,
initialInPlace, initialInPlace,
inplace, inplace,
wbp_calculators,
regionData, regionData,
blockData, blockData,
aquiferData, aquiferData,
getInterRegFlowsAsMap(interRegionFlowMap)); getInterRegFlowsAsMap(interRegFlows));
// Off-by-one-fun: The reportStepNum argument corresponds to the // Off-by-one-fun: The reportStepNum argument corresponds to the
// report step these results will be written to, whereas the // report step these results will be written to, whereas the
// argument to UDQ function evaluation corresponds to the report // argument to UDQ function evaluation corresponds to the report
// step we are currently on. // step we are currently on.
auto udq_step = reportStepNum - 1; const auto udq_step = reportStepNum - 1;
const auto& udq_config = schedule_.getUDQConfig(udq_step);
udq_config.eval( udq_step, schedule_.wellMatcher(udq_step), summaryState, udqState); this->schedule_.getUDQConfig(udq_step)
.eval(udq_step,
this->schedule_.wellMatcher(udq_step),
summaryState,
udqState);
} }
#if HAVE_MPI #if HAVE_MPI
if (collectToIORank_.isParallel()) { if (collectToIORank_.isParallel()) {
EclMpiSerializer ser(grid_.comm()); EclMpiSerializer ser(grid_.comm());

35
ebos/eclgenericwriter.hh
View File

@ -116,10 +116,10 @@ protected:
data::GroupAndNetworkValues&& localGroupAndNetworkData, data::GroupAndNetworkValues&& localGroupAndNetworkData,
data::Aquifers&& localAquiferData, data::Aquifers&& localAquiferData,
WellTestState&& localWTestState, WellTestState&& localWTestState,
const Action::State& actionState, const Action::State& actionState,
const UDQState& udqState, const UDQState& udqState,
const SummaryState& summaryState, const SummaryState& summaryState,
const std::vector<Scalar>& thresholdPressure, const std::vector<Scalar>& thresholdPressure,
Scalar curTime, Scalar curTime,
Scalar nextStepSize, Scalar nextStepSize,
bool doublePrecision, bool doublePrecision,
@ -128,20 +128,20 @@ protected:
bool isFloresn, bool isFloresn,
std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>&& floresn); std::array<std::pair<std::string, std::pair<std::vector<int>, std::vector<double>>>, 3>&& floresn);
void evalSummary(int reportStepNum, void evalSummary(int reportStepNum,
Scalar curTime, Scalar curTime,
const std::map<std::size_t, double>& wbpData, const data::Wells& localWellData,
const data::Wells& localWellData, const data::WellBlockAveragePressures& localWBPData,
const data::GroupAndNetworkValues& localGroupAndNetworkData, const data::GroupAndNetworkValues& localGroupAndNetworkData,
const std::map<int,data::AquiferData>& localAquiferData, const std::map<int,data::AquiferData>& localAquiferData,
const std::map<std::pair<std::string, int>, double>& blockData, const std::map<std::pair<std::string, int>, double>& blockData,
const std::map<std::string, double>& miscSummaryData, const std::map<std::string, double>& miscSummaryData,
const std::map<std::string, std::vector<double>>& regionData, const std::map<std::string, std::vector<double>>& regionData,
const Inplace& inplace, const Inplace& inplace,
const Inplace& initialInPlace, const Inplace& initialInPlace,
const EclInterRegFlowMap& interRegionFlowMap, const EclInterRegFlowMap& interRegFlows,
SummaryState& summaryState, SummaryState& summaryState,
UDQState& udqState); UDQState& udqState);
CollectDataToIORankType collectToIORank_; CollectDataToIORankType collectToIORank_;
const Grid& grid_; const Grid& grid_;
@ -156,7 +156,6 @@ protected:
const Dune::CartesianIndexMapper<Grid>& cartMapper_; const Dune::CartesianIndexMapper<Grid>& cartMapper_;
const Dune::CartesianIndexMapper<EquilGrid>* equilCartMapper_; const Dune::CartesianIndexMapper<EquilGrid>* equilCartMapper_;
const EquilGrid* equilGrid_; const EquilGrid* equilGrid_;
std::vector<std::size_t> wbp_index_list_;
SimulatorReportSingle sub_step_report_; SimulatorReportSingle sub_step_report_;
SimulatorReport simulation_report_; SimulatorReport simulation_report_;
mutable std::vector<NNCdata> outputNnc_; mutable std::vector<NNCdata> outputNnc_;

64
ebos/ecloutputblackoilmodule.hh
View File

@ -138,7 +138,6 @@ class EclOutputBlackOilModule : public EclGenericOutputBlackoilModule<GetPropTyp
public: public:
template <class CollectDataToIORankType> template <class CollectDataToIORankType>
EclOutputBlackOilModule(const Simulator& simulator, EclOutputBlackOilModule(const Simulator& simulator,
const std::vector<std::size_t>& wbp_index_list,
const CollectDataToIORankType& collectToIORank) const CollectDataToIORankType& collectToIORank)
: BaseType(simulator.vanguard().eclState(), : BaseType(simulator.vanguard().eclState(),
simulator.vanguard().schedule(), simulator.vanguard().schedule(),
@ -159,22 +158,17 @@ public:
this->createLocalRegion_(region_pair.second); this->createLocalRegion_(region_pair.second);
} }
auto isCartIdxOnThisRank = [&collectToIORank](int idx) auto isCartIdxOnThisRank = [&collectToIORank](const int idx) {
{ return collectToIORank.isCartIdxOnThisRank(idx);
return collectToIORank.isCartIdxOnThisRank(idx); };
};
this->setupBlockData(isCartIdxOnThisRank); this->setupBlockData(isCartIdxOnThisRank);
for (const auto& global_index : wbp_index_list) { this->forceDisableFipOutput_ =
if (collectToIORank.isCartIdxOnThisRank(global_index - 1)) { EWOMS_GET_PARAM(TypeTag, bool, ForceDisableFluidInPlaceOutput);
this->wbpData_.emplace(global_index, 0.0);
}
}
this->forceDisableFipOutput_ = EWOMS_GET_PARAM(TypeTag, bool, ForceDisableFluidInPlaceOutput); this->forceDisableFipresvOutput_ =
EWOMS_GET_PARAM(TypeTag, bool, ForceDisableResvFluidInPlaceOutput);
this->forceDisableFipresvOutput_ = EWOMS_GET_PARAM(TypeTag, bool, ForceDisableResvFluidInPlaceOutput);
} }
/*! /*!
@ -199,25 +193,32 @@ public:
* write to ECL output files * write to ECL output files
*/ */
void void
allocBuffers(unsigned bufferSize, unsigned reportStepNum, const bool substep, const bool log, const bool isRestart) allocBuffers(const unsigned bufferSize,
const unsigned reportStepNum,
const bool substep,
const bool log,
const bool isRestart)
{ {
if (!std::is_same<Discretization, EcfvDiscretization<TypeTag>>::value) if (! std::is_same<Discretization, EcfvDiscretization<TypeTag>>::value) {
return; return;
}
const auto& problem = this->simulator_.problem();
this->doAllocBuffers(bufferSize, this->doAllocBuffers(bufferSize,
reportStepNum, reportStepNum,
substep, substep,
log, log,
isRestart, isRestart,
simulator_.problem().vapparsActive(std::max(simulator_.episodeIndex(), 0)), problem.vapparsActive(std::max(simulator_.episodeIndex(), 0)),
simulator_.problem().materialLawManager()->enableHysteresis(), problem.materialLawManager()->enableHysteresis(),
simulator_.problem().tracerModel().numTracers(), problem.tracerModel().numTracers(),
simulator_.problem().eclWriter()->getOutputNnc().size()); problem.eclWriter()->getOutputNnc().size());
} }
/*! /*!
* \brief Modify the internal buffers according to the intensive quanties relevant * \brief Modify the internal buffers according to the intensive
* for an element * quanties relevant for an element
*/ */
void processElement(const ElementContext& elemCtx) void processElement(const ElementContext& elemCtx)
{ {
@ -550,7 +551,6 @@ public:
= FluidSystem::viscosity(fsInitial, gasPhaseIdx, intQuants.pvtRegionIndex()); = FluidSystem::viscosity(fsInitial, gasPhaseIdx, intQuants.pvtRegionIndex());
} }
// Adding Well RFT data // Adding Well RFT data
const auto cartesianIdx = elemCtx.simulator().vanguard().cartesianIndex(globalDofIdx); const auto cartesianIdx = elemCtx.simulator().vanguard().cartesianIndex(globalDofIdx);
if (this->oilConnectionPressures_.count(cartesianIdx) > 0) { if (this->oilConnectionPressures_.count(cartesianIdx) > 0) {
@ -562,25 +562,17 @@ public:
if (this->gasConnectionSaturations_.count(cartesianIdx) > 0) { if (this->gasConnectionSaturations_.count(cartesianIdx) > 0) {
this->gasConnectionSaturations_[cartesianIdx] = getValue(fs.saturation(gasPhaseIdx)); this->gasConnectionSaturations_[cartesianIdx] = getValue(fs.saturation(gasPhaseIdx));
} }
if (this->wbpData_.count(cartesianIdx) > 0) {
if (FluidSystem::phaseIsActive(oilPhaseIdx)) {
this->wbpData_[cartesianIdx] = getValue(fs.pressure(oilPhaseIdx));
} else if (FluidSystem::phaseIsActive(gasPhaseIdx)) {
this->wbpData_[cartesianIdx] = getValue(fs.pressure(gasPhaseIdx));
} else if (FluidSystem::phaseIsActive(waterPhaseIdx)) {
this->wbpData_[cartesianIdx] = getValue(fs.pressure(waterPhaseIdx));
}
}
// tracers // tracers
const auto& tracerModel = simulator_.problem().tracerModel(); const auto& tracerModel = simulator_.problem().tracerModel();
if (!this->tracerConcentrations_.empty()) { if (! this->tracerConcentrations_.empty()) {
for (int tracerIdx = 0; tracerIdx < tracerModel.numTracers(); tracerIdx++) { for (int tracerIdx = 0; tracerIdx < tracerModel.numTracers(); ++tracerIdx) {
if (this->tracerConcentrations_[tracerIdx].empty()) if (this->tracerConcentrations_[tracerIdx].empty()) {
continue; continue;
}
this->tracerConcentrations_[tracerIdx][globalDofIdx] this->tracerConcentrations_[tracerIdx][globalDofIdx] =
= tracerModel.tracerConcentration(tracerIdx, globalDofIdx); tracerModel.tracerConcentration(tracerIdx, globalDofIdx);
} }
} }
} }

173
ebos/eclwriter.hh
View File

@ -148,22 +148,28 @@ public:
simulator.vanguard().eclState(), simulator.vanguard().eclState(),
simulator.vanguard().summaryConfig(), simulator.vanguard().summaryConfig(),
simulator.vanguard().grid(), simulator.vanguard().grid(),
simulator.vanguard().grid().comm().rank() == 0 ? &simulator.vanguard().equilGrid() : nullptr, ((simulator.vanguard().grid().comm().rank() == 0)
? &simulator.vanguard().equilGrid()
: nullptr),
simulator.vanguard().gridView(), simulator.vanguard().gridView(),
simulator.vanguard().cartesianIndexMapper(), simulator.vanguard().cartesianIndexMapper(),
simulator.vanguard().grid().comm().rank() == 0 ? &simulator.vanguard().equilCartesianIndexMapper() : nullptr, ((simulator.vanguard().grid().comm().rank() == 0)
EWOMS_GET_PARAM(TypeTag, bool, EnableAsyncEclOutput), EWOMS_GET_PARAM(TypeTag, bool, EnableEsmry)) ? &simulator.vanguard().equilCartesianIndexMapper()
: nullptr),
EWOMS_GET_PARAM(TypeTag, bool, EnableAsyncEclOutput),
EWOMS_GET_PARAM(TypeTag, bool, EnableEsmry))
, simulator_(simulator) , simulator_(simulator)
{ {
#ifdef HAVE_DAMARIS #ifdef HAVE_DAMARIS
this->damarisUpdate_ = enableDamarisOutput_(); this->damarisUpdate_ = enableDamarisOutput_();
#endif #endif
this->eclOutputModule_ = std::make_unique<EclOutputBlackOilModule<TypeTag>>(simulator, this->wbp_index_list_, this->collectToIORank_);
this->wbp_index_list_.clear(); this->eclOutputModule_ = std::make_unique<EclOutputBlackOilModule<TypeTag>>
(simulator, this->collectToIORank_);
} }
~EclWriter() ~EclWriter()
{ } {}
const EquilGrid& globalGrid() const const EquilGrid& globalGrid() const
{ {
@ -204,6 +210,7 @@ public:
simulator_.vanguard().setupTime(); simulator_.vanguard().setupTime();
const auto localWellData = simulator_.problem().wellModel().wellData(); const auto localWellData = simulator_.problem().wellModel().wellData();
const auto localWBP = data::WellBlockAveragePressures{};
const auto localGroupAndNetworkData = simulator_.problem().wellModel() const auto localGroupAndNetworkData = simulator_.problem().wellModel()
.groupAndNetworkData(reportStepNum); .groupAndNetworkData(reportStepNum);
@ -220,8 +227,8 @@ public:
this->collectToIORank_.collect({}, this->collectToIORank_.collect({},
eclOutputModule_->getBlockData(), eclOutputModule_->getBlockData(),
eclOutputModule_->getWBPData(),
localWellData, localWellData,
localWBP,
localGroupAndNetworkData, localGroupAndNetworkData,
localAquiferData, localAquiferData,
localWellTestState, localWellTestState,
@ -283,26 +290,34 @@ public:
if (this->simulation_report_.success.total_newton_iterations != 0) { if (this->simulation_report_.success.total_newton_iterations != 0) {
miscSummaryData["MSUMNEWT"] = this->simulation_report_.success.total_newton_iterations; miscSummaryData["MSUMNEWT"] = this->simulation_report_.success.total_newton_iterations;
} }
{ {
OPM_TIMEBLOCK(evalSummary); OPM_TIMEBLOCK(evalSummary);
this->evalSummary(reportStepNum, curTime,
this->collectToIORank_.isParallel() ? const auto& blockData = this->collectToIORank_.isParallel()
this->collectToIORank_.globalWBPData() : ? this->collectToIORank_.globalBlockData()
this->eclOutputModule_->getWBPData(), : this->eclOutputModule_->getBlockData();
localWellData,
localGroupAndNetworkData, const auto& interRegFlows = this->collectToIORank_.isParallel()
localAquiferData, ? this->collectToIORank_.globalInterRegFlows()
this->collectToIORank_.isParallel() ? : this->eclOutputModule_->getInterRegFlows();
this->collectToIORank_.globalBlockData() :
this->eclOutputModule_->getBlockData(), this->evalSummary(reportStepNum,
miscSummaryData, regionData, curTime,
inplace, localWellData,
eclOutputModule_->initialInplace(), localWBP,
this->collectToIORank_.isParallel() localGroupAndNetworkData,
? this->collectToIORank_.globalInterRegFlows() localAquiferData,
: this->eclOutputModule_->getInterRegFlows(), blockData,
summaryState(), udqState()); miscSummaryData,
regionData,
inplace,
this->eclOutputModule_->initialInplace(),
interRegFlows,
this->summaryState(),
this->udqState());
} }
{ {
OPM_TIMEBLOCK(outputXXX); OPM_TIMEBLOCK(outputXXX);
eclOutputModule_->outputProdLog(reportStepNum, isSubStep, forceDisableProdOutput); eclOutputModule_->outputProdLog(reportStepNum, isSubStep, forceDisableProdOutput);
@ -314,9 +329,11 @@ public:
void writeOutput(bool isSubStep) void writeOutput(bool isSubStep)
{ {
OPM_TIMEBLOCK(writeOutput); OPM_TIMEBLOCK(writeOutput);
const int reportStepNum = simulator_.episodeIndex() + 1; const int reportStepNum = simulator_.episodeIndex() + 1;
this->prepareLocalCellData(isSubStep, reportStepNum); this->prepareLocalCellData(isSubStep, reportStepNum);
this->eclOutputModule_->outputErrorLog(simulator_.gridView().comm()); this->eclOutputModule_->outputErrorLog(simulator_.gridView().comm());
#ifdef HAVE_DAMARIS #ifdef HAVE_DAMARIS
if (EWOMS_GET_PARAM(TypeTag, bool, EnableDamarisOutput)) { if (EWOMS_GET_PARAM(TypeTag, bool, EnableDamarisOutput)) {
// N.B. damarisUpdate_ should be set to true if at any time the model geometry changes // N.B. damarisUpdate_ should be set to true if at any time the model geometry changes
@ -340,35 +357,44 @@ public:
} }
} }
#endif #endif
// output using eclWriter if enabled
auto localWellData = simulator_.problem().wellModel().wellData(); auto localWellData = simulator_.problem().wellModel().wellData();
auto localGroupAndNetworkData = simulator_.problem().wellModel() auto localGroupAndNetworkData = simulator_.problem().wellModel()
.groupAndNetworkData(reportStepNum); .groupAndNetworkData(reportStepNum);
auto localAquiferData = simulator_.problem().aquiferModel().aquiferData(); auto localAquiferData = simulator_.problem().aquiferModel().aquiferData();
auto localWellTestState = simulator_.problem().wellModel().wellTestState(); auto localWellTestState = simulator_.problem().wellModel().wellTestState();
auto flowsn = this->eclOutputModule_->getFlowsn();
const bool isFlowsn = this->eclOutputModule_->hasFlowsn(); const bool isFlowsn = this->eclOutputModule_->hasFlowsn();
auto floresn = this->eclOutputModule_->getFloresn(); auto flowsn = this->eclOutputModule_->getFlowsn();
const bool isFloresn = this->eclOutputModule_->hasFloresn(); const bool isFloresn = this->eclOutputModule_->hasFloresn();
auto floresn = this->eclOutputModule_->getFloresn();
data::Solution localCellData = {}; data::Solution localCellData = {};
if (! isSubStep) { if (! isSubStep) {
this->eclOutputModule_->assignToSolution(localCellData); this->eclOutputModule_->assignToSolution(localCellData);
// add cell data to perforations for Rft output // Add cell data to perforations for RFT output
this->eclOutputModule_->addRftDataToWells(localWellData, reportStepNum); this->eclOutputModule_->addRftDataToWells(localWellData, reportStepNum);
} }
if (this->collectToIORank_.isParallel()|| this->collectToIORank_.doesNeedReordering()) { if (this->collectToIORank_.isParallel() ||
this->collectToIORank_.doesNeedReordering())
{
// Note: We don't need WBP (well-block averaged pressures) or
// inter-region flow rate values in order to create restart file
// output. There's consequently no need to collect those
// properties on the I/O rank.
this->collectToIORank_.collect(localCellData, this->collectToIORank_.collect(localCellData,
eclOutputModule_->getBlockData(), this->eclOutputModule_->getBlockData(),
eclOutputModule_->getWBPData(),
localWellData, localWellData,
/* wbpData = */ {},
localGroupAndNetworkData, localGroupAndNetworkData,
localAquiferData, localAquiferData,
localWellTestState, localWellTestState,
{}, /* interRegFlows = */ {},
flowsn, flowsn,
floresn); floresn);
} }
@ -376,6 +402,7 @@ public:
if (this->collectToIORank_.isIORank()) { if (this->collectToIORank_.isIORank()) {
const Scalar curTime = simulator_.time() + simulator_.timeStepSize(); const Scalar curTime = simulator_.time() + simulator_.timeStepSize();
const Scalar nextStepSize = simulator_.problem().nextTimeStepSize(); const Scalar nextStepSize = simulator_.problem().nextTimeStepSize();
this->doWriteOutput(reportStepNum, isSubStep, this->doWriteOutput(reportStepNum, isSubStep,
std::move(localCellData), std::move(localCellData),
std::move(localWellData), std::move(localWellData),
@ -385,13 +412,11 @@ public:
this->actionState(), this->actionState(),
this->udqState(), this->udqState(),
this->summaryState(), this->summaryState(),
simulator_.problem().thresholdPressure().getRestartVector(), this->simulator_.problem().thresholdPressure().getRestartVector(),
curTime, nextStepSize, curTime, nextStepSize,
EWOMS_GET_PARAM(TypeTag, bool, EclOutputDoublePrecision), EWOMS_GET_PARAM(TypeTag, bool, EclOutputDoublePrecision),
isFlowsn, isFlowsn, std::move(flowsn),
std::move(flowsn), isFloresn, std::move(floresn));
isFloresn,
std::move(floresn));
} }
} }
@ -487,7 +512,7 @@ public:
Scalar restartTimeStepSize() const Scalar restartTimeStepSize() const
{ return restartTimeStepSize_; } { return restartTimeStepSize_; }
template<class Serializer> template <class Serializer>
void serializeOp(Serializer& serializer) void serializeOp(Serializer& serializer)
{ {
serializer(*eclOutputModule_); serializer(*eclOutputModule_);
@ -496,10 +521,12 @@ public:
private: private:
static bool enableEclOutput_() static bool enableEclOutput_()
{ return EWOMS_GET_PARAM(TypeTag, bool, EnableEclOutput); } { return EWOMS_GET_PARAM(TypeTag, bool, EnableEclOutput); }
#ifdef HAVE_DAMARIS #ifdef HAVE_DAMARIS
static bool enableDamarisOutput_() static bool enableDamarisOutput_()
{ return EWOMS_GET_PARAM(TypeTag, bool, EnableDamarisOutput); } { return EWOMS_GET_PARAM(TypeTag, bool, EnableDamarisOutput); }
#endif #endif
const EclipseState& eclState() const const EclipseState& eclState() const
{ return simulator_.vanguard().eclState(); } { return simulator_.vanguard().eclState(); }
@ -519,7 +546,8 @@ private:
const int reportStepNum) const int reportStepNum)
{ {
OPM_TIMEBLOCK(prepareLocalCellData); OPM_TIMEBLOCK(prepareLocalCellData);
if (eclOutputModule_->localDataValid()) {
if (this->eclOutputModule_->localDataValid()) {
return; return;
} }
@ -527,54 +555,68 @@ private:
const int numElements = gridView.size(/*codim=*/0); const int numElements = gridView.size(/*codim=*/0);
const bool log = this->collectToIORank_.isIORank(); const bool log = this->collectToIORank_.isIORank();
eclOutputModule_->allocBuffers(numElements, reportStepNum, this->eclOutputModule_->
isSubStep, log, /*isRestart*/ false); allocBuffers(numElements, reportStepNum,
isSubStep, log, /*isRestart*/ false);
ElementContext elemCtx(simulator_); ElementContext elemCtx(simulator_);
OPM_BEGIN_PARALLEL_TRY_CATCH();
{
OPM_TIMEBLOCK(prepareCellBasedData);
for (const auto& elem : elements(gridView)) {
elemCtx.updatePrimaryStencil(elem);
elemCtx.updatePrimaryIntensiveQuantities(/*timeIdx=*/0);
eclOutputModule_->processElement(elemCtx); OPM_BEGIN_PARALLEL_TRY_CATCH();
{
OPM_TIMEBLOCK(prepareCellBasedData);
for (const auto& elem : elements(gridView)) {
elemCtx.updatePrimaryStencil(elem);
elemCtx.updatePrimaryIntensiveQuantities(/*timeIdx=*/0);
this->eclOutputModule_->processElement(elemCtx);
}
} }
}
if(!simulator_.model().linearizer().getFlowsInfo().empty()){ if (! this->simulator_.model().linearizer().getFlowsInfo().empty()) {
OPM_TIMEBLOCK(prepareFlowsData); OPM_TIMEBLOCK(prepareFlowsData);
for (const auto& elem : elements(gridView)) { for (const auto& elem : elements(gridView)) {
elemCtx.updatePrimaryStencil(elem); elemCtx.updatePrimaryStencil(elem);
elemCtx.updatePrimaryIntensiveQuantities(/*timeIdx=*/0); elemCtx.updatePrimaryIntensiveQuantities(/*timeIdx=*/0);
eclOutputModule_->processElementFlows(elemCtx);
this->eclOutputModule_->processElementFlows(elemCtx);
} }
} }
{ {
OPM_TIMEBLOCK(prepareBlockData); OPM_TIMEBLOCK(prepareBlockData);
for (const auto& elem : elements(gridView)) { for (const auto& elem : elements(gridView)) {
elemCtx.updatePrimaryStencil(elem); elemCtx.updatePrimaryStencil(elem);
elemCtx.updatePrimaryIntensiveQuantities(/*timeIdx=*/0); elemCtx.updatePrimaryIntensiveQuantities(/*timeIdx=*/0);
eclOutputModule_->processElementBlockData(elemCtx);
} this->eclOutputModule_->processElementBlockData(elemCtx);
}
} }
{ {
OPM_TIMEBLOCK(prepareFluidInPlace); OPM_TIMEBLOCK(prepareFluidInPlace);
#ifdef _OPENMP #ifdef _OPENMP
#pragma omp parallel for #pragma omp parallel for
#endif #endif
for (int dofIdx=0; dofIdx < numElements; ++dofIdx){ for (int dofIdx = 0; dofIdx < numElements; ++dofIdx) {
const auto& intQuants = *(simulator_.model().cachedIntensiveQuantities(dofIdx, /*timeIdx=*/0)); const auto& intQuants = *simulator_.model().cachedIntensiveQuantities(dofIdx, /*timeIdx=*/0);
const auto totVolume = simulator_.model().dofTotalVolume(dofIdx); const auto totVolume = simulator_.model().dofTotalVolume(dofIdx);
eclOutputModule_->updateFluidInPlace(dofIdx, intQuants, totVolume);
this->eclOutputModule_->updateFluidInPlace(dofIdx, intQuants, totVolume);
}
} }
}
eclOutputModule_->validateLocalData(); this->eclOutputModule_->validateLocalData();
OPM_END_PARALLEL_TRY_CATCH("EclWriter::prepareLocalCellData() failed: ", simulator_.vanguard().grid().comm());
OPM_END_PARALLEL_TRY_CATCH("EclWriter::prepareLocalCellData() failed: ",
this->simulator_.vanguard().grid().comm());
} }
void captureLocalFluxData() void captureLocalFluxData()
{ {
OPM_TIMEBLOCK(captureLocalData); OPM_TIMEBLOCK(captureLocalData);
const auto& gridView = this->simulator_.vanguard().gridView(); const auto& gridView = this->simulator_.vanguard().gridView();
const auto timeIdx = 0u; const auto timeIdx = 0u;
@ -612,6 +654,7 @@ private:
Simulator& simulator_; Simulator& simulator_;
std::unique_ptr<EclOutputBlackOilModule<TypeTag>> eclOutputModule_; std::unique_ptr<EclOutputBlackOilModule<TypeTag>> eclOutputModule_;
Scalar restartTimeStepSize_; Scalar restartTimeStepSize_;
#ifdef HAVE_DAMARIS #ifdef HAVE_DAMARIS
bool damarisUpdate_ = false; ///< Whenever this is true writeOutput() will set up Damaris offsets of model fields bool damarisUpdate_ = false; ///< Whenever this is true writeOutput() will set up Damaris offsets of model fields
#endif #endif

2
tests/test_ParallelSerialization.cpp
View File

@ -211,6 +211,8 @@ TEST_FOR_TYPE_NAMED(data::SegmentPressures, SegmentPressures)
TEST_FOR_TYPE_NAMED(data::Solution, Solution) TEST_FOR_TYPE_NAMED(data::Solution, Solution)
TEST_FOR_TYPE_NAMED(data::Well, dataWell) TEST_FOR_TYPE_NAMED(data::Well, dataWell)
TEST_FOR_TYPE_NAMED(data::Wells, Wells) TEST_FOR_TYPE_NAMED(data::Wells, Wells)
TEST_FOR_TYPE_NAMED(data::WellBlockAvgPress, dataWBPObject)
TEST_FOR_TYPE_NAMED(data::WellBlockAveragePressures, dataWBPCollection)
TEST_FOR_TYPE(Deck) TEST_FOR_TYPE(Deck)
TEST_FOR_TYPE(DeckItem) TEST_FOR_TYPE(DeckItem)
TEST_FOR_TYPE(DeckKeyword) TEST_FOR_TYPE(DeckKeyword)