30#include <unordered_map>
34#include <opm/input/eclipse/EclipseState/Runspec.hpp>
35#include <opm/input/eclipse/Schedule/Group/Group.hpp>
36#include <opm/input/eclipse/Schedule/MessageLimits.hpp>
37#include <opm/input/eclipse/Schedule/ScheduleDeck.hpp>
38#include <opm/input/eclipse/Schedule/ScheduleState.hpp>
39#include <opm/input/eclipse/Schedule/Well/PAvg.hpp>
40#include <opm/input/eclipse/Schedule/WriteRestartFileEvents.hpp>
41#include <opm/input/eclipse/Schedule/CompletedCells.hpp>
42#include <opm/input/eclipse/Schedule/Action/WGNames.hpp>
43#include <opm/input/eclipse/Units/UnitSystem.hpp>
52 class ActiveGridCells;
58 class FieldPropsManager;
61 class GuideRateConfig;
63 enum class InputErrorAction;
67 class SCHEDULESection;
68 struct SimulatorUpdate;
73 enum class WellGasInflowEquation;
75 enum class WellProducerCMode;
76 enum class WellStatus;
79 namespace RestartIO {
struct RstState; }
83 std::shared_ptr<const Python> m_python_handle;
84 std::string m_input_path;
90 std::optional<int> output_interval;
93 bool gaslift_opt_active{
false};
97 explicit ScheduleStatic(std::shared_ptr<const Python> python_handle) :
98 m_python_handle(python_handle)
105 const std::optional<int>& output_interval_,
109 template<
class Serializer>
112 serializer(m_deck_message_limits);
113 serializer(this->rst_info);
114 serializer(m_runspec);
115 serializer(m_unit_system);
116 serializer(this->m_input_path);
117 serializer(rst_info);
118 serializer(rst_config);
119 serializer(this->output_interval);
120 serializer(this->gaslift_opt_active);
135 bool operator()(
const std::pair<std::string,KeywordLocation>& pair,
136 const std::string& str)
const
138 return std::get<0>(pair) < str;
140 bool operator()(
const std::pair<std::string,KeywordLocation>& pair1,
141 const std::pair<std::string,KeywordLocation>& pair2)
const
143 return std::get<0>(pair1) < std::get<0>(pair2);
145 bool operator()(
const std::string& str,
146 const std::pair<std::string,KeywordLocation>& pair)
const
148 return str < std::get<0>(pair);
152 using WelSegsSet = std::set<std::pair<std::string,KeywordLocation>,
PairComp>;
155 explicit Schedule(std::shared_ptr<const Python> python_handle);
162 std::shared_ptr<const Python> python,
163 const std::optional<int>& output_interval = {},
174 std::shared_ptr<const Python> python,
175 const std::optional<int>& output_interval = {},
176 const RestartIO::RstState* rst =
nullptr,
177 const TracerConfig* tracer_config =
nullptr);
179 Schedule(
const Deck& deck,
180 const EclipseGrid& grid,
181 const FieldPropsManager& fp,
182 const Runspec &runspec,
183 std::shared_ptr<const Python> python,
184 const std::optional<int>& output_interval = {},
185 const RestartIO::RstState* rst =
nullptr,
186 const TracerConfig* tracer_config =
nullptr);
188 Schedule(
const Deck& deck,
189 const EclipseState& es,
190 const ParseContext& parseContext,
192 std::shared_ptr<const Python> python,
193 const std::optional<int>& output_interval = {},
194 const RestartIO::RstState* rst =
nullptr);
196 template <
typename T>
197 Schedule(
const Deck& deck,
198 const EclipseState& es,
199 const ParseContext& parseContext,
201 std::shared_ptr<const Python> python,
202 const std::optional<int>& output_interval = {},
203 const RestartIO::RstState* rst =
nullptr);
205 Schedule(
const Deck& deck,
206 const EclipseState& es,
207 std::shared_ptr<const Python> python,
208 const std::optional<int>& output_interval = {},
209 const RestartIO::RstState* rst =
nullptr);
212 Schedule(
const Deck& deck,
213 const EclipseState& es,
214 const std::optional<int>& output_interval = {},
215 const RestartIO::RstState* rst =
nullptr);
217 static Schedule serializationTestObject();
223 std::time_t getStartTime()
const;
224 std::time_t posixStartTime()
const;
225 std::time_t posixEndTime()
const;
226 std::time_t simTime(std::size_t timeStep)
const;
227 double seconds(std::size_t timeStep)
const;
228 double stepLength(std::size_t timeStep)
const;
229 std::optional<int> exitStatus()
const;
230 const UnitSystem& getUnits()
const {
return this->m_static.m_unit_system; }
231 const Runspec& runspec()
const {
return this->m_static.m_runspec; }
233 std::size_t numWells()
const;
234 std::size_t numWells(std::size_t timestep)
const;
235 bool hasWell(
const std::string& wellName)
const;
236 bool hasWell(
const std::string& wellName, std::size_t timeStep)
const;
238 WellMatcher wellMatcher(std::size_t report_step)
const;
239 std::vector<std::string> wellNames(
const std::string& pattern, std::size_t timeStep,
const std::vector<std::string>& matching_wells = {})
const;
240 std::vector<std::string> wellNames(
const std::string& pattern)
const;
241 std::vector<std::string> wellNames(std::size_t timeStep)
const;
242 std::vector<std::string> wellNames()
const;
244 bool hasGroup(
const std::string& groupName, std::size_t timeStep)
const;
245 std::vector<std::string> groupNames(
const std::string& pattern, std::size_t timeStep)
const;
246 std::vector<std::string> groupNames(std::size_t timeStep)
const;
247 std::vector<std::string> groupNames(
const std::string& pattern)
const;
248 std::vector<std::string> groupNames()
const;
258 std::vector<const Group*> restart_groups(std::size_t timeStep)
const;
260 std::vector<std::string> changed_wells(std::size_t reportStep)
const;
261 const Well& getWell(std::size_t well_index, std::size_t timeStep)
const;
262 const Well& getWell(
const std::string& wellName, std::size_t timeStep)
const;
263 const Well& getWellatEnd(
const std::string& well_name)
const;
265 std::unordered_set<int> getAquiferFluxSchedule()
const;
266 std::vector<Well> getWells(std::size_t timeStep)
const;
267 std::vector<Well> getWellsatEnd()
const;
268 void shut_well(
const std::string& well_name, std::size_t report_step);
269 void stop_well(
const std::string& well_name, std::size_t report_step);
270 void open_well(
const std::string& well_name, std::size_t report_step);
271 void applyWellProdIndexScaling(
const std::string& well_name,
const std::size_t reportStep,
const double scalingFactor);
273 std::vector<const Group*> getChildGroups2(
const std::string& group_name, std::size_t timeStep)
const;
274 std::vector<Well> getChildWells2(
const std::string& group_name, std::size_t timeStep)
const;
275 WellProducerCMode getGlobalWhistctlMmode(std::size_t timestep)
const;
277 const UDQConfig& getUDQConfig(std::size_t timeStep)
const;
278 void evalAction(
const SummaryState& summary_state, std::size_t timeStep);
280 GTNode groupTree(std::size_t report_step)
const;
281 GTNode groupTree(
const std::string& root_node, std::size_t report_step)
const;
282 const Group& getGroup(
const std::string& groupName, std::size_t timeStep)
const;
284 std::optional<std::size_t> first_RFT()
const;
289 void filterConnections(
const ActiveGridCells& grid);
290 std::size_t size()
const;
292 bool write_rst_file(std::size_t report_step)
const;
293 const std::map< std::string, int >& rst_keywords(
size_t timestep )
const;
302 SimulatorUpdate applyAction(std::size_t reportStep,
const Action::ActionX& action,
const std::vector<std::string>& matching_wells,
const std::unordered_map<std::string, double>& wellpi);
310 SimulatorUpdate runPyAction(std::size_t reportStep,
const Action::PyAction& pyaction, Action::State& action_state, EclipseState& ecl_state, SummaryState& summary_state);
313 const GasLiftOpt& glo(std::size_t report_step)
const;
315 bool operator==(
const Schedule& data)
const;
316 std::shared_ptr<const Python> python()
const;
319 const ScheduleState& back()
const;
320 const ScheduleState& operator[](std::size_t index)
const;
321 std::vector<ScheduleState>::const_iterator begin()
const;
322 std::vector<ScheduleState>::const_iterator end()
const;
323 void create_next(
const time_point& start_time,
const std::optional<time_point>& end_time);
324 void create_next(
const ScheduleBlock& block);
325 void create_first(
const time_point& start_time,
const std::optional<time_point>& end_time);
334 static bool cmp(
const Schedule& sched1,
const Schedule& sched2, std::size_t report_step);
335 void applyKeywords(std::vector<DeckKeyword*>& keywords, std::size_t timeStep);
337 template<
class Serializer>
338 void serializeOp(Serializer& serializer)
340 serializer(this->m_static);
341 serializer(this->m_sched_deck);
342 serializer(this->action_wgnames);
343 serializer(this->exit_status);
344 serializer(this->snapshots);
345 serializer(this->restart_output);
346 serializer(this->completed_cells);
348 this->
template pack_unpack<PAvg>(serializer);
349 this->
template pack_unpack<WellTestConfig>(serializer);
350 this->
template pack_unpack<GConSale>(serializer);
351 this->
template pack_unpack<GConSump>(serializer);
352 this->
template pack_unpack<WListManager>(serializer);
353 this->
template pack_unpack<Network::ExtNetwork>(serializer);
354 this->
template pack_unpack<Network::Balance>(serializer);
355 this->
template pack_unpack<RPTConfig>(serializer);
356 this->
template pack_unpack<Action::Actions>(serializer);
357 this->
template pack_unpack<UDQActive>(serializer);
358 this->
template pack_unpack<UDQConfig>(serializer);
359 this->
template pack_unpack<NameOrder>(serializer);
360 this->
template pack_unpack<GroupOrder>(serializer);
361 this->
template pack_unpack<GuideRateConfig>(serializer);
362 this->
template pack_unpack<GasLiftOpt>(serializer);
363 this->
template pack_unpack<RFTConfig>(serializer);
364 this->
template pack_unpack<RSTConfig>(serializer);
366 this->
template pack_unpack_map<int, VFPProdTable>(serializer);
367 this->
template pack_unpack_map<int, VFPInjTable>(serializer);
368 this->
template pack_unpack_map<std::string, Group>(serializer);
369 this->
template pack_unpack_map<std::string, Well>(serializer);
372 template <
typename T,
class Serializer>
373 void pack_unpack(Serializer& serializer) {
374 std::vector<T> value_list;
375 std::vector<std::size_t> index_list;
377 if (serializer.isSerializing())
378 this->
template pack_state<T>(value_list, index_list);
380 serializer(value_list);
381 serializer(index_list);
383 if (!serializer.isSerializing())
384 this->
template unpack_state<T>(value_list, index_list);
387 template <
typename T>
388 std::vector<std::pair<std::size_t, T>> unique()
const {
389 std::vector<std::pair<std::size_t, T>> values;
390 for (std::size_t index = 0; index < this->snapshots.size(); index++) {
391 const auto& member = this->snapshots[index].get<T>();
392 const auto& value = member.get();
393 if (values.empty() || !(value == values.back().second))
394 values.push_back( std::make_pair(index, value));
400 template <
typename T>
401 void pack_state(std::vector<T>& value_list, std::vector<std::size_t>& index_list)
const {
402 auto unique_values = this->
template unique<T>();
403 for (
auto& [index, value] : unique_values) {
404 value_list.push_back( std::move(value) );
405 index_list.push_back( index );
410 template <
typename T>
411 void unpack_state(
const std::vector<T>& value_list,
const std::vector<std::size_t>& index_list) {
412 std::size_t unique_index = 0;
413 while (unique_index < value_list.size()) {
414 const auto& value = value_list[unique_index];
415 const auto& first_index = index_list[unique_index];
416 auto last_index = this->snapshots.size();
417 if (unique_index < (value_list.size() - 1))
418 last_index = index_list[unique_index + 1];
420 auto& target_state = this->snapshots[first_index];
421 target_state.get<T>().update( std::move(value) );
422 for (std::size_t index=first_index + 1; index < last_index; index++)
423 this->snapshots[index].get<T>().update( target_state.get<T>() );
430 template <
typename K,
typename T,
class Serializer>
431 void pack_unpack_map(Serializer& serializer) {
432 std::vector<T> value_list;
433 std::vector<std::size_t> index_list;
435 if (serializer.isSerializing())
436 pack_map<K,T>(value_list, index_list);
438 serializer(value_list);
439 serializer(index_list);
441 if (!serializer.isSerializing())
442 unpack_map<K,T>(value_list, index_list);
446 template <
typename K,
typename T>
447 void pack_map(std::vector<T>& value_list,
448 std::vector<std::size_t>& index_list) {
450 const auto& last_map = this->snapshots.back().get_map<K,T>();
451 std::vector<K> key_list{ last_map.keys() };
452 std::unordered_map<K,T> current_value;
454 for (std::size_t index = 0; index < this->snapshots.size(); index++) {
455 auto& state = this->snapshots[index];
456 const auto& current_map = state.template get_map<K,T>();
457 for (
const auto& key : key_list) {
458 auto& value = current_map.get_ptr(key);
460 auto it = current_value.find(key);
461 if (it == current_value.end() || !(*value == it->second)) {
462 value_list.push_back( *value );
463 index_list.push_back( index );
465 current_value[key] = *value;
473 template <
typename K,
typename T>
474 void unpack_map(
const std::vector<T>& value_list,
475 const std::vector<std::size_t>& index_list) {
477 std::unordered_map<K, std::vector<std::pair<std::size_t, T>>> storage;
478 for (std::size_t storage_index = 0; storage_index < value_list.size(); storage_index++) {
479 const auto& value = value_list[storage_index];
480 const auto& time_index = index_list[storage_index];
482 storage[ value.name() ].emplace_back( time_index, value );
485 for (
const auto& [key, values] : storage) {
486 for (std::size_t unique_index = 0; unique_index < values.size(); unique_index++) {
487 const auto& [time_index, value] = values[unique_index];
488 auto last_index = this->snapshots.size();
489 if (unique_index < (values.size() - 1))
490 last_index = values[unique_index + 1].first;
492 auto& map_value = this->snapshots[time_index].template get_map<K,T>();
493 map_value.update(std::move(value));
495 for (std::size_t index=time_index + 1; index < last_index; index++) {
496 auto& forward_map = this->snapshots[index].template get_map<K,T>();
497 forward_map.update( key, map_value );
503 friend std::ostream& operator<<(std::ostream& os,
const Schedule& sched);
504 void dump_deck(std::ostream& os)
const;
507 struct HandlerContext {
509 const ScheduleBlock& block;
510 const DeckKeyword& keyword;
511 const std::size_t currentStep;
512 const std::vector<std::string>& matching_wells;
513 const bool actionx_mode;
514 const ParseContext& parseContext;
516 SimulatorUpdate * sim_update;
517 const std::unordered_map<std::string, double> * target_wellpi;
518 std::unordered_map<std::string, double>* wpimult_global_factor;
519 WelSegsSet *welsegs_wells;
520 std::set<std::string>*compsegs_wells;
521 const ScheduleGrid& grid;
525 HandlerContext(
const ScheduleBlock& block_,
526 const DeckKeyword& keyword_,
527 const ScheduleGrid& grid_,
528 const std::size_t currentStep_,
529 const std::vector<std::string>& matching_wells_,
531 const ParseContext& parseContext_,
533 SimulatorUpdate * sim_update_,
534 const std::unordered_map<std::string, double> * target_wellpi_,
535 std::unordered_map<std::string, double>* wpimult_global_factor_,
536 WelSegsSet* welsegs_wells_,
537 std::set<std::string>* compsegs_wells_)
540 , currentStep(currentStep_)
541 , matching_wells(matching_wells_)
542 , actionx_mode(actionx_mode_)
543 , parseContext(parseContext_)
545 , sim_update(sim_update_)
546 , target_wellpi(target_wellpi_)
547 , wpimult_global_factor(wpimult_global_factor_)
548 , welsegs_wells(welsegs_wells_)
549 , compsegs_wells(compsegs_wells_)
553 void affected_well(
const std::string& well_name);
556 void welsegs_handled(
const std::string& well_name)
559 welsegs_wells->insert({well_name, keyword.location()});
563 void compsegs_handled(
const std::string& well_name)
566 compsegs_wells->insert(well_name);
576 ScheduleStatic m_static;
577 ScheduleDeck m_sched_deck;
578 Action::WGNames action_wgnames;
579 std::optional<int> exit_status;
580 std::vector<ScheduleState> snapshots;
581 WriteRestartFileEvents restart_output;
582 CompletedCells completed_cells;
584 void load_rst(
const RestartIO::RstState& rst,
585 const TracerConfig& tracer_config,
586 const ScheduleGrid& grid,
587 const FieldPropsManager& fp);
588 void addWell(Well well);
589 void addWell(
const std::string& wellName,
590 const std::string& group,
593 Phase preferredPhase,
594 const std::optional<double>& refDepth,
595 double drainageRadius,
597 bool automaticShutIn,
599 WellGasInflowEquation gas_inflow,
600 std::size_t timeStep,
601 Connection::Order wellConnectionOrder);
602 bool updateWPAVE(
const std::string& wname, std::size_t report_step,
const PAvg& pavg);
604 void updateGuideRateModel(
const GuideRateModel& new_model, std::size_t report_step);
605 GTNode groupTree(
const std::string& root_node, std::size_t report_step, std::size_t level,
const std::optional<std::string>& parent_name)
const;
606 bool checkGroups(
const ParseContext& parseContext, ErrorGuard& errors);
607 bool updateWellStatus(
const std::string& well, std::size_t reportStep, WellStatus status, std::optional<KeywordLocation> = {});
608 void addWellToGroup(
const std::string& group_name,
const std::string& well_name , std::size_t timeStep);
609 void iterateScheduleSection(std::size_t load_start,
610 std::size_t load_end,
611 const ParseContext& parseContext,
613 const ScheduleGrid& grid,
614 const std::unordered_map<std::string, double> * target_wellpi,
615 const std::string& prefix,
616 const bool log_to_debug =
false);
617 void addACTIONX(
const Action::ActionX& action);
618 void addGroupToGroup(
const std::string& parent_group,
const std::string& child_group);
619 void addGroup(
const std::string& groupName , std::size_t timeStep);
620 void addGroup(Group group);
621 void addGroup(
const RestartIO::RstGroup& rst_group, std::size_t timeStep);
622 void addWell(
const std::string& wellName,
const DeckRecord& record, std::size_t timeStep, Connection::Order connection_order);
623 void checkIfAllConnectionsIsShut(std::size_t currentStep);
624 void end_report(std::size_t report_step);
627 void handleKeyword(std::size_t currentStep,
628 const ScheduleBlock& block,
629 const DeckKeyword& keyword,
630 const ParseContext& parseContext,
632 const ScheduleGrid& grid,
633 const std::vector<std::string>& matching_wells,
635 SimulatorUpdate* sim_update,
636 const std::unordered_map<std::string, double>* target_wellpi,
637 std::unordered_map<std::string, double>* wpimult_global_factor =
nullptr,
638 WelSegsSet* welsegs_wells =
nullptr,
639 std::set<std::string>* compsegs_wells =
nullptr);
641 void prefetch_cell_properties(
const ScheduleGrid& grid,
const DeckKeyword& keyword);
642 void store_wgnames(
const DeckKeyword& keyword);
643 std::vector<std::string> wellNames(
const std::string& pattern,
const HandlerContext& context);
644 std::vector<std::string> wellNames(
const std::string& pattern, std::size_t timeStep,
const std::vector<std::string>& matching_wells, InputErrorAction error_action, ErrorGuard& errors,
const KeywordLocation& location)
const;
645 void invalidNamePattern(
const std::string& namePattern,
const HandlerContext& context)
const;
646 static std::string formatDate(std::time_t t);
647 std::string simulationDays(std::size_t currentStep)
const;
648 void applyGlobalWPIMULT(
const std::unordered_map<std::string, double>& wpimult_global_factor);
650 bool must_write_rst_file(std::size_t report_step)
const;
652 void applyEXIT(
const DeckKeyword&, std::size_t currentStep);
653 SimulatorUpdate applyAction(std::size_t reportStep,
const std::string& action_name,
const std::vector<std::string>& matching_wells);
670 bool handleNormalKeyword(HandlerContext& handlerContext);
673 void handlePYACTION(
const DeckKeyword&);
674 void handleWELPIRuntime(HandlerContext&);
678 void handleAQUCT (HandlerContext&);
679 void handleAQUFETP (HandlerContext&);
680 void handleAQUFLUX (HandlerContext&);
681 void handleBRANPROP (HandlerContext&);
682 void handleCOMPDAT (HandlerContext&);
683 void handleCOMPLUMP (HandlerContext&);
684 void handleCOMPORD (HandlerContext&);
685 void handleCOMPSEGS (HandlerContext&);
686 void handleCOMPTRAJ (HandlerContext&);
687 void handleDRSDT (HandlerContext&);
688 void handleDRSDTCON (HandlerContext&);
689 void handleDRSDTR (HandlerContext&);
690 void handleDRVDT (HandlerContext&);
691 void handleDRVDTR (HandlerContext&);
692 void handleEXIT (HandlerContext&);
693 void handleGCONINJE (HandlerContext&);
694 void handleGCONPROD (HandlerContext&);
695 void handleGCONSALE (HandlerContext&);
696 void handleGCONSUMP (HandlerContext&);
697 void handleGEFAC (HandlerContext&);
698 void handleGEOKeyword(HandlerContext&);
699 void handleGLIFTOPT (HandlerContext&);
700 void handleGPMAINT (HandlerContext&);
701 void handleGRUPNET (HandlerContext&);
702 void handleGRUPTREE (HandlerContext&);
703 void handleGUIDERAT (HandlerContext&);
704 void handleLIFTOPT (HandlerContext&);
705 void handleLINCOM (HandlerContext&);
706 void handleMESSAGES (HandlerContext&);
707 void handleMXUNSUPP (HandlerContext&);
708 void handleNETBALAN (HandlerContext&);
709 void handleNEXTSTEP (HandlerContext&);
710 void handleNODEPROP (HandlerContext&);
711 void handleNUPCOL (HandlerContext&);
712 void handleRPTONLY (HandlerContext&);
713 void handleRPTONLYO (HandlerContext&);
714 void handleRPTRST (HandlerContext&);
715 void handleRPTSCHED (HandlerContext&);
716 void handleTUNING (HandlerContext&);
717 void handleSAVE (HandlerContext&);
718 void handleSUMTHIN (HandlerContext&);
719 void handleUDQ (HandlerContext&);
720 void handleVAPPARS (HandlerContext&);
721 void handleVFPINJ (HandlerContext&);
722 void handleVFPPROD (HandlerContext&);
723 void handleWCONHIST (HandlerContext&);
724 void handleWCONINJE (HandlerContext&);
725 void handleWCONINJH (HandlerContext&);
726 void handleWCONPROD (HandlerContext&);
727 void handleWECON (HandlerContext&);
728 void handleWEFAC (HandlerContext&);
729 void handleWELOPEN (HandlerContext&);
730 void handleWELPI (HandlerContext&);
731 void handleWELSEGS (HandlerContext&);
732 void handleWELSPECS (HandlerContext&);
733 void handleWELTARG (HandlerContext&);
734 void handleWELTRAJ (HandlerContext&);
735 void handleWFOAM (HandlerContext&);
736 void handleWGRUPCON (HandlerContext&);
737 void handleWHISTCTL (HandlerContext&);
738 void handleWINJTEMP (HandlerContext&);
739 void handleWLIFTOPT (HandlerContext&);
740 void handleWLIST (HandlerContext&);
741 void handleWMICP (HandlerContext&);
742 void handleWPAVE (HandlerContext&);
743 void handleWPAVEDEP (HandlerContext&);
744 void handleWVFPEXP (HandlerContext&);
745 void handleWWPAVE (HandlerContext&);
746 void handleWPIMULT (HandlerContext&);
747 void handleWPMITAB (HandlerContext&);
748 void handleWPOLYMER (HandlerContext&);
749 void handleWRFT (HandlerContext&);
750 void handleWRFTPLT (HandlerContext&);
751 void handleWSALT (HandlerContext&);
752 void handleWSEGITER (HandlerContext&);
753 void handleWSEGSICD (HandlerContext&);
754 void handleWSEGAICD (HandlerContext&);
755 void handleWSEGVALV (HandlerContext&);
756 void handleWSKPTAB (HandlerContext&);
757 void handleWSOLVENT (HandlerContext&);
758 void handleWTEMP (HandlerContext&);
759 void handleWTEST (HandlerContext&);
760 void handleWTMULT (HandlerContext&);
761 void handleWTRACER (HandlerContext&);
About cell information and dimension: The actual grid information is held in a pointer to an ERT ecl_...
Definition: EclipseGrid.hpp:54
Definition: ErrorGuard.hpp:29
Definition: FieldPropsManager.hpp:41
Definition: MessageLimits.hpp:28
Definition: ParseContext.hpp:84
Definition: RSTConfig.hpp:196
Definition: Runspec.hpp:434
Definition: Schedule.hpp:130
Class for (de-)serializing.
Definition: Serializer.hpp:84
Definition: TracerConfig.hpp:33
Definition: UnitSystem.hpp:33
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:30
Definition: ScheduleDeck.hpp:92
Definition: Schedule.hpp:82
Definition: Schedule.hpp:134