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