My Project
Loading...
Searching...
No Matches
BlackoilWellModel.hpp
1/*
2 Copyright 2016 SINTEF ICT, Applied Mathematics.
3 Copyright 2016 - 2017 Statoil ASA.
4 Copyright 2017 Dr. Blatt - HPC-Simulation-Software & Services
5 Copyright 2016 - 2018 IRIS AS
6
7 This file is part of the Open Porous Media project (OPM).
8
9 OPM is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 OPM is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with OPM. If not, see <http://www.gnu.org/licenses/>.
21*/
22
23
24#ifndef OPM_BLACKOILWELLMODEL_HEADER_INCLUDED
25#define OPM_BLACKOILWELLMODEL_HEADER_INCLUDED
26
27#include <opm/common/OpmLog/OpmLog.hpp>
28
29#include <cstddef>
30#include <map>
31#include <memory>
32#include <optional>
33#include <string>
34#include <vector>
35
36#include <opm/grid/utility/SparseTable.hpp>
37
38#include <opm/input/eclipse/Schedule/Group/Group.hpp>
39#include <opm/input/eclipse/Schedule/Group/GuideRate.hpp>
40#include <opm/input/eclipse/Schedule/Schedule.hpp>
41#include <opm/input/eclipse/Schedule/Well/WellTestState.hpp>
42
44
45#include <opm/simulators/flow/countGlobalCells.hpp>
47#include <opm/simulators/flow/SubDomain.hpp>
48
49#include <opm/simulators/linalg/matrixblock.hh>
50
51#include <opm/simulators/wells/BlackoilWellModelGeneric.hpp>
52#include <opm/simulators/wells/BlackoilWellModelGuideRates.hpp>
53#include <opm/simulators/wells/GasLiftGroupInfo.hpp>
54#include <opm/simulators/wells/GasLiftSingleWell.hpp>
55#include <opm/simulators/wells/GasLiftSingleWellGeneric.hpp>
56#include <opm/simulators/wells/GasLiftWellState.hpp>
57#include <opm/simulators/wells/MultisegmentWell.hpp>
58#include <opm/simulators/wells/ParallelWBPCalculation.hpp>
59#include <opm/simulators/wells/ParallelWellInfo.hpp>
60#include <opm/simulators/wells/PerforationData.hpp>
63#include <opm/simulators/wells/StandardWell.hpp>
64#include <opm/simulators/wells/VFPInjProperties.hpp>
65#include <opm/simulators/wells/VFPProdProperties.hpp>
66#include <opm/simulators/wells/WGState.hpp>
67#include <opm/simulators/wells/WellGroupHelpers.hpp>
68#include <opm/simulators/wells/WellInterface.hpp>
69#include <opm/simulators/wells/WellProdIndexCalculator.hpp>
70#include <opm/simulators/wells/WellState.hpp>
71
72#include <opm/simulators/timestepping/SimulatorReport.hpp>
73#include <opm/simulators/timestepping/gatherConvergenceReport.hpp>
74
75#include <dune/common/fmatrix.hh>
76#include <dune/istl/bcrsmatrix.hh>
77#include <dune/istl/matrixmatrix.hh>
78
79#include <opm/material/densead/Math.hpp>
80
81#include <opm/simulators/utils/DeferredLogger.hpp>
82
83namespace Opm::Parameters {
84
85struct EnableTerminalOutput { static constexpr bool value = true; };
86
87} // namespace Opm::Parameters
88
89namespace Opm {
90
91#if COMPILE_BDA_BRIDGE
92template<class Scalar> class WellContributions;
93#endif
94
96 template<typename TypeTag>
97 class BlackoilWellModel : public BaseAuxiliaryModule<TypeTag>
98 , public BlackoilWellModelGeneric<GetPropType<TypeTag,
99 Properties::Scalar>>
100 {
101 public:
102 // --------- Types ---------
114 using GLiftOptWells = typename BlackoilWellModelGeneric<Scalar>::GLiftOptWells;
115 using GLiftProdWells = typename BlackoilWellModelGeneric<Scalar>::GLiftProdWells;
116 using GLiftWellStateMap =
117 typename BlackoilWellModelGeneric<Scalar>::GLiftWellStateMap;
118 using GLiftEclWells = typename GasLiftGroupInfo<Scalar>::GLiftEclWells;
119 using GLiftSyncGroups = typename GasLiftSingleWellGeneric<Scalar>::GLiftSyncGroups;
120
121 using ModelParameters = BlackoilModelParameters<Scalar>;
122
123 constexpr static std::size_t pressureVarIndex = GetPropType<TypeTag, Properties::Indices>::pressureSwitchIdx;
124 typedef typename BaseAuxiliaryModule<TypeTag>::NeighborSet NeighborSet;
125
126 static const int numEq = Indices::numEq;
127 static const int solventSaturationIdx = Indices::solventSaturationIdx;
128 static constexpr bool has_solvent_ = getPropValue<TypeTag, Properties::EnableSolvent>();
129 static constexpr bool has_polymer_ = getPropValue<TypeTag, Properties::EnablePolymer>();
130 static constexpr bool has_energy_ = getPropValue<TypeTag, Properties::EnableEnergy>();
131 static constexpr bool has_micp_ = getPropValue<TypeTag, Properties::EnableMICP>();
132
133 // TODO: where we should put these types, WellInterface or Well Model?
134 // or there is some other strategy, like TypeTag
135 typedef Dune::FieldVector<Scalar, numEq > VectorBlockType;
136 typedef Dune::BlockVector<VectorBlockType> BVector;
137
138 typedef BlackOilPolymerModule<TypeTag> PolymerModule;
139 typedef BlackOilMICPModule<TypeTag> MICPModule;
140
141 // For the conversion between the surface volume rate and resrevoir voidage rate
142 using RateConverterType = RateConverter::
143 SurfaceToReservoirVoidage<FluidSystem, std::vector<int> >;
144
145 // For computing average pressured used by gpmaint
146 using AverageRegionalPressureType = RegionAverageCalculator::
147 AverageRegionalPressure<FluidSystem, std::vector<int> >;
148
149 using Domain = SubDomain<Grid>;
150
151 BlackoilWellModel(Simulator& simulator);
152
153 void init();
154 void initWellContainer(const int reportStepIdx) override;
155
157 // <eWoms auxiliary module stuff>
159 unsigned numDofs() const override
160 // No extra dofs are inserted for wells. (we use a Schur complement.)
161 { return 0; }
162
163 void addNeighbors(std::vector<NeighborSet>& neighbors) const override;
164
165 void applyInitial() override
166 {}
167
168 void linearize(SparseMatrixAdapter& jacobian, GlobalEqVector& res) override;
169 void linearizeDomain(const Domain& domain, SparseMatrixAdapter& jacobian, GlobalEqVector& res);
170
171 void postSolve(GlobalEqVector& deltaX) override
172 {
173 recoverWellSolutionAndUpdateWellState(deltaX);
174 }
175
176 void postSolveDomain(GlobalEqVector& deltaX, const Domain& domain)
177 {
178 recoverWellSolutionAndUpdateWellStateDomain(deltaX, domain);
179 }
180
182 // </ eWoms auxiliary module stuff>
184
185 template <class Restarter>
186 void deserialize(Restarter& /* res */)
187 {
188 // TODO (?)
189 }
190
195 template <class Restarter>
196 void serialize(Restarter& /* res*/)
197 {
198 // TODO (?)
199 }
200
201 void beginEpisode()
202 {
203 OPM_TIMEBLOCK(beginEpsiode);
204 beginReportStep(simulator_.episodeIndex());
205 }
206
207 void beginTimeStep();
208
209 void beginIteration()
210 {
211 OPM_TIMEBLOCK(beginIteration);
212 assemble(simulator_.model().newtonMethod().numIterations(),
213 simulator_.timeStepSize());
214 }
215
216 void endIteration()
217 { }
218
219 void endTimeStep()
220 {
221 OPM_TIMEBLOCK(endTimeStep);
222 timeStepSucceeded(simulator_.time(), simulator_.timeStepSize());
223 }
224
225 void endEpisode()
226 {
227 endReportStep();
228 }
229
230 void computeTotalRatesForDof(RateVector& rate,
231 unsigned globalIdx) const;
232
233 template <class Context>
234 void computeTotalRatesForDof(RateVector& rate,
235 const Context& context,
236 unsigned spaceIdx,
237 unsigned timeIdx) const;
238
239
240 using WellInterfacePtr = std::shared_ptr<WellInterface<TypeTag> >;
241
242 using BlackoilWellModelGeneric<Scalar>::initFromRestartFile;
243 void initFromRestartFile(const RestartValue& restartValues)
244 {
245 initFromRestartFile(restartValues,
246 this->simulator_.vanguard().transferWTestState(),
247 grid().size(0),
249 }
250
251 using BlackoilWellModelGeneric<Scalar>::prepareDeserialize;
252 void prepareDeserialize(const int report_step)
253 {
254 prepareDeserialize(report_step, grid().size(0),
256 }
257
258 data::Wells wellData() const
259 {
260 auto wsrpt = this->wellState()
261 .report(simulator_.vanguard().globalCell().data(),
262 [this](const int well_index) -> bool
263 {
264 return this->wasDynamicallyShutThisTimeStep(well_index);
265 });
266
267 {
268 const auto& tracerRates = this->simulator_.problem()
269 .tracerModel().getWellTracerRates();
270 const auto& freeTracerRates = simulator_.problem()
271 .tracerModel().getWellFreeTracerRates();
272 const auto& solTracerRates = simulator_.problem()
273 .tracerModel().getWellSolTracerRates();
274 const auto& mswTracerRates = simulator_.problem()
275 .tracerModel().getMswTracerRates();
276
277 this->assignWellTracerRates(wsrpt, tracerRates);
278 this->assignWellTracerRates(wsrpt, freeTracerRates);
279 this->assignWellTracerRates(wsrpt, solTracerRates);
280 this->assignMswTracerRates(wsrpt, mswTracerRates);
281 }
282
283 BlackoilWellModelGuideRates(*this)
284 .assignWellGuideRates(wsrpt, this->reportStepIndex());
285
286 this->assignWellTargets(wsrpt);
287 this->assignShutConnections(wsrpt, this->reportStepIndex());
288 // only used to compute gas injection mass rates for CO2STORE runs
289 // The gas reference density is thus the same for all pvt regions
290 // We therefore for simplicity use 0 here
291 if (eclState().runspec().co2Storage()) {
292 this->assignMassGasRate(wsrpt, FluidSystem::referenceDensity(FluidSystem::gasPhaseIdx, 0));
293 }
294 return wsrpt;
295 }
296
297 data::WellBlockAveragePressures wellBlockAveragePressures() const
298 {
299 return this->computeWellBlockAveragePressures();
300 }
301
302 // subtract B*inv(D)*C * x from A*x
303 void apply(const BVector& x, BVector& Ax) const;
304
305 void applyDomain(const BVector& x, BVector& Ax, const int domainIndex) const;
306
307#if COMPILE_BDA_BRIDGE
308 // accumulate the contributions of all Wells in the WellContributions object
309 void getWellContributions(WellContributions<Scalar>& x) const;
310#endif
311
312 // apply well model with scaling of alpha
313 void applyScaleAdd(const Scalar alpha, const BVector& x, BVector& Ax) const;
314
315 void applyScaleAddDomain(const Scalar alpha, const BVector& x, BVector& Ax, const int domainIndex) const;
316
317 // Check if well equations is converged.
318 ConvergenceReport getWellConvergence(const std::vector<Scalar>& B_avg, const bool checkWellGroupControls = false) const;
319
320 // Check if well equations are converged locally.
321 ConvergenceReport getDomainWellConvergence(const Domain& domain,
322 const std::vector<Scalar>& B_avg,
323 DeferredLogger& local_deferredLogger) const;
324
325 const SimulatorReportSingle& lastReport() const;
326
327 void addWellContributions(SparseMatrixAdapter& jacobian) const;
328
329 // add source from wells to the reservoir matrix
330 void addReservoirSourceTerms(GlobalEqVector& residual,
331 std::vector<typename SparseMatrixAdapter::MatrixBlock*>& diagMatAddress) const;
332
333 // called at the beginning of a report step
334 void beginReportStep(const int time_step);
335
336 // it should be able to go to prepareTimeStep(), however, the updateWellControls() and initPrimaryVariablesEvaluation()
337 // makes it a little more difficult. unless we introduce if (iterationIdx != 0) to avoid doing the above functions
338 // twice at the beginning of the time step
341 void calculateExplicitQuantities(DeferredLogger& deferred_logger) const;
342 // some preparation work, mostly related to group control and RESV,
343 // at the beginning of each time step (Not report step)
344 void prepareTimeStep(DeferredLogger& deferred_logger);
345 void initPrimaryVariablesEvaluation() const;
346 void initPrimaryVariablesEvaluationDomain(const Domain& domain) const;
347
348 std::pair<bool, bool>
349 updateWellControls(const bool mandatory_network_balance, DeferredLogger& deferred_logger, const bool relax_network_tolerance = false);
350
351 void updateAndCommunicate(const int reportStepIdx,
352 const int iterationIdx,
353 DeferredLogger& deferred_logger);
354
355 bool updateGroupControls(const Group& group,
356 DeferredLogger& deferred_logger,
357 const int reportStepIdx,
358 const int iterationIdx);
359
360 WellInterfacePtr getWell(const std::string& well_name) const;
361 bool hasWell(const std::string& well_name) const;
362
363 using PressureMatrix = Dune::BCRSMatrix<Opm::MatrixBlock<Scalar, 1, 1>>;
364
365 void addWellPressureEquations(PressureMatrix& jacobian, const BVector& weights,const bool use_well_weights) const;
366
367 void addWellPressureEquationsDomain([[maybe_unused]] PressureMatrix& jacobian,
368 [[maybe_unused]] const BVector& weights,
369 [[maybe_unused]] const bool use_well_weights,
370 [[maybe_unused]] const int domainIndex) const;
371
372
373 void addWellPressureEquationsStruct(PressureMatrix& jacobian) const;
374
375 void initGliftEclWellMap(GLiftEclWells &ecl_well_map);
376
378 const std::vector<WellInterfacePtr>& localNonshutWells() const
379 {
380 return well_container_;
381 }
382
383 // prototype for assemble function for ASPIN solveLocal()
384 // will try to merge back to assemble() when done prototyping
385 void assembleDomain(const int iterationIdx,
386 const double dt,
387 const Domain& domain);
388 void updateWellControlsDomain(DeferredLogger& deferred_logger, const Domain& domain);
389
390 void logPrimaryVars() const;
391 std::vector<Scalar> getPrimaryVarsDomain(const Domain& domain) const;
392 void setPrimaryVarsDomain(const Domain& domain, const std::vector<Scalar>& vars);
393
394 void setupDomains(const std::vector<Domain>& domains);
395
396 protected:
397 Simulator& simulator_;
398
399 // a vector of all the wells.
400 std::vector<WellInterfacePtr> well_container_{};
401
402 std::vector<bool> is_cell_perforated_{};
403
404 void initializeWellState(const int timeStepIdx);
405
406 // create the well container
407 void createWellContainer(const int report_step) override;
408
409 WellInterfacePtr
410 createWellPointer(const int wellID,
411 const int report_step) const;
412
413 template <typename WellType>
414 std::unique_ptr<WellType>
415 createTypedWellPointer(const int wellID,
416 const int time_step) const;
417
418 WellInterfacePtr createWellForWellTest(const std::string& well_name, const int report_step, DeferredLogger& deferred_logger) const;
419
420
421 const ModelParameters param_;
422 std::size_t global_num_cells_{};
423 // the number of the cells in the local grid
424 std::size_t local_num_cells_{};
425 Scalar gravity_{};
426 std::vector<Scalar> depth_{};
427 bool alternative_well_rate_init_{};
428 std::map<std::string, Scalar> well_group_thp_calc_;
429 std::unique_ptr<RateConverterType> rateConverter_{};
430 std::map<std::string, std::unique_ptr<AverageRegionalPressureType>> regionalAveragePressureCalculator_{};
431
433 {
434 std::optional<typename std::vector<WellInterfacePtr>::size_type> openWellIdx_{};
435 std::size_t wbpCalcIdx_{};
436 };
437
438 std::vector<WBPCalcID> wbpCalcMap_{};
439
440 SimulatorReportSingle last_report_{};
441
442 // Pre-step network solve at static reservoir conditions (group and well states might be updated)
443 void doPreStepNetworkRebalance(DeferredLogger& deferred_logger);
444
445 // used to better efficiency of calcuation
446 mutable BVector scaleAddRes_{};
447
448 std::vector<Scalar> B_avg_{};
449
450 // Keep track of the domain of each well, if using subdomains.
451 std::map<std::string, int> well_domain_;
452
453 // Store the local index of the wells perforated cells in the domain, if using sumdomains
454 SparseTable<int> well_local_cells_;
455
456 const Grid& grid() const
457 { return simulator_.vanguard().grid(); }
458
459 const EquilGrid& equilGrid() const
460 { return simulator_.vanguard().equilGrid(); }
461
462 const EclipseState& eclState() const
463 { return simulator_.vanguard().eclState(); }
464
465 // compute the well fluxes and assemble them in to the reservoir equations as source terms
466 // and in the well equations.
467 void assemble(const int iterationIdx,
468 const double dt);
469
470 // well controls and network pressures affect each other and are solved in an iterative manner.
471 // the function handles one iteration of updating well controls and network pressures.
472 // it is possible to decouple the update of well controls and network pressures further.
473 // the returned two booleans are {continue_due_to_network, well_group_control_changed}, respectively
474 std::pair<bool, bool> updateWellControlsAndNetworkIteration(const bool mandatory_network_balance,
475 const bool relax_network_tolerance,
476 const double dt,
477 DeferredLogger& local_deferredLogger);
478
479 bool updateWellControlsAndNetwork(const bool mandatory_network_balance,
480 const double dt,
481 DeferredLogger& local_deferredLogger);
482
483 void computeWellGroupThp(const double dt, DeferredLogger& local_deferredLogger);
484
493 void initializeLocalWellStructure(const int reportStepIdx,
494 const bool enableWellPIScaling);
495
499 void initializeGroupStructure(const int reportStepIdx);
500
501 // called at the end of a time step
502 void timeStepSucceeded(const double simulationTime, const double dt);
503
504 // called at the end of a report step
505 void endReportStep();
506
507 // using the solution x to recover the solution xw for wells and applying
508 // xw to update Well State
509 void recoverWellSolutionAndUpdateWellState(const BVector& x);
510
511 // using the solution x to recover the solution xw for wells and applying
512 // xw to update Well State
513 void recoverWellSolutionAndUpdateWellStateDomain(const BVector& x, const Domain& domain);
514
515 // setting the well_solutions_ based on well_state.
516 void updatePrimaryVariables(DeferredLogger& deferred_logger);
517
518 void initializeWBPCalculationService();
519
520 data::WellBlockAveragePressures
521 computeWellBlockAveragePressures() const;
522
524 makeWellSourceEvaluatorFactory(const std::vector<Well>::size_type wellIdx) const;
525
526 void registerOpenWellsForWBPCalculation();
527
528 void updateAverageFormationFactor();
529
530 void computePotentials(const std::size_t widx,
531 const WellState<Scalar>& well_state_copy,
532 std::string& exc_msg,
533 ExceptionType::ExcEnum& exc_type,
534 DeferredLogger& deferred_logger) override;
535
536 const std::vector<Scalar>& wellPerfEfficiencyFactors() const;
537
538 void calculateProductivityIndexValuesShutWells(const int reportStepIdx, DeferredLogger& deferred_logger) override;
539 void calculateProductivityIndexValues(DeferredLogger& deferred_logger) override;
540 void calculateProductivityIndexValues(const WellInterface<TypeTag>* wellPtr,
541 DeferredLogger& deferred_logger);
542
543 // The number of components in the model.
544 int numComponents() const;
545
546 int reportStepIndex() const;
547
548 void assembleWellEq(const double dt, DeferredLogger& deferred_logger);
549 void assembleWellEqDomain(const double dt, const Domain& domain, DeferredLogger& deferred_logger);
550
551 void prepareWellsBeforeAssembling(const double dt, DeferredLogger& deferred_logger);
552
553 // TODO: finding a better naming
554 void assembleWellEqWithoutIteration(const double dt, DeferredLogger& deferred_logger);
555
556 bool maybeDoGasLiftOptimize(DeferredLogger& deferred_logger);
557
558 void gasLiftOptimizationStage1(DeferredLogger& deferred_logger,
559 GLiftProdWells& prod_wells,
560 GLiftOptWells& glift_wells,
561 GasLiftGroupInfo<Scalar>& group_info,
562 GLiftWellStateMap& state_map);
563
564 // cannot be const since it accesses the non-const WellState
565 void gasLiftOptimizationStage1SingleWell(WellInterface<TypeTag>* well,
566 DeferredLogger& deferred_logger,
567 GLiftProdWells& prod_wells,
568 GLiftOptWells& glift_wells,
569 GasLiftGroupInfo<Scalar>& group_info,
570 GLiftWellStateMap& state_map,
571 GLiftSyncGroups& groups_to_sync);
572
573 void extractLegacyCellPvtRegionIndex_();
574
575 void extractLegacyDepth_();
576
578 void updateWellTestState(const double& simulationTime, WellTestState& wellTestState) const;
579
580 void wellTesting(const int timeStepIdx, const double simulationTime, DeferredLogger& deferred_logger);
581
582 void calcResvCoeff(const int fipnum,
583 const int pvtreg,
584 const std::vector<Scalar>& production_rates,
585 std::vector<Scalar>& resv_coeff) override;
586
587 void calcInjResvCoeff(const int fipnum,
588 const int pvtreg,
589 std::vector<Scalar>& resv_coeff) override;
590
591 void computeWellTemperature();
592
593 int compressedIndexForInterior(int cartesian_cell_idx) const override {
594 return simulator_.vanguard().compressedIndexForInterior(cartesian_cell_idx);
595 }
596
597 private:
598 BlackoilWellModel(Simulator& simulator, const PhaseUsage& pu);
599
600 // These members are used to avoid reallocation in specific functions
601 // (e.g., apply, applyDomain) instead of using local variables.
602 // Their state is not relevant between function calls, so they can
603 // (and must) be mutable, as the functions using them are const.
604 mutable BVector x_local_;
605 mutable BVector Ax_local_;
606 mutable BVector res_local_;
607 mutable GlobalEqVector linearize_res_local_;
608 };
609
610
611} // namespace Opm
612
613#ifndef OPM_BLACKOILWELLMODEL_IMPL_HEADER_INCLUDED
614#include "BlackoilWellModel_impl.hpp"
615#endif
616
617#endif
Helper class for grid instantiation of ECL file-format using problems.
Facility for converting component rates at surface conditions to phase (voidage) rates at reservoir c...
Facility for converting component rates at surface conditions to phase (voidage) rates at reservoir c...
Base class for specifying auxiliary equations.
Base class for specifying auxiliary equations.
Definition baseauxiliarymodule.hh:56
Contains the high level supplements required to extend the black oil model by MICP.
Definition blackoilmicpmodules.hh:49
Contains the high level supplements required to extend the black oil model by polymer.
Definition blackoilpolymermodules.hh:54
Class for handling the blackoil well model.
Definition GroupEconomicLimitsChecker.hpp:35
Class for handling the blackoil well model.
Definition WellInterface.hpp:31
void initializeGroupStructure(const int reportStepIdx)
Initialize group control modes/constraints and group solution state.
Definition BlackoilWellModel_impl.hpp:394
void serialize(Restarter &)
This method writes the complete state of the well to the harddisk.
Definition BlackoilWellModel.hpp:196
const std::vector< WellInterfacePtr > & localNonshutWells() const
Get list of local nonshut wells.
Definition BlackoilWellModel.hpp:378
void postSolve(GlobalEqVector &deltaX) override
This method is called after the linear solver has been called but before the solution is updated for ...
Definition BlackoilWellModel.hpp:171
void applyInitial() override
Set the initial condition of the auxiliary module in the solution vector.
Definition BlackoilWellModel.hpp:165
unsigned numDofs() const override
Returns the number of additional degrees of freedom required for the auxiliary module.
Definition BlackoilWellModel.hpp:159
void calculateExplicitQuantities(DeferredLogger &deferred_logger) const
Calculating the explict quantities used in the well calculation.
Definition BlackoilWellModel_impl.hpp:2154
void initializeLocalWellStructure(const int reportStepIdx, const bool enableWellPIScaling)
Update rank's notion of intersecting wells and their associate solution variables.
Definition BlackoilWellModel_impl.hpp:349
void addNeighbors(std::vector< NeighborSet > &neighbors) const override
Specify the additional neighboring correlations caused by the auxiliary module.
Definition BlackoilWellModel_impl.hpp:188
void linearize(SparseMatrixAdapter &jacobian, GlobalEqVector &res) override
Linearize the auxiliary equation.
Definition BlackoilWellModel_impl.hpp:229
void updateWellTestState(const double &simulationTime, WellTestState &wellTestState) const
upate the wellTestState related to economic limits
Definition BlackoilWellModel_impl.hpp:2489
int compressedIndexForInterior(int cartesian_cell_idx) const override
get compressed index for interior cells (-1, otherwise
Definition BlackoilWellModel.hpp:593
Definition DeferredLogger.hpp:57
Definition WellInterface.hpp:30
std::function< Evaluator()> EvaluatorFactory
Callback for constructing a source term evaluation function on the current MPI rank.
Definition ParallelWBPCalculation.hpp:63
Manages the initializing and running of time dependent problems.
Definition simulator.hh:92
Vanguard & vanguard()
Return a reference to the grid manager of simulation.
Definition simulator.hh:260
This class serves to eliminate the need to include the WellContributions into the matrix (with –matri...
Definition StandardWellEval.hpp:41
This file contains a set of helper functions used by VFPProd / VFPInj.
Definition blackoilboundaryratevector.hh:37
typename Properties::Detail::GetPropImpl< TypeTag, Property >::type::type GetPropType
get the type alias defined in the property (equivalent to old macro GET_PROP_TYPE(....
Definition propertysystem.hh:235
constexpr auto getPropValue()
get the value data member of a property
Definition propertysystem.hh:242
Solver parameters for the BlackoilModel.
Definition BlackoilModelParameters.hpp:162
bool use_multisegment_well_
Whether to use MultisegmentWell to handle multisegment wells it is something temporary before the mul...
Definition BlackoilModelParameters.hpp:259
Definition BlackoilWellModel.hpp:433
Definition BlackoilWellModel.hpp:85
Definition BlackoilPhases.hpp:46
A struct for returning timing data from a simulator to its caller.
Definition SimulatorReport.hpp:34
Representing a part of a grid, in a way suitable for performing local solves.
Definition SubDomain.hpp:62