My Project
Schedule.hpp
1 /*
2  Copyright 2013 Statoil 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 #ifndef SCHEDULE_HPP
20 #define SCHEDULE_HPP
21 
22 #include <cstddef>
23 #include <map>
24 #include <memory>
25 #include <optional>
26 #include <string>
27 #include <unordered_map>
28 #include <unordered_set>
29 #include <utility>
30 #include <vector>
31 
32 #include <time.h>
33 
34 #include <opm/parser/eclipse/EclipseState/Runspec.hpp>
35 #include <opm/parser/eclipse/EclipseState/Schedule/GasLiftOpt.hpp>
36 #include <opm/parser/eclipse/EclipseState/Schedule/Group/Group.hpp>
37 #include <opm/parser/eclipse/EclipseState/Schedule/Group/GTNode.hpp>
38 #include <opm/parser/eclipse/EclipseState/Schedule/Group/GuideRateConfig.hpp>
39 #include <opm/parser/eclipse/EclipseState/Schedule/MessageLimits.hpp>
40 #include <opm/parser/eclipse/EclipseState/Schedule/Network/ExtNetwork.hpp>
41 #include <opm/parser/eclipse/EclipseState/Schedule/RPTConfig.hpp>
42 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleDeck.hpp>
43 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleState.hpp>
44 #include <opm/parser/eclipse/EclipseState/Schedule/Well/PAvg.hpp>
45 #include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
46 #include <opm/parser/eclipse/EclipseState/Schedule/Well/WellTestConfig.hpp>
47 #include <opm/parser/eclipse/EclipseState/Schedule/Well/WellMatcher.hpp>
48 #include <opm/parser/eclipse/EclipseState/Schedule/WriteRestartFileEvents.hpp>
49 
50 #include <opm/parser/eclipse/Python/Python.hpp>
51 
52 #include <opm/parser/eclipse/Units/UnitSystem.hpp>
53 
54 namespace Opm
55 {
56  class ActiveGridCells;
57  class Deck;
58  class DeckKeyword;
59  class DeckRecord;
60  class EclipseGrid;
61  class EclipseState;
62  class FieldPropsManager;
63  class ParseContext;
64  class SCHEDULESection;
65  class SummaryState;
66  class ErrorGuard;
67  class UDQConfig;
68 
69  namespace RestartIO { struct RstState; }
70 
71 
72  struct ScheduleStatic {
73  std::shared_ptr<const Python> m_python_handle;
74  std::string m_input_path;
75  ScheduleRestartInfo rst_info;
76  MessageLimits m_deck_message_limits;
77  UnitSystem m_unit_system;
78  Runspec m_runspec;
79  RSTConfig rst_config;
80  std::optional<int> output_interval;
81  double sumthin{-1.0};
82  bool rptonly{false};
83 
84  ScheduleStatic() = default;
85 
86  explicit ScheduleStatic(std::shared_ptr<const Python> python_handle) :
87  m_python_handle(python_handle)
88  {}
89 
90  ScheduleStatic(std::shared_ptr<const Python> python_handle,
91  const ScheduleRestartInfo& restart_info,
92  const Deck& deck,
93  const Runspec& runspec,
94  const std::optional<int>& output_interval_,
95  const ParseContext& parseContext,
96  ErrorGuard& errors);
97 
98  template<class Serializer>
99  void serializeOp(Serializer& serializer)
100  {
101  m_deck_message_limits.serializeOp(serializer);
102  this->rst_info.serializeOp(serializer);
103  m_runspec.serializeOp(serializer);
104  m_unit_system.serializeOp(serializer);
105  serializer(this->m_input_path);
106  rst_info.serializeOp(serializer);
107  rst_config.serializeOp(serializer);
108  serializer(this->output_interval);
109  }
110 
111 
112  static ScheduleStatic serializeObject() {
113  auto python = std::make_shared<Python>(Python::Enable::OFF);
114  ScheduleStatic st(python);
115  st.m_deck_message_limits = MessageLimits::serializeObject();
116  st.m_runspec = Runspec::serializeObject();
117  st.m_unit_system = UnitSystem::newFIELD();
118  st.m_input_path = "Some/funny/path";
119  st.rst_config = RSTConfig::serializeObject();
120  st.rst_info = ScheduleRestartInfo::serializeObject();
121  return st;
122  }
123 
124  bool operator==(const ScheduleStatic& other) const {
125  return this->m_input_path == other.m_input_path &&
126  this->m_deck_message_limits == other.m_deck_message_limits &&
127  this->m_unit_system == other.m_unit_system &&
128  this->rst_config == other.rst_config &&
129  this->rst_info == other.rst_info &&
130  this->m_runspec == other.m_runspec;
131  }
132  };
133 
134 
135  class Schedule {
136  public:
137  Schedule() = default;
138  explicit Schedule(std::shared_ptr<const Python> python_handle);
139  Schedule(const Deck& deck,
140  const EclipseGrid& grid,
141  const FieldPropsManager& fp,
142  const Runspec &runspec,
143  const ParseContext& parseContext,
144  ErrorGuard& errors,
145  std::shared_ptr<const Python> python,
146  const std::optional<int>& output_interval = {},
147  const RestartIO::RstState* rst = nullptr);
148 
149  template<typename T>
150  Schedule(const Deck& deck,
151  const EclipseGrid& grid,
152  const FieldPropsManager& fp,
153  const Runspec &runspec,
154  const ParseContext& parseContext,
155  T&& errors,
156  std::shared_ptr<const Python> python,
157  const std::optional<int>& output_interval = {},
158  const RestartIO::RstState* rst = nullptr);
159 
160  Schedule(const Deck& deck,
161  const EclipseGrid& grid,
162  const FieldPropsManager& fp,
163  const Runspec &runspec,
164  std::shared_ptr<const Python> python,
165  const std::optional<int>& output_interval = {},
166  const RestartIO::RstState* rst = nullptr);
167 
168  Schedule(const Deck& deck,
169  const EclipseState& es,
170  const ParseContext& parseContext,
171  ErrorGuard& errors,
172  std::shared_ptr<const Python> python,
173  const std::optional<int>& output_interval = {},
174  const RestartIO::RstState* rst = nullptr);
175 
176  template <typename T>
177  Schedule(const Deck& deck,
178  const EclipseState& es,
179  const ParseContext& parseContext,
180  T&& errors,
181  std::shared_ptr<const Python> python,
182  const std::optional<int>& output_interval = {},
183  const RestartIO::RstState* rst = nullptr);
184 
185  Schedule(const Deck& deck,
186  const EclipseState& es,
187  std::shared_ptr<const Python> python,
188  const std::optional<int>& output_interval = {},
189  const RestartIO::RstState* rst = nullptr);
190 
191  // The constructor *without* the Python arg should really only be used from Python itself
192  Schedule(const Deck& deck,
193  const EclipseState& es,
194  const std::optional<int>& output_interval = {},
195  const RestartIO::RstState* rst = nullptr);
196 
197  static Schedule serializeObject();
198 
199  /*
200  * If the input deck does not specify a start time, Eclipse's 1. Jan
201  * 1983 is defaulted
202  */
203  time_t getStartTime() const;
204  time_t posixStartTime() const;
205  time_t posixEndTime() const;
206  time_t simTime(std::size_t timeStep) const;
207  double seconds(std::size_t timeStep) const;
208  double stepLength(std::size_t timeStep) const;
209  std::optional<int> exitStatus() const;
210  const UnitSystem& getUnits() const { return this->m_static.m_unit_system; }
211  const Runspec& runspec() const { return this->m_static.m_runspec; }
212 
213  std::size_t numWells() const;
214  std::size_t numWells(std::size_t timestep) const;
215  bool hasWell(const std::string& wellName) const;
216  bool hasWell(const std::string& wellName, std::size_t timeStep) const;
217 
218  WellMatcher wellMatcher(std::size_t report_step) const;
219  std::vector<std::string> wellNames(const std::string& pattern, std::size_t timeStep, const std::vector<std::string>& matching_wells = {}) const;
220  std::vector<std::string> wellNames(const std::string& pattern) const;
221  std::vector<std::string> wellNames(std::size_t timeStep) const;
222  std::vector<std::string> wellNames() const;
223 
224  bool hasGroup(const std::string& groupName, std::size_t timeStep) const;
225  std::vector<std::string> groupNames(const std::string& pattern, std::size_t timeStep) const;
226  std::vector<std::string> groupNames(std::size_t timeStep) const;
227  std::vector<std::string> groupNames(const std::string& pattern) const;
228  std::vector<std::string> groupNames() const;
229  /*
230  The restart_groups function returns a vector of groups pointers which
231  is organized as follows:
232 
233  1. The number of elements is WELLDIMS::MAXGROUPS + 1
234  2. The elements are sorted according to group.insert_index().
235  3. If there are less than WELLDIMS::MAXGROUPS nullptr is used.
236  4. The very last element corresponds to the FIELD group.
237  */
238  std::vector<const Group*> restart_groups(std::size_t timeStep) const;
239 
240  std::vector<std::string> changed_wells(std::size_t reportStep) const;
241  const Well& getWell(std::size_t well_index, std::size_t timeStep) const;
242  const Well& getWell(const std::string& wellName, std::size_t timeStep) const;
243  const Well& getWellatEnd(const std::string& well_name) const;
244  std::vector<Well> getWells(std::size_t timeStep) const;
245  std::vector<Well> getWellsatEnd() const;
246  void shut_well(const std::string& well_name, std::size_t report_step);
247  void stop_well(const std::string& well_name, std::size_t report_step);
248  void open_well(const std::string& well_name, std::size_t report_step);
249 
250  std::vector<const Group*> getChildGroups2(const std::string& group_name, std::size_t timeStep) const;
251  std::vector<Well> getChildWells2(const std::string& group_name, std::size_t timeStep) const;
252  Well::ProducerCMode getGlobalWhistctlMmode(std::size_t timestep) const;
253 
254  const UDQConfig& getUDQConfig(std::size_t timeStep) const;
255  void evalAction(const SummaryState& summary_state, std::size_t timeStep);
256 
257  GTNode groupTree(std::size_t report_step) const;
258  GTNode groupTree(const std::string& root_node, std::size_t report_step) const;
259  const Group& getGroup(const std::string& groupName, std::size_t timeStep) const;
260 
261  void invalidNamePattern (const std::string& namePattern, std::size_t report_step, const ParseContext& parseContext, ErrorGuard& errors, const DeckKeyword& keyword) const;
262 
263  std::optional<std::size_t> first_RFT() const;
264  /*
265  Will remove all completions which are connected to cell which is not
266  active. Will scan through all wells and all timesteps.
267  */
268  void filterConnections(const ActiveGridCells& grid);
269  std::size_t size() const;
270 
271  bool write_rst_file(std::size_t report_step) const;
272  const std::map< std::string, int >& rst_keywords( size_t timestep ) const;
273 
274  std::unordered_set<std::string> applyAction(std::size_t reportStep, const time_point& sim_time, const Action::ActionX& action, const Action::Result& result, const std::unordered_map<std::string, double>& wellpi);
275  void applyWellProdIndexScaling(const std::string& well_name, const std::size_t reportStep, const double scalingFactor);
276 
277 
278  const GasLiftOpt& glo(std::size_t report_step) const;
279 
280  bool operator==(const Schedule& data) const;
281  std::shared_ptr<const Python> python() const;
282 
283 
284  const ScheduleState& back() const;
285  const ScheduleState& operator[](std::size_t index) const;
286  std::vector<ScheduleState>::const_iterator begin() const;
287  std::vector<ScheduleState>::const_iterator end() const;
288  void create_next(const time_point& start_time, const std::optional<time_point>& end_time);
289  void create_next(const ScheduleBlock& block);
290  void create_first(const time_point& start_time, const std::optional<time_point>& end_time);
291 
292 
293  /*
294  The cmp() function compares two schedule instances in a context aware
295  manner. Floating point numbers are compared with a tolerance. The
296  purpose of this comparison function is to implement regression tests
297  for the schedule instances created by loading a restart file.
298  */
299  static bool cmp(const Schedule& sched1, const Schedule& sched2, std::size_t report_step);
300 
301  template<class Serializer>
302  void serializeOp(Serializer& serializer)
303  {
304  m_sched_deck.serializeOp(serializer);
305  serializer.vector(snapshots);
306  m_static.serializeOp(serializer);
307  restart_output.serializeOp(serializer);
308 
309  pack_unpack<PAvg, Serializer>(serializer);
310  pack_unpack<WellTestConfig, Serializer>(serializer);
311  pack_unpack<GConSale, Serializer>(serializer);
312  pack_unpack<GConSump, Serializer>(serializer);
313  pack_unpack<WListManager, Serializer>(serializer);
314  pack_unpack<Network::ExtNetwork, Serializer>(serializer);
315  pack_unpack<Network::Balance, Serializer>(serializer);
316  pack_unpack<RPTConfig, Serializer>(serializer);
317  pack_unpack<Action::Actions, Serializer>(serializer);
318  pack_unpack<UDQActive, Serializer>(serializer);
319  pack_unpack<UDQConfig, Serializer>(serializer);
320  pack_unpack<NameOrder, Serializer>(serializer);
321  pack_unpack<GroupOrder, Serializer>(serializer);
322  pack_unpack<GuideRateConfig, Serializer>(serializer);
323  pack_unpack<GasLiftOpt, Serializer>(serializer);
324  pack_unpack<RFTConfig, Serializer>(serializer);
325  pack_unpack<RSTConfig, Serializer>(serializer);
326 
327  pack_unpack_map<int, VFPProdTable, Serializer>(serializer);
328  pack_unpack_map<int, VFPInjTable, Serializer>(serializer);
329  pack_unpack_map<std::string, Group, Serializer>(serializer);
330  pack_unpack_map<std::string, Well, Serializer>(serializer);
331  }
332 
333  template <typename T, class Serializer>
334  void pack_unpack(Serializer& serializer) {
335  std::vector<T> value_list;
336  std::vector<std::size_t> index_list;
337 
338  if (serializer.isSerializing())
339  pack_state<T>(value_list, index_list);
340 
341  serializer.vector(value_list);
342  serializer.template vector<std::size_t, false>(index_list);
343 
344  if (!serializer.isSerializing())
345  unpack_state<T>(value_list, index_list);
346  }
347 
348  template <typename T>
349  std::vector<std::pair<std::size_t, T>> unique() const {
350  std::vector<std::pair<std::size_t, T>> values;
351  for (std::size_t index = 0; index < this->snapshots.size(); index++) {
352  const auto& member = this->snapshots[index].get<T>();
353  const auto& value = member.get();
354  if (values.empty() || !(value == values.back().second))
355  values.push_back( std::make_pair(index, value));
356  }
357  return values;
358  }
359 
360 
361  template <typename T>
362  void pack_state(std::vector<T>& value_list, std::vector<std::size_t>& index_list) const {
363  auto unique_values = this->unique<T>();
364  for (auto& [index, value] : unique_values) {
365  value_list.push_back( std::move(value) );
366  index_list.push_back( index );
367  }
368  }
369 
370 
371  template <typename T>
372  void unpack_state(const std::vector<T>& value_list, const std::vector<std::size_t>& index_list) {
373  std::size_t unique_index = 0;
374  while (unique_index < value_list.size()) {
375  const auto& value = value_list[unique_index];
376  const auto& first_index = index_list[unique_index];
377  auto last_index = this->snapshots.size();
378  if (unique_index < (value_list.size() - 1))
379  last_index = index_list[unique_index + 1];
380 
381  auto& target_state = this->snapshots[first_index];
382  target_state.get<T>().update( std::move(value) );
383  for (std::size_t index=first_index + 1; index < last_index; index++)
384  this->snapshots[index].get<T>().update( target_state.get<T>() );
385 
386  unique_index++;
387  }
388  }
389 
390 
391  template <typename K, typename T, class Serializer>
392  void pack_unpack_map(Serializer& serializer) {
393  std::vector<T> value_list;
394  std::vector<std::size_t> index_list;
395 
396  if (serializer.isSerializing())
397  pack_map<K,T>(value_list, index_list);
398 
399  serializer.vector(value_list);
400  serializer(index_list);
401 
402  if (!serializer.isSerializing())
403  unpack_map<K,T>(value_list, index_list);
404  }
405 
406 
407  template <typename K, typename T>
408  void pack_map(std::vector<T>& value_list,
409  std::vector<std::size_t>& index_list) {
410 
411  const auto& last_map = this->snapshots.back().get_map<K,T>();
412  std::vector<K> key_list{ last_map.keys() };
413  std::unordered_map<K,T> current_value;
414 
415  for (std::size_t index = 0; index < this->snapshots.size(); index++) {
416  auto& state = this->snapshots[index];
417  const auto& current_map = state.template get_map<K,T>();
418  for (const auto& key : key_list) {
419  auto& value = current_map.get_ptr(key);
420  if (value) {
421  auto it = current_value.find(key);
422  if (it == current_value.end() || !(*value == it->second)) {
423  value_list.push_back( *value );
424  index_list.push_back( index );
425 
426  current_value[key] = *value;
427  }
428  }
429  }
430  }
431  }
432 
433 
434  template <typename K, typename T>
435  void unpack_map(const std::vector<T>& value_list,
436  const std::vector<std::size_t>& index_list) {
437 
438  std::unordered_map<K, std::vector<std::pair<std::size_t, T>>> storage;
439  for (std::size_t storage_index = 0; storage_index < value_list.size(); storage_index++) {
440  const auto& value = value_list[storage_index];
441  const auto& time_index = index_list[storage_index];
442 
443  storage[ value.name() ].emplace_back( time_index, value );
444  }
445 
446  for (const auto& [key, values] : storage) {
447  for (std::size_t unique_index = 0; unique_index < values.size(); unique_index++) {
448  const auto& [time_index, value] = values[unique_index];
449  auto last_index = this->snapshots.size();
450  if (unique_index < (values.size() - 1))
451  last_index = values[unique_index + 1].first;
452 
453  auto& map_value = this->snapshots[time_index].template get_map<K,T>();
454  map_value.update(std::move(value));
455 
456  for (std::size_t index=time_index + 1; index < last_index; index++) {
457  auto& forward_map = this->snapshots[index].template get_map<K,T>();
458  forward_map.update( key, map_value );
459  }
460  }
461  }
462  }
463 
464 
465 
466 
467  private:
468  ScheduleStatic m_static;
469  ScheduleDeck m_sched_deck;
470  std::optional<int> exit_status;
471  std::vector<ScheduleState> snapshots;
472  WriteRestartFileEvents restart_output;
473 
474  void load_rst(const RestartIO::RstState& rst,
475  const EclipseGrid& grid,
476  const FieldPropsManager& fp);
477  void addWell(Well well);
478  void addWell(const std::string& wellName,
479  const std::string& group,
480  int headI,
481  int headJ,
482  Phase preferredPhase,
483  const std::optional<double>& refDepth,
484  double drainageRadius,
485  bool allowCrossFlow,
486  bool automaticShutIn,
487  int pvt_table,
488  Well::GasInflowEquation gas_inflow,
489  std::size_t timeStep,
490  Connection::Order wellConnectionOrder);
491  bool updateWPAVE(const std::string& wname, std::size_t report_step, const PAvg& pavg);
492 
493  void updateGuideRateModel(const GuideRateModel& new_model, std::size_t report_step);
494  GTNode groupTree(const std::string& root_node, std::size_t report_step, std::size_t level, const std::optional<std::string>& parent_name) const;
495  bool checkGroups(const ParseContext& parseContext, ErrorGuard& errors);
496  bool updateWellStatus( const std::string& well, std::size_t reportStep, Well::Status status, std::optional<KeywordLocation> = {});
497  void addWellToGroup( const std::string& group_name, const std::string& well_name , std::size_t timeStep);
498  void iterateScheduleSection(std::size_t load_start,
499  std::size_t load_end,
500  const ParseContext& parseContext,
501  ErrorGuard& errors,
502  const std::unordered_map<std::string, double> * target_wellpi,
503  const EclipseGrid* grid,
504  const FieldPropsManager* fp,
505  const std::string& prefix);
506  void addACTIONX(const Action::ActionX& action);
507  void addGroupToGroup( const std::string& parent_group, const std::string& child_group);
508  void addGroup(const std::string& groupName , std::size_t timeStep);
509  void addGroup(Group group);
510  void addGroup(const RestartIO::RstGroup& rst_group, std::size_t timeStep);
511  void addWell(const std::string& wellName, const DeckRecord& record, std::size_t timeStep, Connection::Order connection_order);
512  void checkIfAllConnectionsIsShut(std::size_t currentStep);
513  void end_report(std::size_t report_step);
514  void handleKeyword(std::size_t currentStep,
515  const ScheduleBlock& block,
516  const DeckKeyword& keyword,
517  const ParseContext& parseContext, ErrorGuard& errors,
518  const EclipseGrid* grid,
519  const FieldPropsManager* fp,
520  const std::vector<std::string>& matching_wells,
521  bool runtime,
522  std::unordered_set<std::string> * affected_wells,
523  const std::unordered_map<std::string, double> * target_wellpi);
524 
525  static std::string formatDate(std::time_t t);
526  std::string simulationDays(std::size_t currentStep) const;
527 
528  bool must_write_rst_file(std::size_t report_step) const;
529 
530  void applyEXIT(const DeckKeyword&, std::size_t currentStep);
531  void applyWELOPEN(const DeckKeyword&, std::size_t currentStep, const ParseContext&, ErrorGuard&, const std::vector<std::string>& matching_wells = {}, std::unordered_set<std::string> * affected_wells = nullptr);
532 
533  struct HandlerContext {
534  const ScheduleBlock& block;
535  const DeckKeyword& keyword;
536  const std::size_t currentStep;
537  const std::vector<std::string>& matching_wells;
538  const bool actionx_mode;
539  std::unordered_set<std::string> * affected_wells;
540  const std::unordered_map<std::string, double> * target_wellpi;
541  const EclipseGrid* grid_ptr;
542  const FieldPropsManager* fp_ptr;
543 
544  HandlerContext(const ScheduleBlock& block_,
545  const DeckKeyword& keyword_,
546  const std::size_t currentStep_,
547  const std::vector<std::string>& matching_wells_,
548  bool actionx_mode_,
549  std::unordered_set<std::string> * affected_wells_,
550  const std::unordered_map<std::string, double> * target_wellpi_):
551  block(block_),
552  keyword(keyword_),
553  currentStep(currentStep_),
554  matching_wells(matching_wells_),
555  actionx_mode(actionx_mode_),
556  affected_wells(affected_wells_),
557  target_wellpi(target_wellpi_),
558  grid_ptr(nullptr),
559  fp_ptr(nullptr)
560  {}
561 
562 
563  };
564 
580  bool handleNormalKeyword(const HandlerContext& handlerContext, const ParseContext& parseContext, ErrorGuard& errors);
581 
582  // Keyword Handlers
583  void handlePYACTION(const DeckKeyword&);
584  void handleGCONPROD(const DeckKeyword& keyword, std::size_t current_step, const ParseContext& parseContext, ErrorGuard& errors);
585  void handleGCONINJE(const DeckKeyword& keyword, std::size_t current_step, const ParseContext& parseContext, ErrorGuard& errors);
586  void handleGLIFTOPT(const DeckKeyword& keyword, std::size_t report_step, const ParseContext& parseContext, ErrorGuard& errors);
587  void handleWELPI (const DeckKeyword& keyword, std::size_t report_step, const ParseContext& parseContext, ErrorGuard& errors, const std::vector<std::string>& matching_wells = {});
588  void handleWELPIRuntime(const HandlerContext&);
589 
590  // Normal keyword handlers -- in KeywordHandlers.cpp
591  void handleBRANPROP (const HandlerContext&, const ParseContext&, ErrorGuard&);
592  void handleCOMPDAT (const HandlerContext&, const ParseContext&, ErrorGuard&);
593  void handleCOMPLUMP (const HandlerContext&, const ParseContext&, ErrorGuard&);
594  void handleCOMPORD (const HandlerContext&, const ParseContext&, ErrorGuard&);
595  void handleCOMPSEGS (const HandlerContext&, const ParseContext&, ErrorGuard&);
596  void handleDRSDT (const HandlerContext&, const ParseContext&, ErrorGuard&);
597  void handleDRSDTCON (const HandlerContext&, const ParseContext&, ErrorGuard&);
598  void handleDRSDTR (const HandlerContext&, const ParseContext&, ErrorGuard&);
599  void handleDRVDT (const HandlerContext&, const ParseContext&, ErrorGuard&);
600  void handleDRVDTR (const HandlerContext&, const ParseContext&, ErrorGuard&);
601  void handleEXIT (const HandlerContext&, const ParseContext&, ErrorGuard&);
602  void handleGCONINJE (const HandlerContext&, const ParseContext&, ErrorGuard&);
603  void handleGCONPROD (const HandlerContext&, const ParseContext&, ErrorGuard&);
604  void handleGCONSALE (const HandlerContext&, const ParseContext&, ErrorGuard&);
605  void handleGCONSUMP (const HandlerContext&, const ParseContext&, ErrorGuard&);
606  void handleGEFAC (const HandlerContext&, const ParseContext&, ErrorGuard&);
607  void handleGLIFTOPT (const HandlerContext&, const ParseContext&, ErrorGuard&);
608  void handleGPMAINT (const HandlerContext&, const ParseContext&, ErrorGuard&);
609  void handleGRUPNET (const HandlerContext&, const ParseContext&, ErrorGuard&);
610  void handleGRUPTREE (const HandlerContext&, const ParseContext&, ErrorGuard&);
611  void handleGUIDERAT (const HandlerContext&, const ParseContext&, ErrorGuard&);
612  void handleLIFTOPT (const HandlerContext&, const ParseContext&, ErrorGuard&);
613  void handleLINCOM (const HandlerContext&, const ParseContext&, ErrorGuard&);
614  void handleMESSAGES (const HandlerContext&, const ParseContext&, ErrorGuard&);
615  void handleMULTFLT (const HandlerContext&, const ParseContext&, ErrorGuard&);
616  void handleMXUNSUPP (const HandlerContext&, const ParseContext&, ErrorGuard&);
617  void handleNETBALAN (const HandlerContext&, const ParseContext&, ErrorGuard&);
618  void handleNODEPROP (const HandlerContext&, const ParseContext&, ErrorGuard&);
619  void handleNUPCOL (const HandlerContext&, const ParseContext&, ErrorGuard&);
620  void handleRPTONLY (const HandlerContext&, const ParseContext&, ErrorGuard&);
621  void handleRPTONLYO (const HandlerContext&, const ParseContext&, ErrorGuard&);
622  void handleRPTRST (const HandlerContext&, const ParseContext&, ErrorGuard&);
623  void handleRPTSCHED (const HandlerContext&, const ParseContext&, ErrorGuard&);
624  void handleTUNING (const HandlerContext&, const ParseContext&, ErrorGuard&);
625  void handleSAVE (const HandlerContext&, const ParseContext&, ErrorGuard&);
626  void handleSUMTHIN (const HandlerContext&, const ParseContext&, ErrorGuard&);
627  void handleUDQ (const HandlerContext&, const ParseContext&, ErrorGuard&);
628  void handleVAPPARS (const HandlerContext&, const ParseContext&, ErrorGuard&);
629  void handleVFPINJ (const HandlerContext&, const ParseContext&, ErrorGuard&);
630  void handleVFPPROD (const HandlerContext&, const ParseContext&, ErrorGuard&);
631  void handleWCONHIST (const HandlerContext&, const ParseContext&, ErrorGuard&);
632  void handleWCONINJE (const HandlerContext&, const ParseContext&, ErrorGuard&);
633  void handleWCONINJH (const HandlerContext&, const ParseContext&, ErrorGuard&);
634  void handleWCONPROD (const HandlerContext&, const ParseContext&, ErrorGuard&);
635  void handleWECON (const HandlerContext&, const ParseContext&, ErrorGuard&);
636  void handleWEFAC (const HandlerContext&, const ParseContext&, ErrorGuard&);
637  void handleWELOPEN (const HandlerContext&, const ParseContext&, ErrorGuard&);
638  void handleWELPI (const HandlerContext&, const ParseContext&, ErrorGuard&);
639  void handleWELSEGS (const HandlerContext&, const ParseContext&, ErrorGuard&);
640  void handleWELSPECS (const HandlerContext&, const ParseContext&, ErrorGuard&);
641  void handleWELTARG (const HandlerContext&, const ParseContext&, ErrorGuard&);
642  void handleWFOAM (const HandlerContext&, const ParseContext&, ErrorGuard&);
643  void handleWGRUPCON (const HandlerContext&, const ParseContext&, ErrorGuard&);
644  void handleWHISTCTL (const HandlerContext&, const ParseContext&, ErrorGuard&);
645  void handleWINJTEMP (const HandlerContext&, const ParseContext&, ErrorGuard&);
646  void handleWLIFTOPT (const HandlerContext&, const ParseContext&, ErrorGuard&);
647  void handleWLIST (const HandlerContext&, const ParseContext&, ErrorGuard&);
648  void handleWMICP (const HandlerContext&, const ParseContext&, ErrorGuard&);
649  void handleWPAVE (const HandlerContext&, const ParseContext&, ErrorGuard&);
650  void handleWPAVEDEP (const HandlerContext&, const ParseContext&, ErrorGuard&);
651  void handleWWPAVE (const HandlerContext&, const ParseContext&, ErrorGuard&);
652  void handleWPIMULT (const HandlerContext&, const ParseContext&, ErrorGuard&);
653  void handleWPMITAB (const HandlerContext&, const ParseContext&, ErrorGuard&);
654  void handleWPOLYMER (const HandlerContext&, const ParseContext&, ErrorGuard&);
655  void handleWRFT (const HandlerContext&, const ParseContext&, ErrorGuard&);
656  void handleWRFTPLT (const HandlerContext&, const ParseContext&, ErrorGuard&);
657  void handleWSALT (const HandlerContext&, const ParseContext&, ErrorGuard&);
658  void handleWSEGITER (const HandlerContext&, const ParseContext&, ErrorGuard&);
659  void handleWSEGSICD (const HandlerContext&, const ParseContext&, ErrorGuard&);
660  void handleWSEGAICD (const HandlerContext&, const ParseContext&, ErrorGuard&);
661  void handleWSEGVALV (const HandlerContext&, const ParseContext&, ErrorGuard&);
662  void handleWSKPTAB (const HandlerContext&, const ParseContext&, ErrorGuard&);
663  void handleWSOLVENT (const HandlerContext&, const ParseContext&, ErrorGuard&);
664  void handleWTEMP (const HandlerContext&, const ParseContext&, ErrorGuard&);
665  void handleWTEST (const HandlerContext&, const ParseContext&, ErrorGuard&);
666  void handleWTRACER (const HandlerContext&, const ParseContext&, ErrorGuard&);
667  };
668 }
669 
670 #endif
Definition: ActionX.hpp:74
Definition: ActionResult.hpp:99
Simple class capturing active cells of a grid.
Definition: ActiveGridCells.hpp:35
Definition: DeckKeyword.hpp:36
Definition: DeckRecord.hpp:32
Definition: Deck.hpp:119
About cell information and dimension: The actual grid information is held in a pointer to an ERT ecl_...
Definition: EclipseGrid.hpp:55
Definition: EclipseState.hpp:55
Definition: ErrorGuard.hpp:29
Definition: FieldPropsManager.hpp:37
Definition: GTNode.hpp:31
Definition: GasLiftOpt.hpp:28
Definition: Group.hpp:44
Definition: GuideRateModel.hpp:29
Definition: MessageLimits.hpp:28
Definition: PAvg.hpp:28
Definition: ParseContext.hpp:88
Definition: RSTConfig.hpp:196
Definition: Runspec.hpp:402
Definition: ScheduleDeck.hpp:54
Definition: ScheduleDeck.hpp:142
Definition: ScheduleState.hpp:81
Definition: Schedule.hpp:135
Definition: Serializer.hpp:38
Definition: SummaryState.hpp:69
Definition: UDQConfig.hpp:51
Definition: UnitSystem.hpp:34
Definition: WellMatcher.hpp:32
Definition: Well.hpp:75
Definition: WriteRestartFileEvents.hpp:31
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:29
Definition: group.hpp:33
Definition: state.hpp:50
Definition: ScheduleDeck.hpp:89
Definition: Schedule.hpp:72