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
108 bool available;
109 double guide_rate;
110 GuideRateTarget guide_phase;
111 double scale_factor;
112
113 static WellGuideRate serializationTestObject()
114 {
115 WellGuideRate result;
116 result.available = true;
117 result.guide_rate = 1.0;
118 result.guide_phase = GuideRateTarget::COMB;
119 result.scale_factor = 2.0;
120
121 return result;
122 }
123
124 bool operator==(const WellGuideRate& data) const {
125 return available == data.available &&
126 guide_rate == data.guide_rate &&
127 guide_phase == data.guide_phase &&
128 scale_factor == data.scale_factor;
129 }
130
131 template<class Serializer>
132 void serializeOp(Serializer& serializer)
133 {
134 serializer(available);
135 serializer(guide_rate);
136 serializer(guide_phase);
137 serializer(scale_factor);
138 }
139 };
140
142
144 std::string name;
145 UDAValue surfaceInjectionRate;
146 UDAValue reservoirInjectionRate;
147 UDAValue BHPTarget;
148 UDAValue THPTarget;
149
150 double bhp_hist_limit = 0.0;
151 double thp_hist_limit = 0.0;
152
153 double BHPH;
154 double THPH;
155 int VFPTableNumber;
156 bool predictionMode;
157 int injectionControls;
158 InjectorType injectorType;
159 InjectorCMode controlMode;
160
161 double rsRvInj;
162
163 bool operator==(const WellInjectionProperties& other) const;
164 bool operator!=(const WellInjectionProperties& other) const;
165
167 WellInjectionProperties(const UnitSystem& units, const std::string& wname);
168
169 static WellInjectionProperties serializationTestObject();
170
171 void handleWELTARG(WELTARGCMode cmode, const UDAValue& new_arg, double SIFactorP);
172
179 void handleWCONINJE(const DeckRecord& record,
180 const double bhp_def,
181 bool availableForGroupControl,
182 const std::string& well_name,
183 const KeywordLocation& location);
184
191 void handleWCONINJH(const DeckRecord& record,
192 const double bhp_def,
193 const bool is_producer,
194 const std::string& well_name,
195 const KeywordLocation& loc);
196
197 bool hasInjectionControl(InjectorCMode controlModeArg) const {
198 if (injectionControls & static_cast<int>(controlModeArg))
199 return true;
200 else
201 return false;
202 }
203
204 void dropInjectionControl(InjectorCMode controlModeArg) {
205 auto int_arg = static_cast<int>(controlModeArg);
206 if ((injectionControls & int_arg) != 0)
207 injectionControls -= int_arg;
208 }
209
210 void addInjectionControl(InjectorCMode controlModeArg) {
211 auto int_arg = static_cast<int>(controlModeArg);
212 if ((injectionControls & int_arg) == 0)
213 injectionControls += int_arg;
214 }
215
216 void clearControls();
217
218 void resetDefaultHistoricalBHPLimit();
219 void resetBHPLimit();
220 void setBHPLimit(const double limit);
221 InjectionControls controls(const UnitSystem& unit_system, const SummaryState& st, double udq_default) const;
222 bool updateUDQActive(const UDQConfig& udq_config, UDQActive& active) const;
223 bool updateUDQActive(const UDQConfig& udq_config, const WELTARGCMode cmode, UDQActive& active) const;
224 void update_uda(const UDQConfig& udq_config, UDQActive& udq_active, UDAControl control, const UDAValue& value);
225 void handleWTMULT(Well::WELTARGCMode cmode, double factor);
226
227 template<class Serializer>
228 void serializeOp(Serializer& serializer)
229 {
230 serializer(name);
231 serializer(surfaceInjectionRate);
232 serializer(reservoirInjectionRate);
233 serializer(BHPTarget);
234 serializer(THPTarget);
235 serializer(bhp_hist_limit);
236 serializer(thp_hist_limit);
237 serializer(BHPH);
238 serializer(THPH);
239 serializer(VFPTableNumber);
240 serializer(predictionMode);
241 serializer(injectionControls);
242 serializer(injectorType);
243 serializer(controlMode);
244 serializer(rsRvInj);
245 }
246 };
247
249
251 public:
252 // the rates serve as limits under prediction mode
253 // while they are observed rates under historical mode
254 std::string name;
255 UDAValue OilRate;
256 UDAValue WaterRate;
257 UDAValue GasRate;
258 UDAValue LiquidRate;
259 UDAValue ResVRate;
260 UDAValue BHPTarget;
261 UDAValue THPTarget;
262 UDAValue ALQValue;
263
264 // BHP and THP limit
265 double bhp_hist_limit = 0.0;
266 double thp_hist_limit = 0.0;
267 bool bhp_hist_limit_defaulted = true; // Tracks whether value was defaulted or not
268
269 // historical BHP and THP under historical mode
270 double BHPH = 0.0;
271 double THPH = 0.0;
272 int VFPTableNumber = 0;
273 bool predictionMode = false;
274 ProducerCMode controlMode = ProducerCMode::CMODE_UNDEFINED;
275 ProducerCMode whistctl_cmode = ProducerCMode::CMODE_UNDEFINED;
276
277 bool operator==(const WellProductionProperties& other) const;
278 bool operator!=(const WellProductionProperties& other) const;
279
281 WellProductionProperties(const UnitSystem& units, const std::string& name_arg);
282
283 static WellProductionProperties serializationTestObject();
284
285 bool hasProductionControl(ProducerCMode controlModeArg) const {
286 return (m_productionControls & static_cast<int>(controlModeArg)) != 0;
287 }
288
289 void dropProductionControl(ProducerCMode controlModeArg) {
290 if (hasProductionControl(controlModeArg))
291 m_productionControls -= static_cast<int>(controlModeArg);
292 }
293
294 void addProductionControl(ProducerCMode controlModeArg) {
295 if (! hasProductionControl(controlModeArg))
296 m_productionControls += static_cast<int>(controlModeArg);
297 }
298
299 // this is used to check whether the specified control mode is an effective history matching production mode
300 static bool effectiveHistoryProductionControl(ProducerCMode cmode);
301
309 void handleWCONPROD(const std::optional<VFPProdTable::ALQ_TYPE>& alq_type,
310 const double bhp_def,
311 const UnitSystem& unit_system,
312 const std::string& well,
313 const DeckRecord& record,
314 const KeywordLocation& location);
315
321 void handleWCONHIST(const std::optional<VFPProdTable::ALQ_TYPE>& alq_type,
322 const double bhp_def,
323 const UnitSystem& unit_system,
324 const DeckRecord& record);
325 void handleWELTARG( WELTARGCMode cmode, const UDAValue& new_arg, double SiFactorP);
326 void resetDefaultBHPLimit();
327 void clearControls();
328 ProductionControls controls(const SummaryState& st, double udq_default) const;
329 bool updateUDQActive(const UDQConfig& udq_config, UDQActive& active) const;
330 bool updateUDQActive(const UDQConfig& udq_config, const WELTARGCMode cmode, UDQActive& active) const;
331 void update_uda(const UDQConfig& udq_config, UDQActive& udq_active, UDAControl control, const UDAValue& value);
332
333 void setBHPLimit(const double limit);
334 int productionControls() const { return this->m_productionControls; }
335 void handleWTMULT(Well::WELTARGCMode cmode, double factor);
336
337 template<class Serializer>
338 void serializeOp(Serializer& serializer)
339 {
340 serializer(name);
341 serializer(OilRate);
342 serializer(WaterRate);
343 serializer(GasRate);
344 serializer(LiquidRate);
345 serializer(ResVRate);
346 serializer(BHPTarget);
347 serializer(THPTarget);
348 serializer(ALQValue);
349 serializer(bhp_hist_limit);
350 serializer(thp_hist_limit);
351 serializer(BHPH);
352 serializer(THPH);
353 serializer(VFPTableNumber);
354 serializer(predictionMode);
355 serializer(controlMode);
356 serializer(whistctl_cmode);
357 serializer(m_productionControls);
358 }
359
360 private:
361 int m_productionControls = 0;
362 void init_rates( const DeckRecord& record );
363
364 void init_history(const DeckRecord& record);
365 void init_vfp(const std::optional<VFPProdTable::ALQ_TYPE>& alq_type, const UnitSystem& unit_system, const DeckRecord& record);
366
368
369 double getBHPLimit() const;
370 };
371
372 static int eclipseControlMode(const Well::InjectorCMode imode,
373 const InjectorType itype);
374
375 static int eclipseControlMode(const Well::ProducerCMode pmode);
376
377 static int eclipseControlMode(const Well& well,
378 const SummaryState& st);
379
380
381 Well() = default;
382 Well(const std::string& wname,
383 const std::string& gname,
384 std::size_t init_step,
385 std::size_t insert_index,
386 int headI,
387 int headJ,
388 const std::optional<double>& ref_depth,
389 const WellType& wtype_arg,
390 ProducerCMode whistctl_cmode,
391 Connection::Order ordering,
392 const UnitSystem& unit_system,
393 double udq_undefined,
394 double dr,
395 bool allow_xflow,
396 bool auto_shutin,
397 int pvt_table,
398 GasInflowEquation inflow_eq);
399
400 Well(const RestartIO::RstWell& rst_well,
401 int report_step,
402 int rst_whistctl_cmode,
403 const TracerConfig& tracer_config,
404 const UnitSystem& unit_system,
405 double udq_undefined);
406
407 static Well serializationTestObject();
408
409 bool isMultiSegment() const;
410 bool isAvailableForGroupControl() const;
411 double getGuideRate() const;
412 GuideRateTarget getGuideRatePhase() const;
413 GuideRateTarget getRawGuideRatePhase() const;
414 double getGuideRateScalingFactor() const;
415
416 bool hasBeenDefined(std::size_t timeStep) const;
417 std::size_t firstTimeStep() const;
418 const WellType& wellType() const;
419 bool predictionMode() const;
420 bool isProducer() const;
421 bool isInjector() const;
422 InjectorCMode injection_cmode() const;
423 ProducerCMode production_cmode() const;
424 InjectorType injectorType() const;
425 std::size_t seqIndex() const;
426 bool getAutomaticShutIn() const;
427 bool getAllowCrossFlow() const;
428 const std::string& name() const;
429 const std::vector<std::string>& wListNames() const;
430 int getHeadI() const;
431 int getHeadJ() const;
432 double getWPaveRefDepth() const;
433 bool hasRefDepth() const;
434 double getRefDepth() const;
435 double getDrainageRadius() const;
436 double getEfficiencyFactor() const;
437 double getSolventFraction() const;
438 Status getStatus() const;
439 const std::string& groupName() const;
440 Phase getPreferredPhase() const;
441 InjMultMode getInjMultMode() const;
442 const InjMult& getWellInjMult() const;
443 bool aciveWellInjMult() const;
444
445 bool hasConnections() const;
446 const std::vector<const Connection *> getConnections(int completion) const;
447 const WellConnections& getConnections() const;
448 const WellSegments& getSegments() const;
449 int maxSegmentID() const;
450 int maxBranchID() const;
451
452 const WellProductionProperties& getProductionProperties() const;
453 const WellInjectionProperties& getInjectionProperties() const;
454 const WellEconProductionLimits& getEconLimits() const;
455 const WellFoamProperties& getFoamProperties() const;
456 const WellPolymerProperties& getPolymerProperties() const;
457 const WellMICPProperties& getMICPProperties() const;
458 const WellBrineProperties& getBrineProperties() const;
459 const WellTracerProperties& getTracerProperties() const;
460 const WVFPDP& getWVFPDP() const;
461 const WVFPEXP& getWVFPEXP() const;
462 const WDFAC& getWDFAC() const;
463
464 /* The rate of a given phase under the following assumptions:
465 * * Returns zero if production is requested for an injector (and vice
466 * versa)
467 * * If this is an injector and something else than the
468 * requested phase is injected, returns 0, i.e.
469 * water_injector.injection_rate( gas ) == 0
470 * * Mixed injection is not supported and always returns 0.
471 */
472 double production_rate( const SummaryState& st, Phase phase) const;
473 double injection_rate( const SummaryState& st, Phase phase) const;
474 static bool wellNameInWellNamePattern(const std::string& wellName, const std::string& wellNamePattern);
475
476 /*
477 The getCompletions() function will return a map:
478
479 {
480 1 : [Connection, Connection],
481 2 : [Connection, Connection, Connecton],
482 3 : [Connection],
483 4 : [Connection]
484 }
485
486 The integer ID's correspond to the COMPLETION id given by the COMPLUMP
487 keyword.
488 */
489 std::map<int, std::vector<Connection>> getCompletions() const;
490 /*
491 For hasCompletion(int completion) and getConnections(int completion) the
492 completion argument is an integer ID used to denote a collection of
493 connections. The integer ID is assigned with the COMPLUMP keyword.
494 */
495 bool hasCompletion(int completion) const;
496 bool updatePrediction(bool prediction_mode);
497 bool updateAutoShutin(bool auto_shutin);
498 bool updateCrossFlow(bool allow_cross_flow);
499 bool updatePVTTable(std::optional<int> pvt_table);
500 bool updateHead(std::optional<int> I, std::optional<int> J);
501 void updateRefDepth();
502 bool updateRefDepth(std::optional<double> ref_dpeth);
503 bool updateDrainageRadius(std::optional<double> drainage_radius);
504 void updateSegments(std::shared_ptr<WellSegments> segments_arg);
505 bool updateConnections(std::shared_ptr<WellConnections> connections, bool force);
506 bool updateConnections(std::shared_ptr<WellConnections> connections, const ScheduleGrid& grid);
507 bool updateStatus(Status status);
508 bool updateGroup(const std::string& group);
509 bool updateWellGuideRate(bool available, double guide_rate, GuideRateTarget guide_phase, double scale_factor);
510 bool updateWellGuideRate(double guide_rate);
511 bool updateAvailableForGroupControl(bool available);
512 bool updateEfficiencyFactor(double efficiency_factor);
513
514 bool updateSolventFraction(double solvent_fraction);
515 bool updateTracer(std::shared_ptr<WellTracerProperties> tracer_properties);
516 bool updateFoamProperties(std::shared_ptr<WellFoamProperties> foam_properties);
517 bool updatePolymerProperties(std::shared_ptr<WellPolymerProperties> polymer_properties);
518 bool updateMICPProperties(std::shared_ptr<WellMICPProperties> micp_properties);
519 bool updateBrineProperties(std::shared_ptr<WellBrineProperties> brine_properties);
520 bool updateEconLimits(std::shared_ptr<WellEconProductionLimits> econ_limits);
521 bool updateProduction(std::shared_ptr<WellProductionProperties> production);
522 bool updateInjection(std::shared_ptr<WellInjectionProperties> injection);
523 bool updateWellProductivityIndex();
524 bool updateWSEGSICD(const std::vector<std::pair<int, SICD> >& sicd_pairs);
525 bool updateWSEGVALV(const std::vector<std::pair<int, Valve> >& valve_pairs);
526 bool updateWSEGAICD(const std::vector<std::pair<int, AutoICD> >& aicd_pairs, const KeywordLocation& location);
527 bool updateWPAVE(const PAvg& pavg);
528 void updateWPaveRefDepth(double ref_depth);
529 bool updateWVFPDP(std::shared_ptr<WVFPDP> wvfpdp);
530 bool updateWVFPEXP(std::shared_ptr<WVFPEXP> wvfpexp);
531 bool updateWDFAC(std::shared_ptr<WDFAC> wdfac);
532
533
534 bool handleWELSEGS(const DeckKeyword& keyword);
535 bool handleCOMPSEGS(const DeckKeyword& keyword, const ScheduleGrid& grid, const ParseContext& parseContext, ErrorGuard& errors);
536 bool handleWELOPENConnections(const DeckRecord& record, Connection::State status);
537 bool handleCSKIN(const DeckRecord& record, const KeywordLocation& location);
538 bool handleCOMPLUMP(const DeckRecord& record);
539 bool handleWPIMULT(const DeckRecord& record);
540 bool handleWINJCLN(const DeckRecord& record, const KeywordLocation& location);
541 bool handleWINJDAM(const DeckRecord& record, const KeywordLocation& location);
542 bool handleWINJMULT(const DeckRecord& record, const KeywordLocation& location);
543 void setFilterConc(const UDAValue& conc);
544 double evalFilterConc(const SummaryState& summary_sate) const;
545 bool applyGlobalWPIMULT(double scale_factor);
546
547 void filterConnections(const ActiveGridCells& grid);
548 ProductionControls productionControls(const SummaryState& st) const;
549 InjectionControls injectionControls(const SummaryState& st) const;
550 int vfp_table_number() const;
551 int pvt_table_number() const;
552 int fip_region_number() const;
553 GasInflowEquation gas_inflow_equation() const;
554 bool segmented_density_calculation() const { return true; }
555 double alq_value(const SummaryState& st) const;
556 double temperature() const;
557 void setWellTemperature(const double temp);
558 bool hasInjected( ) const;
559 bool hasProduced( ) const;
560 bool updateHasInjected( );
561 bool updateHasProduced();
562 bool cmp_structure(const Well& other) const;
563 bool operator==(const Well& data) const;
564 bool hasSameConnectionsPointers(const Well& other) const;
565 void setInsertIndex(std::size_t index);
566 double convertDeckPI(double deckPI) const;
567 void applyWellProdIndexScaling(const double scalingFactor,
568 std::vector<bool>& scalingApplicable);
569 const PAvg& pavg() const;
570
571 template<class Serializer>
572 void serializeOp(Serializer& serializer)
573 {
574 serializer(wname);
575 serializer(group_name);
576 serializer(init_step);
577 serializer(insert_index);
578 serializer(headI);
579 serializer(headJ);
580 serializer(ref_depth);
581 serializer(wpave_ref_depth);
582 serializer(unit_system);
583 serializer(udq_undefined);
584 serializer(status);
585 serializer(drainage_radius);
586 serializer(allow_cross_flow);
587 serializer(automatic_shutin);
588 serializer(pvt_table);
589 serializer(gas_inflow);
590 serializer(wtype);
591 serializer(guide_rate);
592 serializer(efficiency_factor);
593 serializer(solvent_fraction);
594 serializer(has_produced);
595 serializer(has_injected);
596 serializer(prediction_mode);
597 serializer(derive_refdepth_from_conns_);
598 serializer(econ_limits);
599 serializer(foam_properties);
600 serializer(polymer_properties);
601 serializer(micp_properties);
602 serializer(brine_properties);
603 serializer(tracer_properties);
604 serializer(connections);
605 serializer(production);
606 serializer(injection);
607 serializer(segments);
608 serializer(wvfpdp);
609 serializer(wdfac);
610 serializer(wvfpexp);
611 serializer(m_pavg);
612 serializer(well_temperature);
613 serializer(inj_mult_mode);
614 serializer(well_inj_mult);
615 serializer(m_filter_concentration);
616 }
617
618private:
619 void switchToInjector();
620 void switchToProducer();
621
622 GuideRateTarget preferredPhaseAsGuideRatePhase() const;
623
624 std::string wname;
625 std::string group_name;
626 std::size_t init_step;
627 std::size_t insert_index;
628 int headI;
629 int headJ;
630 std::optional<double> ref_depth;
631 std::optional<double> wpave_ref_depth;
632 double drainage_radius;
633 bool allow_cross_flow;
634 bool automatic_shutin;
635 int pvt_table;
636 GasInflowEquation gas_inflow = GasInflowEquation::STD; // Will NOT be loaded/assigned from restart file
637 UnitSystem unit_system;
638 double udq_undefined;
639 WellType wtype;
640 WellGuideRate guide_rate;
641 double efficiency_factor;
642 double solvent_fraction;
643 bool has_produced = false;
644 bool has_injected = false;
645 bool prediction_mode = true;
646 bool derive_refdepth_from_conns_ { true };
647
648 std::shared_ptr<WellEconProductionLimits> econ_limits;
649 std::shared_ptr<WellFoamProperties> foam_properties;
650 std::shared_ptr<WellPolymerProperties> polymer_properties;
651 std::shared_ptr<WellMICPProperties> micp_properties;
652 std::shared_ptr<WellBrineProperties> brine_properties;
653 std::shared_ptr<WellTracerProperties> tracer_properties;
654 std::shared_ptr<WellConnections> connections; // The WellConnections object cannot be const because of WELPI and the filterConnections method
655 std::shared_ptr<WellProductionProperties> production;
656 std::shared_ptr<WellInjectionProperties> injection;
657 std::shared_ptr<WellSegments> segments;
658 std::shared_ptr<WVFPDP> wvfpdp;
659 std::shared_ptr<WVFPEXP> wvfpexp;
660 std::shared_ptr<WDFAC> wdfac;
661
662 Status status;
663 PAvg m_pavg;
664 double well_temperature;
665 InjMultMode inj_mult_mode = InjMultMode::NONE;
666 std::optional<InjMult> well_inj_mult;
667 UDAValue m_filter_concentration;
668};
669
670std::ostream& operator<<( std::ostream&, const Well::WellInjectionProperties& );
671std::ostream& operator<<( std::ostream&, const Well::WellProductionProperties& );
672
673}
674#endif
Simple class capturing active cells of a grid.
Definition ActiveGridCells.hpp:36
Definition DeckKeyword.hpp:36
Definition DeckRecord.hpp:32
Definition ErrorGuard.hpp:29
Definition KeywordLocation.hpp:27
Definition PAvg.hpp:30
Definition ParseContext.hpp:84
Definition ScheduleGrid.hpp:37
Class for (de-)serializing.
Definition Serializer.hpp:84
Definition SummaryState.hpp:68
Definition TracerConfig.hpp:33
Definition UDAValue.hpp:32
Definition UDQActive.hpp:43
Definition UDQConfig.hpp:63
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:47
Definition WellTracerProperties.hpp:28
Definition ScheduleTypes.hpp:38
void handleWCONHIST(const std::optional< VFPProdTable::ALQ_TYPE > &alq_type, const double bhp_def, const UnitSystem &unit_system, const DeckRecord &record)
Handle WCONHIST keyword.
Definition WellProductionProperties.cpp:236
void handleWCONPROD(const std::optional< VFPProdTable::ALQ_TYPE > &alq_type, 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
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:107
Definition Well.hpp:143
void handleWCONINJH(const DeckRecord &record, const double bhp_def, const bool is_producer, const std::string &well_name, const KeywordLocation &loc)
Handle a WCONINJH keyword.
Definition WellInjectionProperties.cpp:199
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:89