My Project
Loading...
Searching...
No Matches
Well.hpp
1/*
2 Copyright 2019 Equinor ASA.
3
4 This file is part of the Open Porous Media project (OPM).
5
6 OPM is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
10
11 OPM is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with OPM. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20
21#ifndef WELL2_HPP
22#define WELL2_HPP
23
24#include <cstddef>
25#include <iosfwd>
26#include <map>
27#include <memory>
28#include <optional>
29#include <string>
30#include <utility>
31#include <vector>
32
33#include <opm/input/eclipse/Deck/UDAValue.hpp>
34#include <opm/input/eclipse/EclipseState/Phase.hpp>
35#include <opm/input/eclipse/Schedule/ScheduleTypes.hpp>
36#include <opm/input/eclipse/Schedule/VFPProdTable.hpp>
37#include <opm/input/eclipse/Schedule/Well/Connection.hpp>
38#include <opm/input/eclipse/Schedule/Well/PAvg.hpp>
39#include <opm/input/eclipse/Schedule/Well/WellEnums.hpp>
40#include <opm/input/eclipse/Schedule/Well/WellInjectionControls.hpp>
41#include <opm/input/eclipse/Schedule/Well/WellProductionControls.hpp>
42#include <opm/input/eclipse/Schedule/Well/WINJMULT.hpp>
43#include <opm/input/eclipse/Units/UnitSystem.hpp>
44
45namespace Opm {
46
47class ActiveGridCells;
48class AutoICD;
49class DeckKeyword;
50class DeckRecord;
51class ErrorGuard;
52class EclipseGrid;
53class KeywordLocation;
54class ParseContext;
55class ScheduleGrid;
56class SICD;
57class SummaryState;
58class UDQActive;
59class UDQConfig;
60class Valve;
61class TracerConfig;
62class WellConnections;
63struct WellBrineProperties;
64class WellEconProductionLimits;
65struct WellFoamProperties;
66struct WellMICPProperties;
67struct WellPolymerProperties;
68class WellSegments;
69class WellTracerProperties;
70class WVFPEXP;
71class WVFPDP;
72class WDFAC;
73
74namespace RestartIO {
75struct RstWell;
76}
77
78class Well {
79public:
80 using Status = WellStatus;
81
82 /*
83 * The mode for the keyword WINJMULT. It can have four different values: WREV, CREV, CIRR and NONE.
84 */
85 using InjMultMode = InjMult::InjMultMode;
86
87 /*
88 The elements in this enum are used as bitmasks to keep track
89 of which controls are present, i.e. the 2^n structure must
90 be intact.
91 */
92 using InjectorCMode = WellInjectorCMode;
93
94 /*
95 The properties are initialized with the CMODE_UNDEFINED
96 value, but the undefined value is never assigned apart from
97 that; and it is not part of the string conversion routines.
98 */
99 using ProducerCMode = WellProducerCMode;
100
101 using WELTARGCMode = WellWELTARGCMode;
102
103 using GuideRateTarget = WellGuideRateTarget;
104
105 using GasInflowEquation = WellGasInflowEquation;
106
107 void flag_lgr_well();
108 void set_lgr_well_tag(const std::string& lgr_tag_name);
109 bool is_lgr_well() const;
110 std::optional<std::string> get_lgr_well_tag() const;
112 bool available;
113 double guide_rate;
114 GuideRateTarget guide_phase;
115 double scale_factor;
116
117 static WellGuideRate serializationTestObject()
118 {
119 WellGuideRate result;
120 result.available = true;
121 result.guide_rate = 1.0;
122 result.guide_phase = GuideRateTarget::COMB;
123 result.scale_factor = 2.0;
124
125 return result;
126 }
127
128 bool operator==(const WellGuideRate& data) const {
129 return available == data.available &&
130 guide_rate == data.guide_rate &&
131 guide_phase == data.guide_phase &&
132 scale_factor == data.scale_factor;
133 }
134
135 template<class Serializer>
136 void serializeOp(Serializer& serializer)
137 {
138 serializer(available);
139 serializer(guide_rate);
140 serializer(guide_phase);
141 serializer(scale_factor);
142 }
143 };
144
146
148 std::string name;
149 UDAValue surfaceInjectionRate;
150 UDAValue reservoirInjectionRate;
151 UDAValue BHPTarget;
152 UDAValue THPTarget;
153
154 double bhp_hist_limit = 0.0;
155 double thp_hist_limit = 0.0;
156
157 double BHPH;
158 double THPH;
159 int VFPTableNumber;
160 bool predictionMode;
161 int injectionControls;
162 InjectorType injectorType;
163 InjectorCMode controlMode;
164
165 double rsRvInj;
166
167 // injection stream compostion for compositional simulation
168 std::optional<std::vector<double>> gas_inj_composition{};
169
170 bool operator==(const WellInjectionProperties& other) const;
171 bool operator!=(const WellInjectionProperties& other) const;
172
174 WellInjectionProperties(const UnitSystem& units, const std::string& wname);
175
176 static WellInjectionProperties serializationTestObject();
177
178 void handleWELTARG(WELTARGCMode cmode, const UDAValue& new_arg, double SIFactorP);
179
186 void handleWCONINJE(const DeckRecord& record,
187 const double bhp_def,
188 bool availableForGroupControl,
189 const std::string& well_name,
190 const KeywordLocation& location);
191
199 void handleWCONINJH(const DeckRecord& record,
200 const int vfp_table_nr,
201 const double bhp_def,
202 const bool is_producer,
203 const std::string& well_name,
204 const KeywordLocation& loc);
205
206 bool hasInjectionControl(InjectorCMode controlModeArg) const {
207 if (injectionControls & static_cast<int>(controlModeArg))
208 return true;
209 else
210 return false;
211 }
212
213 void dropInjectionControl(InjectorCMode controlModeArg) {
214 auto int_arg = static_cast<int>(controlModeArg);
215 if ((injectionControls & int_arg) != 0)
216 injectionControls -= int_arg;
217 }
218
219 void addInjectionControl(InjectorCMode controlModeArg) {
220 auto int_arg = static_cast<int>(controlModeArg);
221 if ((injectionControls & int_arg) == 0)
222 injectionControls += int_arg;
223 }
224
225 void clearControls();
226
227 void resetDefaultHistoricalBHPLimit();
228 void resetBHPLimit();
229 void setBHPLimit(const double limit);
230 InjectionControls controls(const UnitSystem& unit_system, const SummaryState& st, double udq_default) const;
231 bool updateUDQActive(const UDQConfig& udq_config, UDQActive& active) const;
232 bool updateUDQActive(const UDQConfig& udq_config, const WELTARGCMode cmode, UDQActive& active) const;
233 void update_uda(const UDQConfig& udq_config, UDQActive& udq_active, UDAControl control, const UDAValue& value);
234 void handleWTMULT(Well::WELTARGCMode cmode, double factor);
235
236 void setGasInjComposition(const std::vector<double>& composition);
237 const std::vector<double>& gasInjComposition() const;
238
239 template<class Serializer>
240 void serializeOp(Serializer& serializer)
241 {
242 serializer(name);
243 serializer(surfaceInjectionRate);
244 serializer(reservoirInjectionRate);
245 serializer(BHPTarget);
246 serializer(THPTarget);
247 serializer(bhp_hist_limit);
248 serializer(thp_hist_limit);
249 serializer(BHPH);
250 serializer(THPH);
251 serializer(VFPTableNumber);
252 serializer(predictionMode);
253 serializer(injectionControls);
254 serializer(injectorType);
255 serializer(controlMode);
256 serializer(rsRvInj);
257 serializer(gas_inj_composition);
258 }
259 };
260
262
264 public:
265 // the rates serve as limits under prediction mode
266 // while they are observed rates under historical mode
267 std::string name;
268 UDAValue OilRate;
269 UDAValue WaterRate;
270 UDAValue GasRate;
271 UDAValue LiquidRate;
272 UDAValue ResVRate;
273 UDAValue BHPTarget;
274 UDAValue THPTarget;
275 UDAValue ALQValue;
276
277 // BHP and THP limit
278 double bhp_hist_limit = 0.0;
279 double thp_hist_limit = 0.0;
280 bool bhp_hist_limit_defaulted = true; // Tracks whether value was defaulted or not
281
282 // historical BHP and THP under historical mode
283 double BHPH = 0.0;
284 double THPH = 0.0;
285 int VFPTableNumber = 0;
286 bool predictionMode = false;
287 ProducerCMode controlMode = ProducerCMode::CMODE_UNDEFINED;
288 ProducerCMode whistctl_cmode = ProducerCMode::CMODE_UNDEFINED;
289
290 bool operator==(const WellProductionProperties& other) const;
291 bool operator!=(const WellProductionProperties& other) const;
292
294 WellProductionProperties(const UnitSystem& units, const std::string& name_arg);
295
296 static WellProductionProperties serializationTestObject();
297
298 bool hasProductionControl(ProducerCMode controlModeArg) const {
299 return (m_productionControls & static_cast<int>(controlModeArg)) != 0;
300 }
301
302 void dropProductionControl(ProducerCMode controlModeArg) {
303 if (hasProductionControl(controlModeArg))
304 m_productionControls -= static_cast<int>(controlModeArg);
305 }
306
307 void addProductionControl(ProducerCMode controlModeArg) {
308 if (! hasProductionControl(controlModeArg))
309 m_productionControls += static_cast<int>(controlModeArg);
310 }
311
312 // this is used to check whether the specified control mode is an effective history matching production mode
313 static bool effectiveHistoryProductionControl(ProducerCMode cmode);
314
323 void handleWCONPROD(const std::optional<VFPProdTable::ALQ_TYPE>& alq_type,
324 const int vfp_table_nr,
325 const double bhp_def,
326 const UnitSystem& unit_system,
327 const std::string& well,
328 const DeckRecord& record,
329 const KeywordLocation& location);
330
337 void handleWCONHIST(const std::optional<VFPProdTable::ALQ_TYPE>& alq_type,
338 const int vfp_table_nr,
339 const double bhp_def,
340 const UnitSystem& unit_system,
341 const DeckRecord& record);
342 void handleWELTARG( WELTARGCMode cmode, const UDAValue& new_arg, double SiFactorP);
343 void resetDefaultBHPLimit();
344 void clearControls();
345 ProductionControls controls(const SummaryState& st, double udq_default) const;
346 bool updateUDQActive(const UDQConfig& udq_config, UDQActive& active) const;
347 bool updateUDQActive(const UDQConfig& udq_config, const WELTARGCMode cmode, UDQActive& active) const;
348 void update_uda(const UDQConfig& udq_config, UDQActive& udq_active, UDAControl control, const UDAValue& value);
349
350 void setBHPLimit(const double limit);
351 int productionControls() const { return this->m_productionControls; }
352 void handleWTMULT(Well::WELTARGCMode cmode, double factor);
353
354 template<class Serializer>
355 void serializeOp(Serializer& serializer)
356 {
357 serializer(name);
358 serializer(OilRate);
359 serializer(WaterRate);
360 serializer(GasRate);
361 serializer(LiquidRate);
362 serializer(ResVRate);
363 serializer(BHPTarget);
364 serializer(THPTarget);
365 serializer(ALQValue);
366 serializer(bhp_hist_limit);
367 serializer(thp_hist_limit);
368 serializer(BHPH);
369 serializer(THPH);
370 serializer(VFPTableNumber);
371 serializer(predictionMode);
372 serializer(controlMode);
373 serializer(whistctl_cmode);
374 serializer(m_productionControls);
375 }
376
377 private:
378 int m_productionControls = 0;
379 void init_rates( const DeckRecord& record );
380
381 void init_history(const DeckRecord& record);
382 void init_vfp(const std::optional<VFPProdTable::ALQ_TYPE>& alq_type, const int vfp_table_nr, const UnitSystem& unit_system, const DeckRecord& record);
383
385
386 double getBHPLimit() const;
387 };
388
389 static int eclipseControlMode(const Well::InjectorCMode imode,
390 const InjectorType itype);
391
392 static int eclipseControlMode(const Well::ProducerCMode pmode);
393
394 static int eclipseControlMode(const Well& well,
395 const SummaryState& st);
396
397 Well() = default;
398 Well(const std::string& wname,
399 const std::string& gname,
400 std::size_t init_step,
401 std::size_t insert_index,
402 int headI,
403 int headJ,
404 const std::optional<double>& ref_depth,
405 const WellType& wtype_arg,
406 ProducerCMode whistctl_cmode,
407 Connection::Order ordering,
408 const UnitSystem& unit_system,
409 double udq_undefined,
410 double dr,
411 bool allow_xflow,
412 bool auto_shutin,
413 int pvt_table,
414 GasInflowEquation inflow_eq,
415 bool temp_option = false);
416
417 Well(const RestartIO::RstWell& rst_well,
418 int report_step,
419 int rst_whistctl_cmode,
420 const TracerConfig& tracer_config,
421 const UnitSystem& unit_system,
422 double udq_undefined,
423 const std::optional<VFPProdTable::ALQ_TYPE>& alq_type);
424
425 static Well serializationTestObject();
426
427 bool isMultiSegment() const;
428 bool isAvailableForGroupControl() const;
429 double getGuideRate() const;
430 GuideRateTarget getGuideRatePhase() const;
431 GuideRateTarget getRawGuideRatePhase() const;
432 double getGuideRateScalingFactor() const;
433
434 bool hasBeenDefined(std::size_t timeStep) const;
435 std::size_t firstTimeStep() const;
436 const WellType& wellType() const;
437 bool predictionMode() const;
438 bool isProducer() const;
439 bool isInjector() const;
440 InjectorCMode injection_cmode() const;
441 ProducerCMode production_cmode() const;
442 InjectorType injectorType() const;
443 std::size_t seqIndex() const;
444 bool getAutomaticShutIn() const;
445 bool getAllowCrossFlow() const;
446 const std::string& name() const;
447 const std::vector<std::string>& wListNames() const;
448 int getHeadI() const;
449 int getHeadJ() const;
450 double getWPaveRefDepth() const;
451 bool hasRefDepth() const;
452 double getRefDepth() const;
453 double getDrainageRadius() const;
454 double getEfficiencyFactor(bool network = false) const;
455 double getSolventFraction() const;
456 Status getStatus() const;
457 const std::string& groupName() const;
458 Phase getPreferredPhase() const;
459 InjMultMode getInjMultMode() const;
460 const InjMult& getWellInjMult() const;
461 bool aciveWellInjMult() const;
462
463 bool hasConnections() const;
464 std::vector<const Connection *> getConnections(int completion) const;
465 const WellConnections& getConnections() const;
466 WellConnections& getConnections();
467 const WellSegments& getSegments() const;
468 int maxSegmentID() const;
469 int maxBranchID() const;
470
471 const WellProductionProperties& getProductionProperties() const;
472 const WellInjectionProperties& getInjectionProperties() const;
473 const WellEconProductionLimits& getEconLimits() const;
474 const WellFoamProperties& getFoamProperties() const;
475 const WellPolymerProperties& getPolymerProperties() const;
476 const WellMICPProperties& getMICPProperties() const;
477 const WellBrineProperties& getBrineProperties() const;
478 const WellTracerProperties& getTracerProperties() const;
479 const WVFPDP& getWVFPDP() const;
480 const WVFPEXP& getWVFPEXP() const;
481 const WDFAC& getWDFAC() const;
482
483 /* The rate of a given phase under the following assumptions:
484 * * Returns zero if production is requested for an injector (and vice
485 * versa)
486 * * If this is an injector and something else than the
487 * requested phase is injected, returns 0, i.e.
488 * water_injector.injection_rate( gas ) == 0
489 * * Mixed injection is not supported and always returns 0.
490 */
491 double production_rate( const SummaryState& st, Phase phase) const;
492 double injection_rate( const SummaryState& st, Phase phase) const;
493 static bool wellNameInWellNamePattern(const std::string& wellName, const std::string& wellNamePattern);
494
495 /*
496 The getCompletions() function will return a map:
497
498 {
499 1 : [Connection, Connection],
500 2 : [Connection, Connection, Connecton],
501 3 : [Connection],
502 4 : [Connection]
503 }
504
505 The integer ID's correspond to the COMPLETION id given by the COMPLUMP
506 keyword.
507 */
508 std::map<int, std::vector<Connection>> getCompletions() const;
509 /*
510 For hasCompletion(int completion) and getConnections(int completion) the
511 completion argument is an integer ID used to denote a collection of
512 connections. The integer ID is assigned with the COMPLUMP keyword.
513 */
514 bool hasCompletion(int completion) const;
515 bool updatePrediction(bool prediction_mode);
516 bool updateAutoShutin(bool auto_shutin);
517 bool updateCrossFlow(bool allow_cross_flow);
518 bool updatePVTTable(std::optional<int> pvt_table);
519 bool updateHead(std::optional<int> I, std::optional<int> J);
520 void updateRefDepth();
521 bool updateRefDepth(std::optional<double> ref_dpeth);
522 bool updateDrainageRadius(std::optional<double> drainage_radius);
523 void updateSegments(std::shared_ptr<WellSegments> segments_arg);
524 bool updateConnections(std::shared_ptr<WellConnections> connections, bool force);
525 bool updateConnections(std::shared_ptr<WellConnections> connections, const ScheduleGrid& grid);
526 bool updateStatus(Status status);
527 bool updateGroup(const std::string& group);
528 bool updateWellGuideRate(bool available, double guide_rate, GuideRateTarget guide_phase, double scale_factor);
529 bool updateWellGuideRate(double guide_rate);
530 bool updateAvailableForGroupControl(bool available);
531 bool updateEfficiencyFactor(double efficiency_factor, bool use_efficiency_in_network);
532
533 bool updateSolventFraction(double solvent_fraction);
534 bool updateTracer(std::shared_ptr<WellTracerProperties> tracer_properties);
535 bool updateFoamProperties(std::shared_ptr<WellFoamProperties> foam_properties);
536 bool updatePolymerProperties(std::shared_ptr<WellPolymerProperties> polymer_properties);
537 bool updateMICPProperties(std::shared_ptr<WellMICPProperties> micp_properties);
538 bool updateBrineProperties(std::shared_ptr<WellBrineProperties> brine_properties);
539 bool updateEconLimits(std::shared_ptr<WellEconProductionLimits> econ_limits);
540 bool updateProduction(std::shared_ptr<WellProductionProperties> production);
541 bool updateInjection(std::shared_ptr<WellInjectionProperties> injection);
542 bool updateWellProductivityIndex();
543 bool updateWSEGSICD(const std::vector<std::pair<int, SICD> >& sicd_pairs);
544 bool updateWSEGVALV(const std::vector<std::pair<int, Valve> >& valve_pairs);
545 bool updateWSEGAICD(const std::vector<std::pair<int, AutoICD> >& aicd_pairs, const KeywordLocation& location);
546 bool updateWPAVE(const PAvg& pavg);
547
548
549 void updateWPaveRefDepth(double ref_depth);
550 bool updateWVFPDP(std::shared_ptr<WVFPDP> wvfpdp);
551 bool updateWVFPEXP(std::shared_ptr<WVFPEXP> wvfpexp);
552 bool updateWDFAC(std::shared_ptr<WDFAC> wdfac);
553
554 bool handleWELSEGS(const DeckKeyword& keyword);
555 bool handleCOMPSEGS(const DeckKeyword& keyword, const ScheduleGrid& grid, const ParseContext& parseContext, ErrorGuard& errors);
556 bool handleWELOPENConnections(const DeckRecord& record, Connection::State status);
557 bool handleCSKIN(const DeckRecord& record, const KeywordLocation& location);
558 bool handleCOMPLUMP(const DeckRecord& record);
559 bool handleWPIMULT(const DeckRecord& record);
560 bool handleWINJCLN(const DeckRecord& record, const KeywordLocation& location);
561 bool handleWINJDAM(const DeckRecord& record, const KeywordLocation& location);
562 bool handleWINJMULT(const DeckRecord& record, const KeywordLocation& location);
563 void setFilterConc(const UDAValue& conc);
564 double evalFilterConc(const SummaryState& summary_sate) const;
565 bool applyGlobalWPIMULT(double scale_factor);
566
567 void filterConnections(const ActiveGridCells& grid);
568 ProductionControls productionControls(const SummaryState& st) const;
569 InjectionControls injectionControls(const SummaryState& st) const;
570 int vfp_table_number() const;
571 int pvt_table_number() const;
572 int fip_region_number() const;
573 GasInflowEquation gas_inflow_equation() const;
574 bool segmented_density_calculation() const { return true; }
575 double alq_value(const SummaryState& st) const;
576 double inj_temperature() const;
577 bool hasInjTemperature() const;
578 void setWellInjTemperature(const double temp);
579 bool hasInjected( ) const;
580 bool hasProduced( ) const;
581 bool updateHasInjected( );
582 bool updateHasProduced();
583 bool cmp_structure(const Well& other) const;
584 bool operator==(const Well& data) const;
585 bool hasSameConnectionsPointers(const Well& other) const;
586 void setInsertIndex(std::size_t index);
587 double convertDeckPI(double deckPI) const;
588 void applyWellProdIndexScaling(const double scalingFactor,
589 std::vector<bool>& scalingApplicable);
590 const PAvg& pavg() const;
591
593 void updateUnitSystem(const UnitSystem* usys) { unit_system = usys; }
594
595 template<class Serializer>
596 void serializeOp(Serializer& serializer)
597 {
598 serializer(wname);
599 serializer(group_name);
600 serializer(init_step);
601 serializer(insert_index);
602 serializer(headI);
603 serializer(headJ);
604 serializer(ref_depth);
605 serializer(wpave_ref_depth);
606 serializer(udq_undefined);
607 serializer(status);
608 serializer(drainage_radius);
609 serializer(allow_cross_flow);
610 serializer(automatic_shutin);
611 serializer(pvt_table);
612 serializer(gas_inflow);
613 serializer(wtype);
614 serializer(ref_type);
615 serializer(lgr_tag);
616 serializer(guide_rate);
617 serializer(efficiency_factor);
618 serializer(use_efficiency_in_network);
619 serializer(solvent_fraction);
620 serializer(has_produced);
621 serializer(has_injected);
622 serializer(prediction_mode);
623 serializer(derive_refdepth_from_conns_);
624 serializer(econ_limits);
625 serializer(foam_properties);
626 serializer(polymer_properties);
627 serializer(micp_properties);
628 serializer(brine_properties);
629 serializer(tracer_properties);
630 serializer(connections);
631 serializer(production);
632 serializer(injection);
633 serializer(segments);
634 serializer(wvfpdp);
635 serializer(wdfac);
636 serializer(wvfpexp);
637 serializer(m_pavg);
638 serializer(well_inj_temperature);
639 serializer(default_well_inj_temperature);
640 serializer(inj_mult_mode);
641 serializer(well_inj_mult);
642 serializer(m_filter_concentration);
643 }
644
645private:
646 enum class WellRefinementType {
647 STANDARD,
648 LGR,
649 MIXED,
650 };
651 void switchToInjector();
652 void switchToProducer();
653
654 GuideRateTarget preferredPhaseAsGuideRatePhase() const;
655
656 std::string wname{};
657 std::string group_name{};
658
659 std::size_t init_step{};
660 std::size_t insert_index{};
661 int headI{};
662 int headJ{};
663 std::optional<double> ref_depth{};
664 std::optional<double> wpave_ref_depth{};
665 double drainage_radius{};
666 bool allow_cross_flow{false};
667 bool automatic_shutin{false};
668 int pvt_table{};
669
670
671 // Will NOT be loaded/assigned from restart file
672 GasInflowEquation gas_inflow = GasInflowEquation::STD;
673
674 const UnitSystem* unit_system{nullptr};
675 double udq_undefined{};
676 WellType wtype{};
677 WellRefinementType ref_type{WellRefinementType::STANDARD};
678 std::string lgr_tag{};
679 WellGuideRate guide_rate{};
680 double efficiency_factor{};
681 bool use_efficiency_in_network{};
682 double solvent_fraction{};
683 bool has_produced = false;
684 bool has_injected = false;
685 bool prediction_mode = true;
686 bool derive_refdepth_from_conns_ { true };
687
688 std::shared_ptr<WellEconProductionLimits> econ_limits{};
689 std::shared_ptr<WellFoamProperties> foam_properties{};
690 std::shared_ptr<WellPolymerProperties> polymer_properties{};
691 std::shared_ptr<WellMICPProperties> micp_properties{};
692 std::shared_ptr<WellBrineProperties> brine_properties{};
693 std::shared_ptr<WellTracerProperties> tracer_properties{};
694
695 // The WellConnections object cannot be const because of WELPI and the
696 // filterConnections method
697 std::shared_ptr<WellConnections> connections{};
698
699 std::shared_ptr<WellProductionProperties> production{};
700 std::shared_ptr<WellInjectionProperties> injection{};
701 std::shared_ptr<WellSegments> segments{};
702 std::shared_ptr<WVFPDP> wvfpdp{};
703 std::shared_ptr<WVFPEXP> wvfpexp{};
704 std::shared_ptr<WDFAC> wdfac{};
705
706 Status status{Status::AUTO};
707 PAvg m_pavg{};
708 std::optional<double> well_inj_temperature{};
709 std::optional<double> default_well_inj_temperature{std::nullopt};
710 InjMultMode inj_mult_mode = InjMultMode::NONE;
711 std::optional<InjMult> well_inj_mult{};
712 UDAValue m_filter_concentration{};
713};
714
715std::ostream& operator<<( std::ostream&, const Well::WellInjectionProperties& );
716std::ostream& operator<<( std::ostream&, const Well::WellProductionProperties& );
717
718}
719#endif
Simple class capturing active cells of a grid.
Definition ActiveGridCells.hpp:36
Definition DeckKeyword.hpp:36
Definition DeckRecord.hpp:32
Definition ErrorGuard.hpp:30
Definition KeywordLocation.hpp:27
Definition PAvg.hpp:30
Definition ParseContext.hpp:84
Collection of intersected cells and associate properties for all simulation grids,...
Definition ScheduleGrid.hpp:50
Class for (de-)serializing.
Definition Serializer.hpp:94
Definition SummaryState.hpp:72
Definition TracerConfig.hpp:33
Definition UDAValue.hpp:31
Internalised representation of all UDAs in a simulation run.
Definition UDQActive.hpp:50
Collection of all user-defined quantities in the current simulation run.
Definition UDQConfig.hpp:69
Definition UnitSystem.hpp:34
Definition WDFAC.hpp:40
Definition WVFPDP.hpp:34
Definition WVFPEXP.hpp:34
Definition WellConnections.hpp:48
Definition WellEconProductionLimits.hpp:33
Definition WellSegments.hpp:48
Definition WellTracerProperties.hpp:28
Definition ScheduleTypes.hpp:40
void handleWCONHIST(const std::optional< VFPProdTable::ALQ_TYPE > &alq_type, const int vfp_table_nr, const double bhp_def, const UnitSystem &unit_system, const DeckRecord &record)
Handle WCONHIST keyword.
Definition WellProductionProperties.cpp:237
void handleWCONPROD(const std::optional< VFPProdTable::ALQ_TYPE > &alq_type, const int vfp_table_nr, const double bhp_def, const UnitSystem &unit_system, const std::string &well, const DeckRecord &record, const KeywordLocation &location)
Handle WCONPROD keyword.
Definition WellProductionProperties.cpp:168
Definition Well.hpp:78
void updateUnitSystem(const UnitSystem *usys)
Used by schedule deserialization.
Definition Well.hpp:593
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Definition WINJMULT.hpp:30
Definition well.hpp:43
Definition WellBrineProperties.hpp:29
Definition WellFoamProperties.hpp:29
Definition WellInjectionControls.hpp:31
Definition WellMICPProperties.hpp:29
Definition WellPolymerProperties.hpp:28
Definition WellProductionControls.hpp:31
Definition Well.hpp:111
Definition Well.hpp:147
void handleWCONINJE(const DeckRecord &record, const double bhp_def, bool availableForGroupControl, const std::string &well_name, const KeywordLocation &location)
Handle a WCONINJE keyword.
Definition WellInjectionProperties.cpp:91
void handleWCONINJH(const DeckRecord &record, const int vfp_table_nr, const double bhp_def, const bool is_producer, const std::string &well_name, const KeywordLocation &loc)
Handle a WCONINJH keyword.
Definition WellInjectionProperties.cpp:201