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