Building Medical Digital Twins with Pulse: Open Source Simulation Tools for Developers and Researchers
Webinar
×
Controller.h
1 /* Distributed under the Apache License, Version 2.0.
2  See accompanying NOTICE file for details.*/
3 
4 #pragma once
5 
6 #include "engine/CommonDefs.h"
7 #include "engine/PulseConfiguration.h"
8 #include "engine/common/controller/BlackBoxManager.h"
9 #include "engine/common/controller/CircuitManager.h"
10 #include "engine/common/controller/CompartmentManager.h"
11 #include "engine/common/controller/SubstanceManager.h"
12 
13 // CDM
14 #include "cdm/engine/SEActionManager.h"
15 #include "cdm/engine/SEConditionManager.h"
16 #include "cdm/engine/SEDataRequested.h"
17 #include "cdm/engine/SEDataRequestTracker.h"
18 #include "cdm/engine/SEEngineStabilization.h"
19 #include "cdm/engine/SEEventManager.h"
20 #include "cdm/engine/SEPatientConfiguration.h"
21 #include "cdm/patient/SEPatient.h"
22 #include "cdm/properties/SEScalarTime.h"
23 
24 namespace pulse
25 {
26  class StabilizationController;
27  class Model;
28 
29  class EnvironmentModel;
30 
31  class BloodChemistryModel;
32  class CardiovascularModel;
33  class EndocrineModel;
34  class EnergyModel;
35  class GastrointestinalModel;
36  class HepaticModel;
37  class NervousModel;
38  class RenalModel;
39  class RespiratoryModel;
40  class DrugModel;
41  class TissueModel;
42 
43  class AnesthesiaMachineModel;
44  class BagValveMaskModel;
45  class ECMOModel;
46  class ElectroCardioGramModel;
47  class InhalerModel;
48  class MechanicalVentilatorModel;
49 
50  class SaturationCalculator;
51 
52  enum class EngineState
53  {
54  NotReady = 0,
55  Initialization,
56  InitialStabilization,
57  AtInitialStableState,
58  SecondaryStabilization,
59  AtSecondaryStableState,
60  Active,
61  Fatal
62  };
63 
64  // Keep enums in sync with appropriate proto file !!
65  enum class eAirwayMode
66  {
67  Free = 0,
68  AnesthesiaMachine,
69  BagValveMask,
70  Inhaler,
71  MechanicalVentilation,// Action
72  MechanicalVentilator, // Equipment
73  NasalCannula,
74  NonRebreatherMask,
75  SimpleMask
76  };
77  extern PULSE_DECL const std::string& eAirwayMode_Name(eAirwayMode m);
78 
79  class PULSE_DECL Data : public Loggable
80  {
81  friend class Engine;
82  protected:// Create in an Engine
83  Data(Logger* logger = nullptr);
84  public:
85  virtual ~Data();
86 
87  virtual std::string GetDataRoot() const { return m_DataDir; }
88  virtual void SetDataRoot(const std::string& dir) { m_DataDir = dir; }
89 
90  virtual void AdvanceCallback(double time_s);
91 
92  virtual EngineState GetState() const { return m_State; }
93 
94  virtual DataTrack& GetDataTrack() const;
95  virtual SEEngineTracker& GetEngineTracker() const;
96 
97  virtual SaturationCalculator& GetSaturationCalculator() const;
98 
99  virtual SubstanceManager& GetSubstances() const;
100 
101  virtual const SEPatient& GetInitialPatient() const;
102  virtual SEPatient& GetCurrentPatient() const;
103 
104  virtual bool HasBloodChemistry() const;
105  virtual SEBloodChemistrySystem& GetBloodChemistry() const;
106  virtual bool HasCardiovascular() const;
107  virtual SECardiovascularSystem& GetCardiovascular() const;
108  virtual bool HasDrugs() const;
109  virtual SEDrugSystem& GetDrugs() const;
110  virtual bool HasEndocrine() const;
111  virtual SEEndocrineSystem& GetEndocrine() const;
112  virtual bool HasEnergy() const;
113  virtual SEEnergySystem& GetEnergy() const;
114  virtual bool HasGastrointestinal() const;
115  virtual SEGastrointestinalSystem& GetGastrointestinal() const;
116  virtual bool HasHepatic() const;
117  virtual SEHepaticSystem& GetHepatic() const;
118  virtual bool HasNervous() const;
119  virtual SENervousSystem& GetNervous() const;
120  virtual bool HasRenal() const;
121  virtual SERenalSystem& GetRenal() const;
122  virtual bool HasRespiratory() const;
123  virtual SERespiratorySystem& GetRespiratory() const;
124  virtual bool HasTissue() const;
125  virtual SETissueSystem& GetTissue() const;
126 
127  virtual bool HasEnvironment() const;
128  virtual SEEnvironment& GetEnvironment() const;
129  virtual bool HasAnesthesiaMachine() const;
130  virtual SEAnesthesiaMachine& GetAnesthesiaMachine() const;
131  virtual bool HasBagValveMask() const;
132  virtual SEBagValveMask& GetBagValveMask() const;
133  virtual bool HasECG() const;
134  virtual SEElectroCardioGram& GetECG() const;
135  virtual bool HasECMO() const;
136  virtual SEECMO& GetECMO() const;
137  virtual bool HasInhaler() const;
138  virtual SEInhaler& GetInhaler() const;
139  virtual bool HasMechanicalVentilator() const;
140  virtual SEMechanicalVentilator& GetMechanicalVentilator() const;
141 
142  virtual SEActionManager& GetActions() const;
143 
144  virtual SEConditionManager& GetConditions() const;
145 
146  virtual SEEventManager& GetEvents() const;
147 
148  virtual CircuitManager& GetCircuits() const;
149 
150  virtual CompartmentManager& GetCompartments() const;
151 
152  virtual BlackBoxManager& GetBlackBoxes() const;
153 
154  virtual const PulseConfiguration& GetConfiguration() const;
155 
156  virtual double GetTimeStep_s() const;
157  virtual const SEScalarTime& GetTimeStep() const;
158  virtual const SEScalarTime& GetEngineTime() const;
159  virtual const SEScalarTime& GetSimulationTime() const;
160  virtual double GetSimulationTime_s() const;
161  virtual const SEScalarTime& GetStabilizationTime() const;
162 
163  virtual bool IsAirwayModeSupported(eAirwayMode /*mode*/) { return true; }
164  virtual eAirwayMode GetAirwayMode() const { return m_AirwayMode; }
165  virtual void SetAirwayMode(eAirwayMode mode);
166 
167  virtual eSwitch GetIntubation() const { return m_Intubation; }
168 
169  virtual void SetAdvanceHandler(SEAdvanceHandler* handler) { m_AdvanceHandler = handler; }
170 
171  virtual const SEScalarProperties& GetOverrides() const;
172 
173  std::stringstream m_ss;
174  protected:
175  virtual void SetupTracker();
176 
177  EngineState m_State;
178  eEngineInitializationState m_EngineInitializationState;
179  SEScalarTime m_CurrentTime;
180  SEScalarTime m_SimulationTime;
181  SEScalarTime m_StabilizationTime;
182  double m_SpareAdvanceTime_s;
183  eAirwayMode m_AirwayMode;
184  eSwitch m_Intubation;
185 
186  PulseConfiguration* m_Config = nullptr;
187 
188  SEDataRequested* m_DataRequested = nullptr;
189  SEEngineTracker* m_EngineTracker = nullptr;
190 
191  SaturationCalculator* m_SaturationCalculator = nullptr;
192 
193  SubstanceManager* m_Substances = nullptr;
194 
195  SEActionManager* m_Actions = nullptr;
196  SEConditionManager* m_Conditions = nullptr;
197  CircuitManager* m_Circuits = nullptr;
198  CompartmentManager* m_Compartments = nullptr;
199  BlackBoxManager* m_BlackBoxes = nullptr;
200 
201  EnvironmentModel* m_EnvironmentModel = nullptr;
202 
203  BloodChemistryModel* m_BloodChemistryModel = nullptr;
204  CardiovascularModel* m_CardiovascularModel = nullptr;
205  EndocrineModel* m_EndocrineModel = nullptr;
206  EnergyModel* m_EnergyModel = nullptr;
207  GastrointestinalModel* m_GastrointestinalModel = nullptr;
208  HepaticModel* m_HepaticModel = nullptr;
209  NervousModel* m_NervousModel = nullptr;
210  RenalModel* m_RenalModel = nullptr;
211  RespiratoryModel* m_RespiratoryModel = nullptr;
212  DrugModel* m_DrugModel = nullptr;
213  TissueModel* m_TissueModel = nullptr;
214 
215  AnesthesiaMachineModel* m_AnesthesiaMachineModel = nullptr;
216  BagValveMaskModel* m_BagValveMaskModel = nullptr;
217  ECMOModel* m_ECMOModel = nullptr;
218  ElectroCardioGramModel* m_ElectroCardioGramModel = nullptr;
219  InhalerModel* m_InhalerModel = nullptr;
220  MechanicalVentilatorModel* m_MechanicalVentilatorModel = nullptr;
221 
222  SEPatient* m_InitialPatient = nullptr;
223  SEPatient* m_CurrentPatient = nullptr;
224 
225  SEEventManager* m_EventManager = nullptr;
226  LoggerForward* m_LogForward = nullptr;
227 
228  SEAdvanceHandler* m_AdvanceHandler = nullptr;
229 
230  std::string m_DataDir;
231 
232  SEScalarProperties m_ScalarOverrides;
233  protected:
234  std::vector<pulse::Model*> m_Models;
235  };
236 
240  class PULSE_DECL Controller : public Data
241  {
242  friend class Engine;
243  friend class EngineTest;
244  friend class PBState;//friend the serialization class
245  protected:// Create via Engine
246  Controller(Logger* logger = nullptr);
247  public:
248  virtual ~Controller();
249 
250  virtual Data& GetData() { return (*this); }
251  virtual const Data& GetData() const { return (*this); }
252 
253  virtual bool SerializeFromFile(const std::string& file, const SEDataRequestManager* drMgr=nullptr);
254  virtual bool SerializeToFile(const std::string& file) const;
255 
256  virtual bool SerializeFromString(const std::string& state, eSerializationFormat m, const SEDataRequestManager* drMgr=nullptr);
257  virtual bool SerializeToString(std::string& state, eSerializationFormat m) const;
258 
259  virtual bool InitializeEngine(const SEPatientConfiguration& patient_configuration, const SEDataRequestManager* drMgr=nullptr);
260  virtual bool IsReady() const;
261  virtual eEngineInitializationState GetInitializationState() const;
262 
263  virtual void Clear();
264 
265  virtual bool SetConfigurationOverride(const SEEngineConfiguration* config);
266 
267  virtual void SetSimulationTime(const SEScalarTime& time);
268 
269  virtual bool AdvanceModelTime();
270  virtual bool AdvanceModelTime(double time, const TimeUnit& unit);
271  virtual bool ProcessAction(const SEAction& action);
272 
273  virtual bool GetPatientAssessment(SEPatientAssessment& assessment) const = 0;
274 
275  virtual bool CreateCircuitsAndCompartments();
276 
277  virtual void CheckIntubation();
278  protected:
279  virtual std::string GetTypeName() const = 0;
280  virtual void LogBuildInfo() const;
281  // Setup Circuit/Compartments for systems
282 
283  // Default/Optimal Cardiovascular
284  virtual void SetupCardiovascular();
285  virtual void SetupRenal();
286  virtual void SetupTissue();
287  virtual void SetupCerebrospinalFluid();
288 
289  // Optional ComputationalLife Expansion Setup Methods
290  virtual void SetupComputationalLifeCardiovascular();
291  virtual void SetupComputationalLifeRenal();
292  virtual void SetupComputationalLifeTissue();
293  virtual void SetupComputationalLifeCerebrospinalFluid();
294 
295  // Default/Optimal Gastrointestinal
296  virtual void SetupGastrointestinal();
297 
298  // Default/Optimal Respiratory
299  virtual void SetupRespiratory();
300 
301  // Optional Expanded Lungs Respiratory and Cardiovascular Circuit Setup Methods
302  virtual void SetupExpandedLungsRespiratory();
303  virtual void SetupExpandedLungsCardiovascular();
304 
305  // Default/Optimal Equipment
306  virtual void SetupAnesthesiaMachine();
307  virtual void SetupBagValveMask();
308  virtual void SetupECMO();
309  virtual void SetupInhaler();
310  virtual void SetupMechanicalVentilation();
311  virtual void SetupMechanicalVentilator();
312  virtual void SetupNasalCannula();
313  virtual void SetupSimpleMask();
314  virtual void SetupNonRebreatherMask();
315 
316  // Default/Optimal Energy
317  virtual void SetupExternalTemperature();
318  virtual void SetupInternalTemperature();
319 
320  virtual bool OverrideCircuits();
321  virtual bool ModifyCircuits(const SEScalarProperties& modifiers);
322 
323  virtual bool Initialize(const SEPatient& patient);
324  virtual bool Stabilize(const SEPatientConfiguration& patient_configuration);
325  virtual void LogPatientStabilizationDiffs();
326 
327  // Allocate all the models this engine supports
328  virtual void Allocate();
329  virtual bool SetupPatient(const SEPatient& patient) = 0;
330  // Based on what modles are used, setup order for the following
331  virtual void InitializeModels();
332  // Notify Models that steady state has been achieved
333  virtual void AtSteadyState(EngineState state);
334  virtual void PreProcess();
335  virtual void Process();
336  virtual void PostProcess();
337 
338  PulseConfiguration const*m_ConfigOverride = nullptr;
339  StabilizationController *m_Stabilizer = nullptr;
340  eSwitch m_Tracking = eSwitch::On;
341  };
342 
343  class PULSE_DECL StabilizationController : public SEEngineStabilization::Controller
344  {
345  public:
346  StabilizationController(pulse::Controller& pc) : _pc(pc) {}
347  virtual ~StabilizationController() = default;
348 
349  bool AdvanceTime() override { return _pc.AdvanceModelTime(); }
350  SEEngineTracker* GetEngineTracker() override
351  {
352  return &_pc.GetData().GetEngineTracker();
353  }
354  double GetTimeStep(const TimeUnit& unit) override
355  {
356  return _pc.GetData().GetTimeStep().GetValue(unit);
357  }
358  double GetSimulationTime(const TimeUnit& unit) override
359  {
360  return _pc.GetData().GetSimulationTime().GetValue(unit);
361  }
362 
363  protected:
364  pulse::Controller& _pc;
365  };
366 
367  class FatalListner : public LoggerForward
368  {
369  public:
370  FatalListner(SEEventManager& mgr, SEScalarTime& ct) : m_Events(mgr), m_CurrentTime(ct) {};
371  ~FatalListner() = default;
372 
373  void ForwardDebug(const std::string& /*msg*/) override { }
374  void ForwardInfo(const std::string& /*msg*/) override { }
375  void ForwardWarning(const std::string& /*msg*/) override { }
376  void ForwardError(const std::string& /*msg*/) override { }
377  void ForwardFatal(const std::string& /*msg*/) override
378  {
379  m_Events.SetEvent(eEvent::IrreversibleState, true, m_CurrentTime);
380  }
381 
382  protected:
383  SEEventManager& m_Events;
384  SEScalarTime& m_CurrentTime;
385  };
386 END_NAMESPACE
DataTrack
Definition: DataTrack.h:17
Loggable
Definition: Logger.h:23
LoggerForward
Definition: Logger.h:60
Logger
Definition: Logger.h:71
PulseConfiguration
Pulse specific configuration parameters for all systems/equipment
Definition: PulseConfiguration.h:20
SEAction
Definition: SEAction.h:14
SEActionManager
Definition: SEActionManager.h:12
SEAdvanceHandler
Definition: SEAdvanceHandler.h:8
SEAnesthesiaMachine
Definition: SEAnesthesiaMachine.h:24
SEBagValveMask
Definition: SEBagValveMask.h:14
SEBloodChemistrySystem
Definition: SEBloodChemistrySystem.h:10
SECardiovascularSystem
Definition: SECardiovascularSystem.h:25
SEConditionManager
Definition: SEConditionManager.h:26
SEDataRequestManager
Definition: SEDataRequestManager.h:10
SEDataRequested
Definition: SEDataRequested.h:11
SEDrugSystem
Definition: SEDrugSystem.h:9
SEECMO
Definition: SEECMO.h:10
SEElectroCardioGram
Definition: SEElectroCardioGram.h:9
SEEndocrineSystem
Definition: SEEndocrineSystem.h:8
SEEnergySystem
Definition: SEEnergySystem.h:8
SEEngineConfiguration
Definition: SEEngineConfiguration.h:8
SEEngineStabilization::Controller
Definition: SEEngineStabilization.h:18
SEEngineTracker
Definition: SEDataRequestTracker.h:101
SEEngineTracker::GetValue
double GetValue(size_t idx) const override
Definition: SEDataRequestTracker.cpp:207
SEEnvironment
Definition: SEEnvironment.h:13
SEEventManager
Definition: SEEventManager.h:139
SEGastrointestinalSystem
Definition: SEGastrointestinalSystem.h:9
SEHepaticSystem
Definition: SEHepaticSystem.h:8
SEInhaler
Definition: SEInhaler.h:12
SEMechanicalVentilator
Definition: SEMechanicalVentilator.h:10
SENervousSystem
Definition: SENervousSystem.h:9
SEPatientAssessment
Data formed at a level of a clinicians report. This is high level data, such as a mean or generalized...
Definition: SEPatientAssessment.h:22
SEPatientConfiguration
Definition: SEPatientConfiguration.h:11
SEPatient
Definition: SEPatient.h:13
SERenalSystem
Definition: SERenalSystem.h:8
SERespiratorySystem
Definition: SERespiratorySystem.h:44
SEScalarTime
Definition: SEScalarTime.h:28
SETissueSystem
Definition: SETissueSystem.h:8
TimeUnit
Definition: SEScalarTime.h:8
pulse
Definition: Logger.h:14
pulse::eAirwayMode_Name
const std::string & eAirwayMode_Name(eAirwayMode m)
Definition: PBEnums.cpp:12

Distributed under the Apache License, Version 2.0.

See accompanying NOTICE file for details.