22#ifndef OPM_MULTISEGMENTWELL_IMPL_HEADER_INCLUDED
23#define OPM_MULTISEGMENTWELL_IMPL_HEADER_INCLUDED
25#ifndef OPM_MULTISEGMENTWELL_HEADER_INCLUDED
30#include <opm/common/Exceptions.hpp>
31#include <opm/common/OpmLog/OpmLog.hpp>
33#include <opm/input/eclipse/Schedule/MSW/Segment.hpp>
34#include <opm/input/eclipse/Schedule/MSW/Valve.hpp>
35#include <opm/input/eclipse/Schedule/MSW/WellSegments.hpp>
36#include <opm/input/eclipse/Schedule/Well/Connection.hpp>
37#include <opm/input/eclipse/Schedule/Well/WellConnections.hpp>
39#include <opm/input/eclipse/Units/Units.hpp>
41#include <opm/material/densead/EvaluationFormat.hpp>
52#if COMPILE_GPU_BRIDGE && (HAVE_CUDA || HAVE_OPENCL)
60 template <
typename TypeTag>
67 const int pvtRegionIdx,
68 const int num_conservation_quantities,
70 const int index_of_well,
72 :
Base(well, pw_info, time_step, param, rate_converter, pvtRegionIdx, num_conservation_quantities, num_phases, index_of_well, perf_data)
75 , segment_fluid_initial_(this->numberOfSegments(), std::vector<
Scalar>(this->num_conservation_quantities_, 0.0))
79 OPM_THROW(std::runtime_error,
"solvent is not supported by multisegment well yet");
83 OPM_THROW(std::runtime_error,
"polymer is not supported by multisegment well yet");
87 OPM_THROW(std::runtime_error,
"energy is not supported by multisegment well yet");
91 OPM_THROW(std::runtime_error,
"foam is not supported by multisegment well yet");
95 OPM_THROW(std::runtime_error,
"brine is not supported by multisegment well yet");
99 OPM_THROW(std::runtime_error,
"water evaporation is not supported by multisegment well yet");
103 OPM_THROW(std::runtime_error,
"MICP is not supported by multisegment well yet");
107 OPM_THROW(std::runtime_error,
108 "dissolved gas/ vapporized oil in injected oil/gas not supported by multisegment well yet."
109 " \n See (WCONINJE item 10 / WCONHIST item 8)");
119 template <
typename TypeTag>
122 init(
const std::vector<Scalar>& depth_arg,
124 const std::vector< Scalar >& B_avg,
125 const bool changed_to_open_this_step)
127 Base::init(depth_arg, gravity_arg, B_avg, changed_to_open_this_step);
139 this->initMatrixAndVectors();
142 for (
int local_perf_index = 0; local_perf_index < this->number_of_local_perforations_; ++local_perf_index) {
144 const int cell_idx = this->well_cells_[local_perf_index];
146 this->cell_perforation_depth_diffs_[local_perf_index] = depth_arg[cell_idx] - this->perf_depth_[this->pw_info_.localPerfToActivePerf(local_perf_index)];
154 template <
typename TypeTag>
161 const bool stop_or_zero_rate_target = this->stoppedOrZeroRateTarget(simulator, well_state, deferred_logger);
162 this->primary_variables_.update(well_state, stop_or_zero_rate_target);
170 template <
typename TypeTag>
178 Base::updateWellStateWithTarget(simulator, group_state, well_state, deferred_logger);
181 this->scaleSegmentRatesWithWellRates(this->segments_.inlets(),
182 this->segments_.perforations(),
184 this->scaleSegmentPressuresWithBhp(well_state);
191 template <
typename TypeTag>
196 const std::vector<Scalar>& B_avg,
198 const bool relax_tolerance)
const
200 return this->MSWEval::getWellConvergence(well_state,
203 this->param_.max_residual_allowed_,
204 this->param_.tolerance_wells_,
205 this->param_.relaxed_tolerance_flow_well_,
206 this->param_.tolerance_pressure_ms_wells_,
207 this->param_.relaxed_tolerance_pressure_ms_well_,
209 this->wellIsStopped());
217 template <
typename TypeTag>
222 if (!this->isOperableAndSolvable() && !this->wellIsStopped()) {
226 if (this->param_.matrix_add_well_contributions_) {
231 this->linSys_.apply(x, Ax);
238 template <
typename TypeTag>
243 if (!this->isOperableAndSolvable() && !this->wellIsStopped()) {
247 this->linSys_.apply(r);
252 template <
typename TypeTag>
260 if (!this->isOperableAndSolvable() && !this->wellIsStopped()) {
266 this->linSys_.recoverSolutionWell(x, xw);
268 updateWellState(simulator, xw, well_state, deferred_logger);
270 catch (
const NumericalProblem& exp) {
274 deferred_logger.
problem(
"In MultisegmentWell::recoverWellSolutionAndUpdateWellState for well "
275 + this->name() +
": "+exp.what());
284 template <
typename TypeTag>
289 std::vector<Scalar>& well_potentials,
292 const auto [compute_potential, bhp_controlled_well] =
295 if (!compute_potential) {
299 debug_cost_counter_ = 0;
300 bool converged_implicit =
false;
301 if (this->param_.local_well_solver_control_switching_) {
302 converged_implicit = computeWellPotentialsImplicit(simulator, well_state, well_potentials, deferred_logger);
303 if (!converged_implicit) {
304 deferred_logger.
debug(
"Implicit potential calculations failed for well "
305 + this->name() +
", reverting to original aproach.");
308 if (!converged_implicit) {
310 const auto& summaryState = simulator.vanguard().summaryState();
311 if (!Base::wellHasTHPConstraints(summaryState) || bhp_controlled_well) {
312 computeWellRatesAtBhpLimit(simulator, well_potentials, deferred_logger);
314 well_potentials = computeWellPotentialWithTHP(
315 well_state, simulator, deferred_logger);
318 deferred_logger.
debug(
"Cost in iterations of finding well potential for well "
321 this->checkNegativeWellPotentials(well_potentials,
322 this->param_.check_well_operability_,
329 template<
typename TypeTag>
333 std::vector<Scalar>& well_flux,
336 if (this->well_ecl_.isInjector()) {
337 const auto controls = this->well_ecl_.injectionControls(simulator.vanguard().summaryState());
338 computeWellRatesWithBhpIterations(simulator, controls.bhp_limit, well_flux, deferred_logger);
340 const auto controls = this->well_ecl_.productionControls(simulator.vanguard().summaryState());
341 computeWellRatesWithBhpIterations(simulator, controls.bhp_limit, well_flux, deferred_logger);
345 template<
typename TypeTag>
350 std::vector<Scalar>& well_flux,
353 const int np = this->number_of_phases_;
355 well_flux.resize(np, 0.0);
356 const bool allow_cf = this->getAllowCrossFlow();
357 const int nseg = this->numberOfSegments();
358 const WellStateType& well_state = simulator.problem().wellModel().wellState();
359 const auto& ws = well_state.
well(this->indexOfWell());
360 auto segments_copy = ws.segments;
361 segments_copy.scale_pressure(bhp);
362 const auto& segment_pressure = segments_copy.pressure;
363 for (
int seg = 0; seg < nseg; ++seg) {
364 for (
const int perf : this->segments_.perforations()[seg]) {
365 const int local_perf_index = this->pw_info_.activePerfToLocalPerf(perf);
366 if (local_perf_index < 0)
368 const int cell_idx = this->well_cells_[local_perf_index];
369 const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, 0);
371 std::vector<Scalar> mob(this->num_conservation_quantities_, 0.);
372 getMobility(simulator, local_perf_index, mob, deferred_logger);
373 const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(intQuants, cell_idx);
374 const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
375 const std::vector<Scalar> Tw = this->wellIndex(local_perf_index, intQuants, trans_mult, wellstate_nupcol);
376 const Scalar seg_pressure = segment_pressure[seg];
377 std::vector<Scalar> cq_s(this->num_conservation_quantities_, 0.);
380 computePerfRate(intQuants, mob, Tw, seg, perf, seg_pressure,
381 allow_cf, cq_s, perf_press, perf_rates, deferred_logger);
383 for(
int p = 0; p < np; ++p) {
384 well_flux[FluidSystem::activeCompToActivePhaseIdx(p)] += cq_s[p];
388 this->parallel_well_info_.communication().sum(well_flux.data(), well_flux.size());
392 template<
typename TypeTag>
397 std::vector<Scalar>& well_flux,
409 WellStateType well_state_copy = simulator.problem().wellModel().wellState();
410 const auto& group_state = simulator.problem().wellModel().groupState();
411 auto& ws = well_state_copy.
well(this->index_of_well_);
414 const auto& summary_state = simulator.vanguard().summaryState();
415 auto inj_controls = well_copy.
well_ecl_.isInjector()
416 ? well_copy.
well_ecl_.injectionControls(summary_state)
417 : Well::InjectionControls(0);
418 auto prod_controls = well_copy.
well_ecl_.isProducer()
419 ? well_copy.
well_ecl_.productionControls(summary_state) :
420 Well::ProductionControls(0);
424 inj_controls.bhp_limit = bhp;
425 ws.injection_cmode = Well::InjectorCMode::BHP;
427 prod_controls.bhp_limit = bhp;
428 ws.production_cmode = Well::ProducerCMode::BHP;
434 const int np = this->number_of_phases_;
436 for (
int phase = 0; phase < np; ++phase){
437 trivial = trivial && (ws.well_potentials[phase] == 0.0) ;
441 for (
int phase = 0; phase < np; ++phase) {
442 ws.surface_rates[phase] = sign * ws.well_potentials[phase];
446 this->segments_.perforations(),
450 const double dt = simulator.timeStepSize();
457 well_flux.resize(np, 0.0);
458 for (
int compIdx = 0; compIdx < this->num_conservation_quantities_; ++compIdx) {
460 well_flux[FluidSystem::activeCompToActivePhaseIdx(compIdx)] = rate.value();
467 template<
typename TypeTag>
468 std::vector<typename MultisegmentWell<TypeTag>::Scalar>
474 std::vector<Scalar> potentials(this->number_of_phases_, 0.0);
475 const auto& summary_state = simulator.vanguard().summaryState();
477 const auto& well = this->well_ecl_;
478 if (well.isInjector()) {
479 auto bhp_at_thp_limit = computeBhpAtThpLimitInj(simulator, summary_state, deferred_logger);
480 if (bhp_at_thp_limit) {
481 const auto& controls = well.injectionControls(summary_state);
482 const Scalar bhp = std::min(*bhp_at_thp_limit,
483 static_cast<Scalar>(controls.bhp_limit));
484 computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
485 deferred_logger.
debug(
"Converged thp based potential calculation for well "
488 deferred_logger.
warning(
"FAILURE_GETTING_CONVERGED_POTENTIAL",
489 "Failed in getting converged thp based potential calculation for well "
490 + this->name() +
". Instead the bhp based value is used");
491 const auto& controls = well.injectionControls(summary_state);
492 const Scalar bhp = controls.bhp_limit;
493 computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
496 auto bhp_at_thp_limit = computeBhpAtThpLimitProd(
497 well_state, simulator, summary_state, deferred_logger);
498 if (bhp_at_thp_limit) {
499 const auto& controls = well.productionControls(summary_state);
500 const Scalar bhp = std::max(*bhp_at_thp_limit,
501 static_cast<Scalar>(controls.bhp_limit));
502 computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
503 deferred_logger.
debug(
"Converged thp based potential calculation for well "
506 deferred_logger.
warning(
"FAILURE_GETTING_CONVERGED_POTENTIAL",
507 "Failed in getting converged thp based potential calculation for well "
508 + this->name() +
". Instead the bhp based value is used");
509 const auto& controls = well.productionControls(summary_state);
510 const Scalar bhp = controls.bhp_limit;
511 computeWellRatesWithBhpIterations(simulator, bhp, potentials, deferred_logger);
518 template<
typename TypeTag>
523 std::vector<Scalar>& well_potentials,
534 const auto& group_state = simulator.problem().wellModel().groupState();
535 auto& ws = well_state_copy.
well(this->index_of_well_);
538 const auto& summary_state = simulator.vanguard().summaryState();
539 auto inj_controls = well_copy.
well_ecl_.isInjector()
540 ? well_copy.
well_ecl_.injectionControls(summary_state)
541 : Well::InjectionControls(0);
542 auto prod_controls = well_copy.
well_ecl_.isProducer()
543 ? well_copy.
well_ecl_.productionControls(summary_state)
544 : Well::ProductionControls(0);
552 const int np = this->number_of_phases_;
554 for (
int phase = 0; phase < np; ++phase){
555 trivial = trivial && (ws.well_potentials[phase] == 0.0) ;
559 for (
int phase = 0; phase < np; ++phase) {
560 ws.surface_rates[phase] = sign * ws.well_potentials[phase];
564 this->segments_.perforations(),
568 const double dt = simulator.timeStepSize();
570 bool converged =
false;
571 if (this->well_ecl_.isProducer()) {
572 converged = well_copy.
solveWellWithOperabilityCheck(simulator, dt, inj_controls, prod_controls, well_state_copy, group_state, deferred_logger);
574 converged = well_copy.
iterateWellEqWithSwitching(simulator, dt, inj_controls, prod_controls, well_state_copy, group_state, deferred_logger);
578 well_potentials.clear();
579 well_potentials.resize(np, 0.0);
580 for (
int compIdx = 0; compIdx < this->num_conservation_quantities_; ++compIdx) {
582 well_potentials[FluidSystem::activeCompToActivePhaseIdx(compIdx)] = rate.value();
588 template <
typename TypeTag>
595 if (!this->isOperableAndSolvable() && !this->wellIsStopped())
return;
600 const BVectorWell dx_well = this->linSys_.solve();
601 updateWellState(simulator, dx_well, well_state, deferred_logger);
603 catch(
const NumericalProblem& exp) {
607 deferred_logger.
problem(
"In MultisegmentWell::solveEqAndUpdateWellState for well "
608 + this->name() +
": "+exp.what());
617 template <
typename TypeTag>
624 for (
int local_perf_index = 0; local_perf_index < this->number_of_local_perforations_; ++local_perf_index) {
627 std::vector<Scalar> kr(this->number_of_phases_, 0.0);
628 std::vector<Scalar> density(this->number_of_phases_, 0.0);
630 const int cell_idx = this->well_cells_[local_perf_index];
631 const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, 0);
632 const auto& fs = intQuants.fluidState();
636 if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)) {
637 const int water_pos = FluidSystem::canonicalToActivePhaseIdx(FluidSystem::waterPhaseIdx);
638 kr[water_pos] = intQuants.relativePermeability(FluidSystem::waterPhaseIdx).value();
639 sum_kr += kr[water_pos];
640 density[water_pos] = fs.density(FluidSystem::waterPhaseIdx).value();
643 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)) {
644 const int oil_pos = FluidSystem::canonicalToActivePhaseIdx(FluidSystem::oilPhaseIdx);
645 kr[oil_pos] = intQuants.relativePermeability(FluidSystem::oilPhaseIdx).value();
646 sum_kr += kr[oil_pos];
647 density[oil_pos] = fs.density(FluidSystem::oilPhaseIdx).value();
650 if (FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
651 const int gas_pos = FluidSystem::canonicalToActivePhaseIdx(FluidSystem::gasPhaseIdx);
652 kr[gas_pos] = intQuants.relativePermeability(FluidSystem::gasPhaseIdx).value();
653 sum_kr += kr[gas_pos];
654 density[gas_pos] = fs.density(FluidSystem::gasPhaseIdx).value();
657 assert(sum_kr != 0.);
660 Scalar average_density = 0.;
661 for (
int p = 0; p < this->number_of_phases_; ++p) {
662 average_density += kr[p] * density[p];
664 average_density /= sum_kr;
666 this->cell_perforation_pressure_diffs_[local_perf_index] = this->gravity_ * average_density * this->cell_perforation_depth_diffs_[local_perf_index];
674 template <
typename TypeTag>
679 for (
int seg = 0; seg < this->numberOfSegments(); ++seg) {
681 const Scalar surface_volume = getSegmentSurfaceVolume(simulator, seg).value();
682 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx) {
683 segment_fluid_initial_[seg][comp_idx] = surface_volume * this->primary_variables_.surfaceVolumeFraction(seg, comp_idx).value();
692 template <
typename TypeTag>
696 const BVectorWell& dwells,
699 const Scalar relaxation_factor)
701 if (!this->isOperableAndSolvable() && !this->wellIsStopped())
return;
703 const Scalar dFLimit = this->param_.dwell_fraction_max_;
704 const Scalar max_pressure_change = this->param_.max_pressure_change_ms_wells_;
705 const bool stop_or_zero_rate_target =
706 this->stoppedOrZeroRateTarget(simulator, well_state, deferred_logger);
707 this->primary_variables_.updateNewton(dwells,
710 stop_or_zero_rate_target,
711 max_pressure_change);
713 const auto& summary_state = simulator.vanguard().summaryState();
714 this->primary_variables_.copyToWellState(*
this, getRefDensity(),
720 auto& ws = well_state.
well(this->index_of_well_);
721 this->segments_.copyPhaseDensities(ws.segments);
724 Base::calculateReservoirRates(simulator.vanguard().eclState().runspec().co2Storage(), well_state.
well(this->index_of_well_));
731 template <
typename TypeTag>
738 updatePrimaryVariables(simulator, well_state, deferred_logger);
739 computePerfCellPressDiffs(simulator);
740 computeInitialSegmentFluids(simulator);
747 template<
typename TypeTag>
755 auto fluidState = [&simulator,
this](
const int local_perf_index)
757 const auto cell_idx = this->well_cells_[local_perf_index];
758 return simulator.model()
759 .intensiveQuantities(cell_idx, 0).fluidState();
762 const int np = this->number_of_phases_;
763 auto setToZero = [np](
Scalar* x) ->
void
765 std::fill_n(x, np, 0.0);
768 auto addVector = [np](
const Scalar* src,
Scalar* dest) ->
void
770 std::transform(src, src + np, dest, dest, std::plus<>{});
773 auto& ws = well_state.
well(this->index_of_well_);
774 auto& perf_data = ws.perf_data;
775 auto* connPI = perf_data.prod_index.data();
776 auto* wellPI = ws.productivity_index.data();
780 const auto preferred_phase = this->well_ecl_.getPreferredPhase();
781 auto subsetPerfID = 0;
783 for (
const auto& perf : *this->perf_data_){
784 auto allPerfID = perf.ecl_index;
786 auto connPICalc = [&wellPICalc, allPerfID](
const Scalar mobility) ->
Scalar
791 std::vector<Scalar> mob(this->num_conservation_quantities_, 0.0);
796 getMobility(simulator,
static_cast<int>(subsetPerfID), mob, deferred_logger);
798 const auto& fs = fluidState(subsetPerfID);
801 if (this->isInjector()) {
802 this->computeConnLevelInjInd(fs, preferred_phase, connPICalc,
803 mob, connPI, deferred_logger);
806 this->computeConnLevelProdInd(fs, connPICalc, mob, connPI);
809 addVector(connPI, wellPI);
816 const auto& comm = this->parallel_well_info_.communication();
817 if (comm.size() > 1) {
818 comm.sum(wellPI, np);
821 assert (
static_cast<int>(subsetPerfID) == this->number_of_local_perforations_ &&
822 "Internal logic error in processing connections for PI/II");
829 template<
typename TypeTag>
833 [[maybe_unused]]
const int openConnIdx)
const
838 const auto segNum = this->wellEcl()
839 .getConnections()[globalConnIdx].segment();
841 const auto segIdx = this->wellEcl()
842 .getSegments().segmentNumberToIndex(segNum);
844 return this->segments_.density(segIdx).value();
851 template<
typename TypeTag>
856 if (this->number_of_local_perforations_ == 0) {
860 this->linSys_.extract(jacobian);
864 template<
typename TypeTag>
869 const int pressureVarIndex,
870 const bool use_well_weights,
873 if (this->number_of_local_perforations_ == 0) {
878 this->linSys_.extractCPRPressureMatrix(jacobian,
888 template<
typename TypeTag>
889 template<
class Value>
895 const std::vector<Value>& b_perfcells,
896 const std::vector<Value>& mob_perfcells,
897 const std::vector<Scalar>& Tw,
899 const Value& segment_pressure,
900 const Value& segment_density,
901 const bool& allow_cf,
902 const std::vector<Value>& cmix_s,
903 std::vector<Value>& cq_s,
908 const int local_perf_index = this->pw_info_.activePerfToLocalPerf(perf);
909 if (local_perf_index < 0)
913 const Value perf_seg_press_diff = this->gravity() * segment_density *
914 this->segments_.local_perforation_depth_diff(local_perf_index);
916 const Scalar cell_perf_press_diff = this->cell_perforation_pressure_diffs_[local_perf_index];
920 perf_press = segment_pressure + perf_seg_press_diff;
923 const Value cell_press_at_perf = pressure_cell - cell_perf_press_diff;
926 const Value drawdown = cell_press_at_perf - perf_press;
929 if (drawdown > 0.0) {
931 if (!allow_cf && this->isInjector()) {
936 for (
int comp_idx = 0; comp_idx < this->numConservationQuantities(); ++comp_idx) {
937 const Value cq_p = - Tw[comp_idx] * (mob_perfcells[comp_idx] * drawdown);
938 cq_s[comp_idx] = b_perfcells[comp_idx] * cq_p;
941 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
942 const unsigned oilCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::oilCompIdx);
943 const unsigned gasCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::gasCompIdx);
944 const Value cq_s_oil = cq_s[oilCompIdx];
945 const Value cq_s_gas = cq_s[gasCompIdx];
946 cq_s[gasCompIdx] += rs * cq_s_oil;
947 cq_s[oilCompIdx] += rv * cq_s_gas;
951 if (!allow_cf && this->isProducer()) {
956 Value total_mob = mob_perfcells[0];
957 for (
int comp_idx = 1; comp_idx < this->numConservationQuantities(); ++comp_idx) {
958 total_mob += mob_perfcells[comp_idx];
962 Value volume_ratio = 0.0;
963 if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)) {
964 const unsigned waterCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::waterCompIdx);
965 volume_ratio += cmix_s[waterCompIdx] / b_perfcells[waterCompIdx];
968 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
969 const unsigned oilCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::oilCompIdx);
970 const unsigned gasCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::gasCompIdx);
975 const Value d = 1.0 - rv * rs;
977 if (getValue(d) == 0.0) {
979 fmt::format(
"Zero d value obtained for well {} "
980 "during flux calculation with rs {} and rv {}",
981 this->name(), rs, rv),
985 const Value tmp_oil = (cmix_s[oilCompIdx] - rv * cmix_s[gasCompIdx]) / d;
986 volume_ratio += tmp_oil / b_perfcells[oilCompIdx];
988 const Value tmp_gas = (cmix_s[gasCompIdx] - rs * cmix_s[oilCompIdx]) / d;
989 volume_ratio += tmp_gas / b_perfcells[gasCompIdx];
991 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)) {
992 const unsigned oilCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::oilCompIdx);
993 volume_ratio += cmix_s[oilCompIdx] / b_perfcells[oilCompIdx];
995 if (FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
996 const unsigned gasCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::gasCompIdx);
997 volume_ratio += cmix_s[gasCompIdx] / b_perfcells[gasCompIdx];
1001 for (
int componentIdx = 0; componentIdx < this->numConservationQuantities(); ++componentIdx) {
1002 const Value cqt_i = - Tw[componentIdx] * (total_mob * drawdown);
1003 Value cqt_is = cqt_i / volume_ratio;
1004 cq_s[componentIdx] = cmix_s[componentIdx] * cqt_is;
1009 if (this->isProducer()) {
1010 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
1011 const unsigned oilCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::oilCompIdx);
1012 const unsigned gasCompIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::gasCompIdx);
1021 const Scalar d = 1.0 - getValue(rv) * getValue(rs);
1024 perf_rates.
vap_oil = getValue(rv) * (getValue(cq_s[gasCompIdx]) - getValue(rs) * getValue(cq_s[oilCompIdx])) / d;
1027 perf_rates.
dis_gas = getValue(rs) * (getValue(cq_s[oilCompIdx]) - getValue(rv) * getValue(cq_s[gasCompIdx])) / d;
1032 template <
typename TypeTag>
1033 template<
class Value>
1037 const std::vector<Value>& mob_perfcells,
1038 const std::vector<Scalar>& Tw,
1041 const Value& segment_pressure,
1042 const bool& allow_cf,
1043 std::vector<Value>& cq_s,
1049 auto obtain = [
this](
const Eval& value)
1051 if constexpr (std::is_same_v<Value, Scalar>) {
1052 static_cast<void>(
this);
1053 return getValue(value);
1055 return this->extendEval(value);
1058 auto obtainN = [](
const auto& value)
1060 if constexpr (std::is_same_v<Value, Scalar>) {
1061 return getValue(value);
1066 const auto& fs = int_quants.fluidState();
1068 const Value pressure_cell = obtain(this->getPerfCellPressure(fs));
1069 const Value rs = obtain(fs.Rs());
1070 const Value rv = obtain(fs.Rv());
1073 std::vector<Value> b_perfcells(this->num_conservation_quantities_, 0.0);
1075 for (
unsigned phaseIdx = 0; phaseIdx < FluidSystem::numPhases; ++phaseIdx) {
1076 if (!FluidSystem::phaseIsActive(phaseIdx)) {
1080 const unsigned compIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::solventComponentIndex(phaseIdx));
1081 b_perfcells[compIdx] = obtain(fs.invB(phaseIdx));
1084 std::vector<Value> cmix_s(this->numConservationQuantities(), 0.0);
1085 for (
int comp_idx = 0; comp_idx < this->numConservationQuantities(); ++comp_idx) {
1086 cmix_s[comp_idx] = obtainN(this->primary_variables_.surfaceVolumeFraction(seg, comp_idx));
1089 this->computePerfRate(pressure_cell,
1097 obtainN(this->segments_.density(seg)),
1106 template <
typename TypeTag>
1126 auto info = this->getFirstPerforationFluidStateInfo(simulator);
1127 temperature.setValue(std::get<0>(info));
1128 saltConcentration = this->extendEval(std::get<1>(info));
1130 this->segments_.computeFluidProperties(temperature,
1132 this->primary_variables_,
1137 template <
typename TypeTag>
1138 template<
class Value>
1142 const int local_perf_index,
1143 std::vector<Value>& mob,
1146 auto obtain = [
this](
const Eval& value)
1148 if constexpr (std::is_same_v<Value, Scalar>) {
1149 static_cast<void>(
this);
1150 return getValue(value);
1152 return this->extendEval(value);
1159 const auto perf_ecl_index = this->perforationData()[local_perf_index].ecl_index;
1160 const Connection& con = this->well_ecl_.getConnections()[perf_ecl_index];
1161 const int seg = this->segmentNumberToIndex(con.segment());
1165 const Scalar segment_pres = this->primary_variables_.getSegmentPressure(seg).value();
1166 const Scalar perf_seg_press_diff = this->gravity() * this->segments_.density(seg).value()
1167 * this->segments_.local_perforation_depth_diff(local_perf_index);
1168 const Scalar perf_press = segment_pres + perf_seg_press_diff;
1169 const Scalar multiplier = this->getInjMult(local_perf_index, segment_pres, perf_press, deferred_logger);
1170 for (std::size_t i = 0; i < mob.size(); ++i) {
1171 mob[i] *= multiplier;
1178 template<
typename TypeTag>
1183 return this->segments_.getRefDensity();
1186 template<
typename TypeTag>
1193 const auto& summaryState = simulator.vanguard().summaryState();
1197 const bool bhp_limit_not_defaulted = bhp_limit > 1.5 * unit::barsa;
1198 if ( bhp_limit_not_defaulted || !this->wellHasTHPConstraints(summaryState) ) {
1201 Scalar total_ipr_mass_rate = 0.0;
1202 for (
unsigned phaseIdx = 0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
1204 if (!FluidSystem::phaseIsActive(phaseIdx)) {
1208 const unsigned compIdx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::solventComponentIndex(phaseIdx));
1209 const Scalar ipr_rate = this->ipr_a_[compIdx] - this->ipr_b_[compIdx] * bhp_limit;
1211 const Scalar rho = FluidSystem::referenceDensity( phaseIdx, Base::pvtRegionIdx() );
1212 total_ipr_mass_rate += ipr_rate * rho;
1214 if ( (this->isProducer() && total_ipr_mass_rate < 0.) || (this->isInjector() && total_ipr_mass_rate > 0.) ) {
1215 this->operability_status_.operable_under_only_bhp_limit =
false;
1219 if (this->operability_status_.operable_under_only_bhp_limit && this->wellHasTHPConstraints(summaryState)) {
1223 std::vector<Scalar> well_rates_bhp_limit;
1224 computeWellRatesWithBhp(simulator, bhp_limit, well_rates_bhp_limit, deferred_logger);
1226 const Scalar thp_limit = this->getTHPConstraint(summaryState);
1229 this->getRefDensity(),
1230 this->wellEcl().alq_value(summaryState),
1233 if ( (this->isProducer() && thp < thp_limit) || (this->isInjector() && thp > thp_limit) ) {
1234 this->operability_status_.obey_thp_limit_under_bhp_limit =
false;
1245 this->operability_status_.operable_under_only_bhp_limit =
true;
1246 this->operability_status_.obey_thp_limit_under_bhp_limit =
false;
1252 template<
typename TypeTag>
1260 std::fill(this->ipr_a_.begin(), this->ipr_a_.end(), 0.);
1261 std::fill(this->ipr_b_.begin(), this->ipr_b_.end(), 0.);
1263 const int nseg = this->numberOfSegments();
1264 std::vector<Scalar> seg_dp(nseg, 0.0);
1265 for (
int seg = 0; seg < nseg; ++seg) {
1267 const Scalar dp = this->getSegmentDp(seg,
1268 this->segments_.density(seg).value(),
1271 for (
const int perf : this->segments_.perforations()[seg]) {
1272 const int local_perf_index = this->pw_info_.activePerfToLocalPerf(perf);
1273 if (local_perf_index < 0)
1275 std::vector<Scalar> mob(this->num_conservation_quantities_, 0.0);
1278 getMobility(simulator, local_perf_index, mob, deferred_logger);
1280 const int cell_idx = this->well_cells_[local_perf_index];
1281 const auto& int_quantities = simulator.model().intensiveQuantities(cell_idx, 0);
1282 const auto& fs = int_quantities.fluidState();
1284 const Scalar perf_seg_press_diff = this->segments_.getPressureDiffSegLocalPerf(seg, local_perf_index);
1286 const Scalar cell_perf_press_diff = this->cell_perforation_pressure_diffs_[local_perf_index];
1287 const Scalar pressure_cell = this->getPerfCellPressure(fs).value();
1290 std::vector<Scalar> b_perf(this->num_conservation_quantities_);
1291 for (std::size_t phase = 0; phase < FluidSystem::numPhases; ++phase) {
1292 if (!FluidSystem::phaseIsActive(phase)) {
1295 const unsigned comp_idx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::solventComponentIndex(phase));
1296 b_perf[comp_idx] = fs.invB(phase).value();
1300 const Scalar h_perf = cell_perf_press_diff + perf_seg_press_diff + dp;
1301 const Scalar pressure_diff = pressure_cell - h_perf;
1304 if ( (this->isProducer() && pressure_diff < 0.) || (this->isInjector() && pressure_diff > 0.) ) {
1305 deferred_logger.
debug(
"CROSSFLOW_IPR",
1306 "cross flow found when updateIPR for well " + this->name());
1310 const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(int_quantities, cell_idx);
1311 const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
1312 const std::vector<Scalar> tw_perf = this->wellIndex(local_perf_index, int_quantities, trans_mult, wellstate_nupcol);
1313 std::vector<Scalar> ipr_a_perf(this->ipr_a_.size());
1314 std::vector<Scalar> ipr_b_perf(this->ipr_b_.size());
1315 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx) {
1316 const Scalar tw_mob = tw_perf[comp_idx] * mob[comp_idx] * b_perf[comp_idx];
1317 ipr_a_perf[comp_idx] += tw_mob * pressure_diff;
1318 ipr_b_perf[comp_idx] += tw_mob;
1322 if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
1323 const unsigned oil_comp_idx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::oilCompIdx);
1324 const unsigned gas_comp_idx = FluidSystem::canonicalToActiveCompIdx(FluidSystem::gasCompIdx);
1325 const Scalar rs = (fs.Rs()).value();
1326 const Scalar rv = (fs.Rv()).value();
1328 const Scalar dis_gas_a = rs * ipr_a_perf[oil_comp_idx];
1329 const Scalar vap_oil_a = rv * ipr_a_perf[gas_comp_idx];
1331 ipr_a_perf[gas_comp_idx] += dis_gas_a;
1332 ipr_a_perf[oil_comp_idx] += vap_oil_a;
1334 const Scalar dis_gas_b = rs * ipr_b_perf[oil_comp_idx];
1335 const Scalar vap_oil_b = rv * ipr_b_perf[gas_comp_idx];
1337 ipr_b_perf[gas_comp_idx] += dis_gas_b;
1338 ipr_b_perf[oil_comp_idx] += vap_oil_b;
1341 for (std::size_t comp_idx = 0; comp_idx < ipr_a_perf.size(); ++comp_idx) {
1342 this->ipr_a_[comp_idx] += ipr_a_perf[comp_idx];
1343 this->ipr_b_[comp_idx] += ipr_b_perf[comp_idx];
1347 this->parallel_well_info_.communication().sum(this->ipr_a_.data(), this->ipr_a_.size());
1348 this->parallel_well_info_.communication().sum(this->ipr_b_.data(), this->ipr_b_.size());
1351 template<
typename TypeTag>
1365 auto rates = well_state.
well(this->index_of_well_).surface_rates;
1367 for (std::size_t p = 0; p < rates.size(); ++p) {
1368 zero_rates &= rates[p] == 0.0;
1370 auto& ws = well_state.
well(this->index_of_well_);
1372 const auto msg = fmt::format(
"updateIPRImplicit: Well {} has zero rate, IPRs might be problematic", this->name());
1373 deferred_logger.
debug(msg);
1385 const auto& group_state = simulator.problem().wellModel().groupState();
1387 std::fill(ws.implicit_ipr_a.begin(), ws.implicit_ipr_a.end(), 0.);
1388 std::fill(ws.implicit_ipr_b.begin(), ws.implicit_ipr_b.end(), 0.);
1390 auto inj_controls = Well::InjectionControls(0);
1391 auto prod_controls = Well::ProductionControls(0);
1392 prod_controls.addControl(Well::ProducerCMode::BHP);
1393 prod_controls.bhp_limit = well_state.
well(this->index_of_well_).bhp;
1396 const auto cmode = ws.production_cmode;
1397 ws.production_cmode = Well::ProducerCMode::BHP;
1398 const double dt = simulator.timeStepSize();
1399 assembleWellEqWithoutIteration(simulator, dt, inj_controls, prod_controls, well_state, group_state, deferred_logger);
1401 BVectorWell rhs(this->numberOfSegments());
1403 rhs[0][SPres] = -1.0;
1405 const BVectorWell x_well = this->linSys_.solve(rhs);
1406 constexpr int num_eq = MSWEval::numWellEq;
1407 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx){
1408 const EvalWell comp_rate = this->primary_variables_.getQs(comp_idx);
1409 const int idx = FluidSystem::activeCompToActivePhaseIdx(comp_idx);
1410 for (
size_t pvIdx = 0; pvIdx < num_eq; ++pvIdx) {
1412 ws.implicit_ipr_b[idx] -= x_well[0][pvIdx]*comp_rate.derivative(pvIdx+Indices::numEq);
1414 ws.implicit_ipr_a[idx] = ws.implicit_ipr_b[idx]*ws.bhp - comp_rate.value();
1417 ws.production_cmode = cmode;
1420 template<
typename TypeTag>
1427 const auto& summaryState = simulator.vanguard().summaryState();
1428 const auto obtain_bhp = this->isProducer()
1429 ? computeBhpAtThpLimitProd(
1430 well_state, simulator, summaryState, deferred_logger)
1431 : computeBhpAtThpLimitInj(simulator, summaryState, deferred_logger);
1434 this->operability_status_.can_obtain_bhp_with_thp_limit =
true;
1437 this->operability_status_.obey_bhp_limit_with_thp_limit = (*obtain_bhp >= bhp_limit);
1439 const Scalar thp_limit = this->getTHPConstraint(summaryState);
1440 if (this->isProducer() && *obtain_bhp < thp_limit) {
1441 const std::string msg =
" obtained bhp " +
std::to_string(unit::convert::to(*obtain_bhp, unit::barsa))
1442 +
" bars is SMALLER than thp limit "
1444 +
" bars as a producer for well " + this->name();
1445 deferred_logger.
debug(msg);
1447 else if (this->isInjector() && *obtain_bhp > thp_limit) {
1448 const std::string msg =
" obtained bhp " +
std::to_string(unit::convert::to(*obtain_bhp, unit::barsa))
1449 +
" bars is LARGER than thp limit "
1451 +
" bars as a injector for well " + this->name();
1452 deferred_logger.
debug(msg);
1457 this->operability_status_.can_obtain_bhp_with_thp_limit =
false;
1458 this->operability_status_.obey_bhp_limit_with_thp_limit =
false;
1459 if (!this->wellIsStopped()) {
1460 const Scalar thp_limit = this->getTHPConstraint(summaryState);
1461 deferred_logger.
debug(
" could not find bhp value at thp limit "
1463 +
" bar for well " + this->name() +
", the well might need to be closed ");
1472 template<
typename TypeTag>
1477 const Well::InjectionControls& inj_controls,
1478 const Well::ProductionControls& prod_controls,
1483 if (!this->isOperableAndSolvable() && !this->wellIsStopped())
return true;
1485 const int max_iter_number = this->param_.max_inner_iter_ms_wells_;
1489 const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
1494 updatePrimaryVariables(simulator, well_state, deferred_logger);
1496 std::vector<std::vector<Scalar> > residual_history;
1497 std::vector<Scalar> measure_history;
1500 Scalar relaxation_factor = 1.;
1501 bool converged =
false;
1502 bool relax_convergence =
false;
1503 this->regularize_ =
false;
1504 for (; it < max_iter_number; ++it, ++debug_cost_counter_) {
1506 if (it > this->param_.strict_inner_iter_wells_) {
1507 relax_convergence =
true;
1508 this->regularize_ =
true;
1511 assembleWellEqWithoutIteration(simulator, dt, inj_controls, prod_controls,
1512 well_state, group_state, deferred_logger);
1514 const auto report = getWellConvergence(simulator, well_state, Base::B_avg_, deferred_logger, relax_convergence);
1515 if (report.converged()) {
1522 const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
1526 residual_history.push_back(residuals);
1527 measure_history.push_back(this->getResidualMeasureValue(well_state,
1528 residual_history[it],
1529 this->param_.tolerance_wells_,
1530 this->param_.tolerance_pressure_ms_wells_,
1533 bool min_relaxation_reached = this->update_relaxation_factor(measure_history, relaxation_factor, this->regularize_, deferred_logger);
1534 if (min_relaxation_reached || this->repeatedStagnation(measure_history, this->regularize_, deferred_logger)) {
1536 const auto reportStag = getWellConvergence(simulator, well_state, Base::B_avg_, deferred_logger,
true);
1537 if (reportStag.converged()) {
1539 std::string message = fmt::format(
"Well stagnates/oscillates but {} manages to get converged with relaxed tolerances in {} inner iterations."
1541 deferred_logger.
debug(message);
1548 BVectorWell dx_well;
1550 dx_well = this->linSys_.solve();
1551 updateWellState(simulator, dx_well, well_state, deferred_logger, relaxation_factor);
1553 catch(
const NumericalProblem& exp) {
1557 deferred_logger.
problem(
"In MultisegmentWell::iterateWellEqWithControl for well "
1558 + this->name() +
": "+exp.what());
1565 std::ostringstream sstr;
1566 sstr <<
" Well " << this->name() <<
" converged in " << it <<
" inner iterations.";
1567 if (relax_convergence)
1568 sstr <<
" (A relaxed tolerance was used after "<< this->param_.strict_inner_iter_wells_ <<
" iterations)";
1572 deferred_logger.
debug(sstr.str(), OpmLog::defaultDebugVerbosityLevel + (it == 0));
1574 std::ostringstream sstr;
1575 sstr <<
" Well " << this->name() <<
" did not converge in " << it <<
" inner iterations.";
1576#define EXTRA_DEBUG_MSW 0
1578 sstr <<
"***** Outputting the residual history for well " << this->name() <<
" during inner iterations:";
1579 for (
int i = 0; i < it; ++i) {
1580 const auto& residual = residual_history[i];
1581 sstr <<
" residual at " << i <<
"th iteration ";
1582 for (
const auto& res : residual) {
1585 sstr <<
" " << measure_history[i] <<
" \n";
1588#undef EXTRA_DEBUG_MSW
1589 deferred_logger.
debug(sstr.str());
1596 template<
typename TypeTag>
1601 const Well::InjectionControls& inj_controls,
1602 const Well::ProductionControls& prod_controls,
1606 const bool fixed_control ,
1607 const bool fixed_status )
1609 const int max_iter_number = this->param_.max_inner_iter_ms_wells_;
1613 const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
1618 updatePrimaryVariables(simulator, well_state, deferred_logger);
1620 std::vector<std::vector<Scalar> > residual_history;
1621 std::vector<Scalar> measure_history;
1624 Scalar relaxation_factor = 1.;
1625 bool converged =
false;
1626 bool relax_convergence =
false;
1627 this->regularize_ =
false;
1628 const auto& summary_state = simulator.vanguard().summaryState();
1633 const int min_its_after_switch = 3;
1635 const int max_status_switch = this->param_.max_well_status_switch_;
1636 int its_since_last_switch = min_its_after_switch;
1637 int switch_count= 0;
1638 int status_switch_count = 0;
1640 const auto well_status_orig = this->wellStatus_;
1641 const auto operability_orig = this->operability_status_;
1642 auto well_status_cur = well_status_orig;
1644 const bool allow_open = well_state.
well(this->index_of_well_).status == WellStatus::OPEN;
1646 const bool allow_switching = !this->wellUnderZeroRateTarget(simulator, well_state, deferred_logger) &&
1647 (!fixed_control || !fixed_status) && allow_open;
1648 bool final_check =
false;
1650 this->operability_status_.resetOperability();
1651 this->operability_status_.solvable =
true;
1653 for (; it < max_iter_number; ++it, ++debug_cost_counter_) {
1654 ++its_since_last_switch;
1655 if (allow_switching && its_since_last_switch >= min_its_after_switch && status_switch_count < max_status_switch){
1656 const Scalar wqTotal = this->primary_variables_.getWQTotal().value();
1657 bool changed = this->updateWellControlAndStatusLocalIteration(simulator, well_state, group_state,
1658 inj_controls, prod_controls, wqTotal,
1659 deferred_logger, fixed_control,
1662 its_since_last_switch = 0;
1664 if (well_status_cur != this->wellStatus_) {
1665 well_status_cur = this->wellStatus_;
1666 status_switch_count++;
1669 if (!changed && final_check) {
1672 final_check =
false;
1674 if (status_switch_count == max_status_switch) {
1675 this->wellStatus_ = well_status_orig;
1679 if (it > this->param_.strict_inner_iter_wells_) {
1680 relax_convergence =
true;
1681 this->regularize_ =
true;
1684 assembleWellEqWithoutIteration(simulator, dt, inj_controls, prod_controls,
1685 well_state, group_state, deferred_logger);
1688 const auto report = getWellConvergence(simulator, well_state, Base::B_avg_, deferred_logger, relax_convergence);
1689 converged = report.converged();
1690 if (this->parallel_well_info_.communication().size() > 1 &&
1691 this->parallel_well_info_.communication().max(converged) != this->parallel_well_info_.communication().min(converged)) {
1692 OPM_THROW(std::runtime_error, fmt::format(
"Misalignment of the parallel simulation run in iterateWellEqWithSwitching - the well calculation for well {} succeeded some ranks but failed on other ranks.", this->name()));
1697 if (switch_count > 0 && its_since_last_switch < min_its_after_switch) {
1699 its_since_last_switch = min_its_after_switch;
1707 const auto& [isFinite, residuals] = this->getFiniteWellResiduals(Base::B_avg_, deferred_logger);
1711 residual_history.push_back(residuals);
1715 measure_history.push_back(this->getResidualMeasureValue(well_state,
1716 residual_history[it],
1717 this->param_.tolerance_wells_,
1718 this->param_.tolerance_pressure_ms_wells_,
1720 bool min_relaxation_reached = this->update_relaxation_factor(measure_history, relaxation_factor, this->regularize_, deferred_logger);
1721 if (min_relaxation_reached || this->repeatedStagnation(measure_history, this->regularize_, deferred_logger)) {
1727 const BVectorWell dx_well = this->linSys_.solve();
1728 updateWellState(simulator, dx_well, well_state, deferred_logger, relaxation_factor);
1730 catch(
const NumericalProblem& exp) {
1734 deferred_logger.
problem(
"In MultisegmentWell::iterateWellEqWithSwitching for well "
1735 + this->name() +
": "+exp.what());
1741 if (allow_switching){
1743 const bool is_stopped = this->wellIsStopped();
1744 if (this->wellHasTHPConstraints(summary_state)){
1745 this->operability_status_.can_obtain_bhp_with_thp_limit = !is_stopped;
1746 this->operability_status_.obey_thp_limit_under_bhp_limit = !is_stopped;
1748 this->operability_status_.operable_under_only_bhp_limit = !is_stopped;
1751 std::string message = fmt::format(
" Well {} converged in {} inner iterations ("
1752 "{} control/status switches).", this->name(), it, switch_count);
1753 if (relax_convergence) {
1754 message.append(fmt::format(
" (A relaxed tolerance was used after {} iterations)",
1755 this->param_.strict_inner_iter_wells_));
1757 deferred_logger.
debug(message, OpmLog::defaultDebugVerbosityLevel + ((it == 0) && (switch_count == 0)));
1759 this->wellStatus_ = well_status_orig;
1760 this->operability_status_ = operability_orig;
1761 const std::string message = fmt::format(
" Well {} did not converge in {} inner iterations ("
1762 "{} switches, {} status changes).", this->name(), it, switch_count, status_switch_count);
1763 deferred_logger.
debug(message);
1764 this->primary_variables_.outputLowLimitPressureSegments(deferred_logger);
1771 template<
typename TypeTag>
1776 const Well::InjectionControls& inj_controls,
1777 const Well::ProductionControls& prod_controls,
1782 if (!this->isOperableAndSolvable() && !this->wellIsStopped())
return;
1785 this->segments_.updateUpwindingSegments(this->primary_variables_);
1788 computeSegmentFluidProperties(simulator, deferred_logger);
1791 this->linSys_.clear();
1793 auto& ws = well_state.
well(this->index_of_well_);
1794 ws.phase_mixing_rates.fill(0.0);
1801 const bool allow_cf = this->getAllowCrossFlow() || openCrossFlowAvoidSingularity(simulator);
1803 const int nseg = this->numberOfSegments();
1805 const Scalar rhow = FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx) ?
1806 FluidSystem::referenceDensity( FluidSystem::waterPhaseIdx, Base::pvtRegionIdx() ) : 0.0;
1807 const unsigned watCompIdx = FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx) ?
1808 FluidSystem::canonicalToActiveCompIdx(FluidSystem::waterCompIdx) : 0;
1810 for (
int seg = 0; seg < nseg; ++seg) {
1812 const EvalWell seg_pressure = this->primary_variables_.getSegmentPressure(seg);
1813 auto& perf_data = ws.perf_data;
1814 auto& perf_rates = perf_data.phase_rates;
1815 auto& perf_press_state = perf_data.pressure;
1816 for (
const int perf : this->segments_.perforations()[seg]) {
1817 const int local_perf_index = this->pw_info_.activePerfToLocalPerf(perf);
1818 if (local_perf_index < 0)
1820 const int cell_idx = this->well_cells_[local_perf_index];
1821 const auto& int_quants = simulator.model().intensiveQuantities(cell_idx, 0);
1822 std::vector<EvalWell> mob(this->num_conservation_quantities_, 0.0);
1823 getMobility(simulator, local_perf_index, mob, deferred_logger);
1824 const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(int_quants, cell_idx);
1825 const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
1826 const std::vector<Scalar> Tw = this->wellIndex(local_perf_index, int_quants, trans_mult, wellstate_nupcol);
1827 std::vector<EvalWell> cq_s(this->num_conservation_quantities_, 0.0);
1830 computePerfRate(int_quants, mob, Tw, seg, perf, seg_pressure,
1831 allow_cf, cq_s, perf_press, perfRates, deferred_logger);
1834 if (this->isProducer()) {
1835 ws.phase_mixing_rates[ws.dissolved_gas] += perfRates.
dis_gas;
1836 ws.phase_mixing_rates[ws.vaporized_oil] += perfRates.
vap_oil;
1837 perf_data.phase_mixing_rates[local_perf_index][ws.dissolved_gas] = perfRates.
dis_gas;
1838 perf_data.phase_mixing_rates[local_perf_index][ws.vaporized_oil] = perfRates.
vap_oil;
1842 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx) {
1843 perf_rates[local_perf_index*this->number_of_phases_ + FluidSystem::activeCompToActivePhaseIdx(comp_idx)] = cq_s[comp_idx].value();
1845 perf_press_state[local_perf_index] = perf_press.value();
1848 if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)) {
1849 perf_data.wat_mass_rates[local_perf_index] = cq_s[watCompIdx].value() * rhow;
1852 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx) {
1854 const EvalWell cq_s_effective = cq_s[comp_idx] * this->well_efficiency_factor_;
1856 this->connectionRates_[local_perf_index][comp_idx] = Base::restrictEval(cq_s_effective);
1859 assemblePerforationEq(seg, local_perf_index, comp_idx, cq_s_effective, this->linSys_);
1865 const auto& comm = this->parallel_well_info_.communication();
1866 comm.sum(ws.phase_mixing_rates.data(), ws.phase_mixing_rates.size());
1869 if (this->parallel_well_info_.communication().size() > 1) {
1871 this->linSys_.sumDistributed(this->parallel_well_info_.communication());
1873 for (
int seg = 0; seg < nseg; ++seg) {
1877 const EvalWell segment_surface_volume = getSegmentSurfaceVolume(simulator, seg);
1882 const Scalar regularization_factor = this->regularize_? this->param_.regularization_factor_wells_ : 1.0;
1884 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx) {
1885 const EvalWell accumulation_term = regularization_factor * (segment_surface_volume * this->primary_variables_.surfaceVolumeFraction(seg, comp_idx)
1886 - segment_fluid_initial_[seg][comp_idx]) / dt;
1888 assembleAccumulationTerm(seg, comp_idx, accumulation_term, this->linSys_);
1893 const int seg_upwind = this->segments_.upwinding_segment(seg);
1894 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx) {
1896 this->primary_variables_.getSegmentRateUpwinding(seg,
1899 this->well_efficiency_factor_;
1901 assembleOutflowTerm(seg, seg_upwind, comp_idx, segment_rate, this->linSys_);
1907 for (
const int inlet : this->segments_.inlets()[seg]) {
1908 const int inlet_upwind = this->segments_.upwinding_segment(inlet);
1909 for (
int comp_idx = 0; comp_idx < this->num_conservation_quantities_; ++comp_idx) {
1911 this->primary_variables_.getSegmentRateUpwinding(inlet,
1914 this->well_efficiency_factor_;
1916 assembleInflowTerm(seg, inlet, inlet_upwind, comp_idx, inlet_rate, this->linSys_);
1923 const auto& summaryState = simulator.vanguard().summaryState();
1924 const Schedule& schedule = simulator.vanguard().schedule();
1925 const bool stopped_or_zero_target = this->stoppedOrZeroRateTarget(simulator, well_state, deferred_logger);
1927 assembleControlEq(well_state,
1934 this->primary_variables_,
1936 stopped_or_zero_target,
1939 const UnitSystem& unit_system = simulator.vanguard().eclState().getDeckUnitSystem();
1940 const auto& summary_state = simulator.vanguard().summaryState();
1941 this->assemblePressureEq(seg, unit_system, well_state, summary_state, this->param_.use_average_density_ms_wells_, deferred_logger);
1945 this->parallel_well_info_.communication().sum(this->ipr_a_.data(), this->ipr_a_.size());
1946 this->linSys_.createSolver();
1952 template<
typename TypeTag>
1957 return !this->getAllowCrossFlow() && allDrawDownWrongDirection(simulator);
1961 template<
typename TypeTag>
1966 bool all_drawdown_wrong_direction =
true;
1967 const int nseg = this->numberOfSegments();
1969 for (
int seg = 0; seg < nseg; ++seg) {
1970 const EvalWell segment_pressure = this->primary_variables_.getSegmentPressure(seg);
1971 for (
const int perf : this->segments_.perforations()[seg]) {
1972 const int local_perf_index = this->pw_info_.activePerfToLocalPerf(perf);
1973 if (local_perf_index < 0)
1976 const int cell_idx = this->well_cells_[local_perf_index];
1977 const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, 0);
1978 const auto& fs = intQuants.fluidState();
1981 const EvalWell perf_seg_press_diff = this->segments_.getPressureDiffSegLocalPerf(seg, local_perf_index);
1983 const Scalar cell_perf_press_diff = this->cell_perforation_pressure_diffs_[local_perf_index];
1985 const Scalar pressure_cell = this->getPerfCellPressure(fs).value();
1986 const Scalar perf_press = pressure_cell - cell_perf_press_diff;
1989 const EvalWell drawdown = perf_press - (segment_pressure + perf_seg_press_diff);
1994 if ( (drawdown < 0. && this->isInjector()) ||
1995 (drawdown > 0. && this->isProducer()) ) {
1996 all_drawdown_wrong_direction =
false;
2001 const auto& comm = this->parallel_well_info_.communication();
2002 if (comm.size() > 1)
2004 all_drawdown_wrong_direction =
2005 (comm.min(all_drawdown_wrong_direction ? 1 : 0) == 1);
2008 return all_drawdown_wrong_direction;
2014 template<
typename TypeTag>
2025 template<
typename TypeTag>
2033 auto info = this->getFirstPerforationFluidStateInfo(simulator);
2034 temperature.setValue(std::get<0>(info));
2035 saltConcentration = this->extendEval(std::get<1>(info));
2037 return this->segments_.getSurfaceVolume(temperature,
2039 this->primary_variables_,
2045 template<
typename TypeTag>
2046 std::optional<typename MultisegmentWell<TypeTag>::Scalar>
2050 const SummaryState& summary_state,
2056 this->getALQ(well_state),
2063 template<
typename TypeTag>
2064 std::optional<typename MultisegmentWell<TypeTag>::Scalar>
2067 const SummaryState& summary_state,
2070 bool iterate_if_no_solution)
const
2074 auto frates = [
this, &simulator, &deferred_logger](
const Scalar bhp) {
2080 std::vector<Scalar> rates(3);
2081 computeWellRatesWithBhp(simulator, bhp, rates, deferred_logger);
2086 computeBhpAtThpLimitProd(frates,
2088 this->maxPerfPress(simulator),
2089 this->getRefDensity(),
2091 this->getTHPConstraint(summary_state),
2097 if (!iterate_if_no_solution)
2098 return std::nullopt;
2100 auto fratesIter = [
this, &simulator, &deferred_logger](
const Scalar bhp) {
2104 std::vector<Scalar> rates(3);
2105 computeWellRatesWithBhpIterations(simulator, bhp, rates, deferred_logger);
2110 computeBhpAtThpLimitProd(fratesIter,
2112 this->maxPerfPress(simulator),
2113 this->getRefDensity(),
2115 this->getTHPConstraint(summary_state),
2119 template<
typename TypeTag>
2120 std::optional<typename MultisegmentWell<TypeTag>::Scalar>
2123 const SummaryState& summary_state,
2127 auto frates = [
this, &simulator, &deferred_logger](
const Scalar bhp) {
2133 std::vector<Scalar> rates(3);
2134 computeWellRatesWithBhp(simulator, bhp, rates, deferred_logger);
2139 computeBhpAtThpLimitInj(frates,
2141 this->getRefDensity(),
2150 auto fratesIter = [
this, &simulator, &deferred_logger](
const Scalar bhp) {
2154 std::vector<Scalar> rates(3);
2155 computeWellRatesWithBhpIterations(simulator, bhp, rates, deferred_logger);
2160 computeBhpAtThpLimitInj(fratesIter,
2162 this->getRefDensity(),
2173 template<
typename TypeTag>
2178 Scalar max_pressure = 0.0;
2179 const int nseg = this->numberOfSegments();
2180 for (
int seg = 0; seg < nseg; ++seg) {
2181 for (
const int perf : this->segments_.perforations()[seg]) {
2182 const int local_perf_index = this->pw_info_.activePerfToLocalPerf(perf);
2183 if (local_perf_index < 0)
2186 const int cell_idx = this->well_cells_[local_perf_index];
2187 const auto& int_quants = simulator.model().intensiveQuantities(cell_idx, 0);
2188 const auto& fs = int_quants.fluidState();
2189 Scalar pressure_cell = this->getPerfCellPressure(fs).value();
2190 max_pressure = std::max(max_pressure, pressure_cell);
2193 max_pressure = this->parallel_well_info_.communication().max(max_pressure);
2194 return max_pressure;
2201 template<
typename TypeTag>
2202 std::vector<typename MultisegmentWell<TypeTag>::Scalar>
2208 std::vector<Scalar> well_q_s(this->num_conservation_quantities_, 0.0);
2209 const bool allow_cf = this->getAllowCrossFlow() || openCrossFlowAvoidSingularity(simulator);
2210 const int nseg = this->numberOfSegments();
2211 for (
int seg = 0; seg < nseg; ++seg) {
2213 const Scalar seg_pressure = getValue(this->primary_variables_.getSegmentPressure(seg));
2214 for (
const int perf : this->segments_.perforations()[seg]) {
2215 const int local_perf_index = this->pw_info_.activePerfToLocalPerf(perf);
2216 if (local_perf_index < 0)
2219 const int cell_idx = this->well_cells_[local_perf_index];
2220 const auto& int_quants = simulator.model().intensiveQuantities(cell_idx, 0);
2221 std::vector<Scalar> mob(this->num_conservation_quantities_, 0.0);
2222 getMobility(simulator, local_perf_index, mob, deferred_logger);
2223 const Scalar trans_mult = simulator.problem().template wellTransMultiplier<Scalar>(int_quants, cell_idx);
2224 const auto& wellstate_nupcol = simulator.problem().wellModel().nupcolWellState().well(this->index_of_well_);
2225 const std::vector<Scalar> Tw = this->wellIndex(local_perf_index, int_quants, trans_mult, wellstate_nupcol);
2226 std::vector<Scalar> cq_s(this->num_conservation_quantities_, 0.0);
2229 computePerfRate(int_quants, mob, Tw, seg, perf, seg_pressure,
2230 allow_cf, cq_s, perf_press, perf_rates, deferred_logger);
2231 for (
int comp = 0; comp < this->num_conservation_quantities_; ++comp) {
2232 well_q_s[comp] += cq_s[comp];
2236 const auto& comm = this->parallel_well_info_.communication();
2237 if (comm.size() > 1)
2239 comm.sum(well_q_s.data(), well_q_s.size());
2245 template <
typename TypeTag>
2246 std::vector<typename MultisegmentWell<TypeTag>::Scalar>
2250 const int num_seg = this->numberOfSegments();
2251 constexpr int num_eq = MSWEval::numWellEq;
2252 std::vector<Scalar> retval(num_seg * num_eq);
2253 for (
int ii = 0; ii < num_seg; ++ii) {
2254 const auto& pv = this->primary_variables_.value(ii);
2255 std::copy(pv.begin(), pv.end(), retval.begin() + ii * num_eq);
2263 template <
typename TypeTag>
2268 const int num_seg = this->numberOfSegments();
2269 constexpr int num_eq = MSWEval::numWellEq;
2270 std::array<Scalar, num_eq> tmp;
2271 for (
int ii = 0; ii < num_seg; ++ii) {
2272 const auto start = it + ii * num_eq;
2273 std::copy(start, start + num_eq, tmp.begin());
2274 this->primary_variables_.setValue(ii, tmp);
2276 return num_seg * num_eq;
2279 template <
typename TypeTag>
2283 Scalar fsTemperature = 0.0;
2284 using SaltConcType =
typename std::decay<
decltype(std::declval<
decltype(simulator.model().intensiveQuantities(0, 0).fluidState())>().saltConcentration())>::type;
2285 SaltConcType fsSaltConcentration{};
2286 int pvt_region_index = 0;
2289 if (this->well_cells_.size() > 0) {
2292 const int cell_idx = this->well_cells_[0];
2293 const auto& intQuants = simulator.model().intensiveQuantities(cell_idx, 0);
2294 const auto& fs = intQuants.fluidState();
2296 fsTemperature = fs.temperature(FluidSystem::oilPhaseIdx).value();
2297 fsSaltConcentration = fs.saltConcentration();
2298 pvt_region_index = fs.pvtRegionIndex();
2301 auto info = std::make_tuple(fsTemperature, fsSaltConcentration, pvt_region_index);
2305 return this->parallel_well_info_.communication().size() == 1 ? info : this->pw_info_.broadcastFirstPerforationValue(info);
#define OPM_DEFLOG_PROBLEM(Exception, message, deferred_logger)
Definition: DeferredLoggingErrorHelpers.hpp:61
Definition: ConvergenceReport.hpp:38
Definition: DeferredLogger.hpp:57
void warning(const std::string &tag, const std::string &message)
void problem(const std::string &tag, const std::string &message)
void debug(const std::string &tag, const std::string &message)
Definition: GroupState.hpp:41
Class handling assemble of the equation system for MultisegmentWell.
Definition: MultisegmentWellAssemble.hpp:44
typename PrimaryVariables::EvalWell EvalWell
Definition: MultisegmentWellEval.hpp:66
PrimaryVariables primary_variables_
The primary variables.
Definition: MultisegmentWellEval.hpp:143
void scaleSegmentRatesWithWellRates(const std::vector< std::vector< int > > &segment_inlets, const std::vector< std::vector< int > > &segment_perforations, WellState< Scalar, IndexTraits > &well_state) const
void scaleSegmentPressuresWithBhp(WellState< Scalar, IndexTraits > &well_state) const
Definition: MultisegmentWell.hpp:38
bool computeWellPotentialsImplicit(const Simulator &simulator, const WellStateType &well_state, std::vector< Scalar > &well_potentials, DeferredLogger &deferred_logger) const
Definition: MultisegmentWell_impl.hpp:521
void updateWellState(const Simulator &simulator, const BVectorWell &dwells, WellStateType &well_state, DeferredLogger &deferred_logger, const Scalar relaxation_factor=1.0)
Definition: MultisegmentWell_impl.hpp:695
void updateWaterThroughput(const double dt, WellStateType &well_state) const override
Definition: MultisegmentWell_impl.hpp:2017
void addWellPressureEquations(PressureMatrix &mat, const BVector &x, const int pressureVarIndex, const bool use_well_weights, const WellStateType &well_state) const override
Definition: MultisegmentWell_impl.hpp:867
std::optional< Scalar > computeBhpAtThpLimitProdWithAlq(const Simulator &simulator, const SummaryState &summary_state, const Scalar alq_value, DeferredLogger &deferred_logger, bool iterate_if_no_solution) const override
Definition: MultisegmentWell_impl.hpp:2066
Scalar connectionDensity(const int globalConnIdx, const int openConnIdx) const override
Definition: MultisegmentWell_impl.hpp:832
void addWellContributions(SparseMatrixAdapter &jacobian) const override
Definition: MultisegmentWell_impl.hpp:854
bool iterateWellEqWithSwitching(const Simulator &simulator, const double dt, const Well::InjectionControls &inj_controls, const Well::ProductionControls &prod_controls, WellStateType &well_state, const GroupState< Scalar > &group_state, DeferredLogger &deferred_logger, const bool fixed_control=false, const bool fixed_status=false) override
Definition: MultisegmentWell_impl.hpp:1599
void solveEqAndUpdateWellState(const Simulator &simulator, WellStateType &well_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:591
Scalar getRefDensity() const override
Definition: MultisegmentWell_impl.hpp:1181
std::vector< Scalar > getPrimaryVars() const override
Definition: MultisegmentWell_impl.hpp:2248
void computeWellRatesWithBhpIterations(const Simulator &simulator, const Scalar &bhp, std::vector< Scalar > &well_flux, DeferredLogger &deferred_logger) const override
Definition: MultisegmentWell_impl.hpp:395
std::vector< Scalar > computeCurrentWellRates(const Simulator &simulator, DeferredLogger &deferred_logger) const override
Definition: MultisegmentWell_impl.hpp:2204
void apply(const BVector &x, BVector &Ax) const override
Ax = Ax - C D^-1 B x.
Definition: MultisegmentWell_impl.hpp:220
MultisegmentWell(const Well &well, const ParallelWellInfo< Scalar > &pw_info, const int time_step, const ModelParameters ¶m, const RateConverterType &rate_converter, const int pvtRegionIdx, const int num_conservation_quantities, const int num_phases, const int index_of_well, const std::vector< PerforationData< Scalar > > &perf_data)
Definition: MultisegmentWell_impl.hpp:62
GetPropType< TypeTag, Properties::Scalar > Scalar
Definition: WellInterface.hpp:82
void checkOperabilityUnderBHPLimit(const WellStateType &well_state, const Simulator &ebos_simulator, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:1189
void getMobility(const Simulator &simulator, const int local_perf_index, std::vector< Value > &mob, DeferredLogger &deferred_logger) const
Definition: MultisegmentWell_impl.hpp:1141
void computePerfRate(const IntensiveQuantities &int_quants, const std::vector< Value > &mob_perfcells, const std::vector< Scalar > &Tw, const int seg, const int perf, const Value &segment_pressure, const bool &allow_cf, std::vector< Value > &cq_s, Value &perf_press, PerforationRates< Scalar > &perf_rates, DeferredLogger &deferred_logger) const
Definition: MultisegmentWell_impl.hpp:1036
void updateIPRImplicit(const Simulator &simulator, WellStateType &well_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:1354
std::optional< Scalar > computeBhpAtThpLimitProd(const WellStateType &well_state, const Simulator &ebos_simulator, const SummaryState &summary_state, DeferredLogger &deferred_logger) const
Definition: MultisegmentWell_impl.hpp:2048
bool openCrossFlowAvoidSingularity(const Simulator &simulator) const
Definition: MultisegmentWell_impl.hpp:1955
void computeSegmentFluidProperties(const Simulator &simulator, DeferredLogger &deferred_logger)
Definition: MultisegmentWell_impl.hpp:1109
void checkOperabilityUnderTHPLimit(const Simulator &ebos_simulator, const WellStateType &well_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:1423
bool iterateWellEqWithControl(const Simulator &simulator, const double dt, const Well::InjectionControls &inj_controls, const Well::ProductionControls &prod_controls, WellStateType &well_state, const GroupState< Scalar > &group_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:1475
int setPrimaryVars(typename std::vector< Scalar >::const_iterator it) override
Definition: MultisegmentWell_impl.hpp:2266
void computeWellRatesWithBhp(const Simulator &simulator, const Scalar &bhp, std::vector< Scalar > &well_flux, DeferredLogger &deferred_logger) const override
Definition: MultisegmentWell_impl.hpp:348
EvalWell getSegmentSurfaceVolume(const Simulator &simulator, const int seg_idx) const
Definition: MultisegmentWell_impl.hpp:2028
bool allDrawDownWrongDirection(const Simulator &simulator) const
Definition: MultisegmentWell_impl.hpp:1964
int debug_cost_counter_
Definition: MultisegmentWell.hpp:176
ConvergenceReport getWellConvergence(const Simulator &simulator, const WellStateType &well_state, const std::vector< Scalar > &B_avg, DeferredLogger &deferred_logger, const bool relax_tolerance) const override
check whether the well equations get converged for this well
Definition: MultisegmentWell_impl.hpp:194
void updateProductivityIndex(const Simulator &simulator, const WellProdIndexCalculator< Scalar > &wellPICalc, WellStateType &well_state, DeferredLogger &deferred_logger) const override
Definition: MultisegmentWell_impl.hpp:750
static constexpr bool has_polymer
Definition: WellInterface.hpp:113
static constexpr bool has_solvent
Definition: WellInterface.hpp:111
void computePerfCellPressDiffs(const Simulator &simulator)
Definition: MultisegmentWell_impl.hpp:620
void computeWellPotentials(const Simulator &simulator, const WellStateType &well_state, std::vector< Scalar > &well_potentials, DeferredLogger &deferred_logger) override
computing the well potentials for group control
Definition: MultisegmentWell_impl.hpp:287
void recoverWellSolutionAndUpdateWellState(const Simulator &simulator, const BVector &x, WellStateType &well_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:255
void updateWellStateWithTarget(const Simulator &simulator, const GroupState< Scalar > &group_state, WellStateType &well_state, DeferredLogger &deferred_logger) const override
updating the well state based the current control mode
Definition: MultisegmentWell_impl.hpp:173
void updateIPR(const Simulator &ebos_simulator, DeferredLogger &deferred_logger) const override
Definition: MultisegmentWell_impl.hpp:1255
std::tuple< Scalar, typename std::decay< decltype(std::declval< decltype(std::declval< const Simulator & >().model().intensiveQuantities(0, 0).fluidState())>().saltConcentration())>::type, int > FSInfo
Definition: MultisegmentWell.hpp:73
FSInfo getFirstPerforationFluidStateInfo(const Simulator &simulator) const
Definition: MultisegmentWell_impl.hpp:2281
void computeWellRatesAtBhpLimit(const Simulator &simulator, std::vector< Scalar > &well_flux, DeferredLogger &deferred_logger) const
Definition: MultisegmentWell_impl.hpp:332
void init(const std::vector< Scalar > &depth_arg, const Scalar gravity_arg, const std::vector< Scalar > &B_avg, const bool changed_to_open_this_step) override
Definition: MultisegmentWell_impl.hpp:122
void assembleWellEqWithoutIteration(const Simulator &simulator, const double dt, const Well::InjectionControls &inj_controls, const Well::ProductionControls &prod_controls, WellStateType &well_state, const GroupState< Scalar > &group_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:1774
Scalar maxPerfPress(const Simulator &simulator) const
Definition: MultisegmentWell_impl.hpp:2176
void updatePrimaryVariables(const Simulator &simulator, const WellStateType &well_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:157
std::optional< Scalar > computeBhpAtThpLimitInj(const Simulator &ebos_simulator, const SummaryState &summary_state, DeferredLogger &deferred_logger) const
Definition: MultisegmentWell_impl.hpp:2122
void calculateExplicitQuantities(const Simulator &simulator, const WellStateType &well_state, DeferredLogger &deferred_logger) override
Definition: MultisegmentWell_impl.hpp:734
std::vector< Scalar > computeWellPotentialWithTHP(const WellStateType &well_state, const Simulator &simulator, DeferredLogger &deferred_logger) const
Definition: MultisegmentWell_impl.hpp:470
void computeInitialSegmentFluids(const Simulator &simulator)
Definition: MultisegmentWell_impl.hpp:677
EvalWell getQs(const int comp_idx) const
Returns scaled rate for a component.
Class encapsulating some information about parallel wells.
Definition: ParallelWellInfo.hpp:198
Class for computing BHP limits.
Definition: WellBhpThpCalculator.hpp:41
Scalar calculateThpFromBhp(const std::vector< Scalar > &rates, const Scalar bhp, const Scalar rho, const std::optional< Scalar > &alq, const Scalar thp_limit, DeferredLogger &deferred_logger) const
Calculates THP from BHP.
Scalar mostStrictBhpFromBhpLimits(const SummaryState &summaryState) const
Obtain the most strict BHP from BHP limits.
Well well_ecl_
Definition: WellInterfaceGeneric.hpp:300
FluidSystem::Scalar rsRvInj() const
void resetDampening()
Definition: WellInterfaceGeneric.hpp:243
std::pair< bool, bool > computeWellPotentials(std::vector< Scalar > &well_potentials, const WellStateType &well_state)
void prepareForPotentialCalculations(const SummaryState &summary_state, WellStateType &well_state, Well::InjectionControls &inj_controls, Well::ProductionControls &prod_controls) const
Definition: WellInterfaceIndices.hpp:34
Definition: WellInterface.hpp:76
static constexpr bool has_brine
Definition: WellInterface.hpp:119
GetPropType< TypeTag, Properties::Simulator > Simulator
Definition: WellInterface.hpp:81
typename WellInterfaceFluidSystem< FluidSystem >::RateConverterType RateConverterType
Definition: WellInterface.hpp:103
Dune::BCRSMatrix< Opm::MatrixBlock< Scalar, 1, 1 > > PressureMatrix
Definition: WellInterface.hpp:97
void getMobility(const Simulator &simulator, const int local_perf_index, std::vector< Value > &mob, Callback &extendEval, DeferredLogger &deferred_logger) const
Definition: WellInterface_impl.hpp:1899
GetPropType< TypeTag, Properties::IntensiveQuantities > IntensiveQuantities
Definition: WellInterface.hpp:86
GetPropType< TypeTag, Properties::Scalar > Scalar
Definition: WellInterface.hpp:82
static constexpr bool has_watVapor
Definition: WellInterface.hpp:120
Dune::BlockVector< VectorBlockType > BVector
Definition: WellInterface.hpp:96
typename Base::ModelParameters ModelParameters
Definition: WellInterface.hpp:109
GetPropType< TypeTag, Properties::FluidSystem > FluidSystem
Definition: WellInterface.hpp:83
static constexpr bool has_foam
Definition: WellInterface.hpp:118
static constexpr bool has_micp
Definition: WellInterface.hpp:123
typename Base::Eval Eval
Definition: WellInterface.hpp:95
static constexpr bool has_energy
Definition: WellInterface.hpp:114
bool solveWellWithOperabilityCheck(const Simulator &simulator, const double dt, const Well::InjectionControls &inj_controls, const Well::ProductionControls &prod_controls, WellStateType &well_state, const GroupState< Scalar > &group_state, DeferredLogger &deferred_logger)
Definition: WellInterface_impl.hpp:563
GetPropType< TypeTag, Properties::Indices > Indices
Definition: WellInterface.hpp:85
bool thp_update_iterations
Definition: WellInterface.hpp:370
GetPropType< TypeTag, Properties::SparseMatrixAdapter > SparseMatrixAdapter
Definition: WellInterface.hpp:88
Definition: WellProdIndexCalculator.hpp:37
Scalar connectionProdIndStandard(const std::size_t connIdx, const Scalar connMobility) const
Definition: WellState.hpp:66
const SingleWellState< Scalar, IndexTraits > & well(std::size_t well_index) const
Definition: WellState.hpp:289
@ NONE
Definition: DeferredLogger.hpp:46
Definition: blackoilboundaryratevector.hh:39
std::string to_string(const ConvergenceReport::ReservoirFailure::Type t)
Static data associated with a well perforation.
Definition: PerforationData.hpp:30
Definition: PerforationData.hpp:41
Scalar dis_gas
Definition: PerforationData.hpp:42
Scalar vap_oil
Definition: PerforationData.hpp:44