Building Medical Digital Twins with Pulse: Open Source Simulation Tools for Developers and Researchers
Webinar
×
PulseEngine.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 "cdm/PhysiologyEngine.h"
8 #include "cdm/utils/ScopedMutex.h"
9 
10 struct PULSE_DECL PulseBuildInformation
11 {
12  static std::string Time();
13  static std::string Hash();
14  static std::string Version();
15 };
16 
17 enum class eModelType { HumanAdultWholeBody=0, HumanAdultVentilationMechanics, HumanAdultHemodynamics };
18 PULSE_DECL bool eModelType_ValueOf(const std::string s, eModelType& t);
19 
20 PULSE_DECL std::unique_ptr<PhysiologyEngine> CreatePulseEngine(eModelType type = eModelType::HumanAdultWholeBody, Logger* logger = nullptr);
21 
22 namespace pulse
23 {
25  // All Compartments used by Pulse //
27 
28  class Graph
29  {
30  public:
31  DEFINE_STATIC_STRING(ActiveCardiovascular);
32  DEFINE_STATIC_STRING(Cardiovascular);
33  DEFINE_STATIC_STRING(Renal);
34  DEFINE_STATIC_STRING(Respiratory);
35  DEFINE_STATIC_STRING(RespiratoryAndAnesthesiaMachine);
36  DEFINE_STATIC_STRING(RespiratoryAndBagValveMask);
37  DEFINE_STATIC_STRING(RespiratoryAndInhaler);
38  DEFINE_STATIC_STRING(RespiratoryAndMechanicalVentilation);
39  DEFINE_STATIC_STRING(RespiratoryAndMechanicalVentilator);
40  DEFINE_STATIC_STRING(RespiratoryAndNasalCannula);
41  DEFINE_STATIC_STRING(RespiratoryAndNonRebreatherMask);
42  DEFINE_STATIC_STRING(RespiratoryAndSimpleMask);
43  DEFINE_STATIC_STRING(Aerosol);
44  DEFINE_STATIC_STRING(AerosolAndBagValveMask);
45  DEFINE_STATIC_STRING(AerosolAndInhaler);
46  DEFINE_STATIC_STRING(AerosolAndMechanicalVentilation);
47  DEFINE_STATIC_STRING(AerosolAndMechanicalVentilator);
48  DEFINE_STATIC_STRING(AnesthesiaMachine);
49  DEFINE_STATIC_STRING(BagValveMask);
50  DEFINE_STATIC_STRING(MechanicalVentilator);
51 
52  static const std::vector<std::string>& GetValues()
53  {
54  ScopedMutex lock;
55  if (_values.empty())
56  {
57  _values.push_back(ActiveCardiovascular);
58  _values.push_back(Cardiovascular);
59  _values.push_back(Renal);
60  _values.push_back(Respiratory);
61  _values.push_back(RespiratoryAndAnesthesiaMachine);
62  _values.push_back(RespiratoryAndBagValveMask);
63  _values.push_back(RespiratoryAndInhaler);
64  _values.push_back(RespiratoryAndMechanicalVentilation);
65  _values.push_back(RespiratoryAndMechanicalVentilator);
66  _values.push_back(RespiratoryAndNasalCannula);
67  _values.push_back(RespiratoryAndNonRebreatherMask);
68  _values.push_back(RespiratoryAndSimpleMask);
69  _values.push_back(Aerosol);
70  _values.push_back(AerosolAndBagValveMask);
71  _values.push_back(AerosolAndInhaler);
72  _values.push_back(AerosolAndMechanicalVentilation);
73  _values.push_back(AerosolAndMechanicalVentilator);
74  _values.push_back(BagValveMask);
75  _values.push_back(AnesthesiaMachine);
76  _values.push_back(MechanicalVentilator);
77  }
78  return _values;
79  }
80  static bool HasValue(const std::string& v)
81  {
82  return std::find(_values.begin(), _values.end(), v) != _values.end();
83  }
84  static void AddValue(const std::string& v)
85  {
86  if (!HasValue(v))
87  {
88  ScopedMutex lock;
89  _values.push_back(v);
90  }
91  }
92  protected:
93  static std::vector<std::string> _values;
94  };
95 
96  // TODO Rachel
97  class CerebrospinalFluidCompartment
98  {
99  public:
100  DEFINE_STATIC_STRING(IntracranialSpace);
101 
102  static const std::vector<std::string>& GetValues()
103  {
104  ScopedMutex lock;
105  if (_values.empty())
106  {
107  _values.push_back(IntracranialSpace);
108  }
109  return _values;
110  }
111  static bool HasValue(const std::string& v)
112  {
113  return std::find(_values.begin(), _values.end(), v) != _values.end();
114  }
115  static void AddValue(const std::string& v)
116  {
117  if (!HasValue(v))
118  {
119  ScopedMutex lock;
120  _values.push_back(v);
121  }
122  }
123  protected:
124  static std::vector<std::string> _values;
125  };
126 
127  class ChymeCompartment
128  {
129  public:
130  DEFINE_STATIC_STRING_EX(SmallIntestine, SmallIntestineChyme);
131 
132  static const std::vector<std::string>& GetValues()
133  {
134  ScopedMutex lock;
135  if (_values.empty())
136  {
137  _values.push_back(SmallIntestine);
138  }
139  return _values;
140  }
141  static bool HasValue(const std::string& v)
142  {
143  return std::find(_values.begin(), _values.end(), v) != _values.end();
144  }
145  static void AddValue(const std::string& v)
146  {
147  if (!HasValue(v))
148  {
149  ScopedMutex lock;
150  _values.push_back(v);
151  }
152  }
153  protected:
154  static std::vector<std::string> _values;
155  };
156 
157  class ChymeLink
158  {
159  public:
160  DEFINE_STATIC_STRING(SmallIntestineChymeToVasculature);
161 
162  static const std::vector<std::string>& GetValues()
163  {
164  ScopedMutex lock;
165  if (_values.empty())
166  {
167  _values.push_back(SmallIntestineChymeToVasculature);
168  }
169  return _values;
170  }
171  static bool HasValue(const std::string& v)
172  {
173  return std::find(_values.begin(), _values.end(), v) != _values.end();
174  }
175  static void AddValue(const std::string& v)
176  {
177  if (!HasValue(v))
178  {
179  ScopedMutex lock;
180  _values.push_back(v);
181  }
182  }
183  protected:
184  static std::vector<std::string> _values;
185  };
186 
187  class PulmonaryCompartment
188  {
189  public:
190  DEFINE_STATIC_STRING(Airway);
191  DEFINE_STATIC_STRING(Stomach);
192  DEFINE_STATIC_STRING(Pharynx);
193  DEFINE_STATIC_STRING(Carina);
194  DEFINE_STATIC_STRING_EX(Lungs, PulmonaryLungs);
195  DEFINE_STATIC_STRING(Alveoli);
196  DEFINE_STATIC_STRING(AlveolarDeadSpace);
197  DEFINE_STATIC_STRING(AnatomicDeadSpace);
198  DEFINE_STATIC_STRING_EX(LeftLung, LeftLungPulmonary);
199  /***/DEFINE_STATIC_STRING(LeftAnatomicDeadSpace);
200  /***/DEFINE_STATIC_STRING(LeftAlveolarDeadSpace);
201  /***/DEFINE_STATIC_STRING(LeftAlveoli);
202  DEFINE_STATIC_STRING_EX(RightLung, RightLungPulmonary);
203  /***/DEFINE_STATIC_STRING(RightAnatomicDeadSpace);
204  /***/DEFINE_STATIC_STRING(RightAlveolarDeadSpace);
205  /***/DEFINE_STATIC_STRING(RightAlveoli);
206  DEFINE_STATIC_STRING(PleuralCavity);
207  DEFINE_STATIC_STRING(LeftPleuralCavity);
208  DEFINE_STATIC_STRING(RightPleuralCavity);
209 
210  DEFINE_STATIC_STRING(LeftAlveoliLeak);
211  DEFINE_STATIC_STRING(LeftChestLeak);
212  DEFINE_STATIC_STRING(LeftNeedle);
213  DEFINE_STATIC_STRING(RightAlveoliLeak);
214  DEFINE_STATIC_STRING(RightChestLeak);
215  DEFINE_STATIC_STRING(RightNeedle);
216 
217  static const std::vector<std::string>& GetValues()
218  {
219  ScopedMutex lock;
220  if (_values.empty())
221  {
222  _values.push_back(Airway);
223  _values.push_back(Stomach);
224  _values.push_back(Pharynx);
225  _values.push_back(Carina);
226  _values.push_back(Lungs);
227  _values.push_back(Alveoli);
228  _values.push_back(AlveolarDeadSpace);
229  _values.push_back(AnatomicDeadSpace);
230  _values.push_back(LeftLung);
231  _values.push_back(LeftAnatomicDeadSpace);
232  _values.push_back(LeftAlveolarDeadSpace);
233  _values.push_back(LeftAlveoli);
234  _values.push_back(RightLung);
235  _values.push_back(RightAnatomicDeadSpace);
236  _values.push_back(RightAlveolarDeadSpace);
237  _values.push_back(RightAlveoli);
238  _values.push_back(PleuralCavity);
239  _values.push_back(LeftPleuralCavity);
240  _values.push_back(RightPleuralCavity);
241  _values.push_back(LeftAlveoliLeak);
242  _values.push_back(LeftChestLeak);
243  _values.push_back(LeftNeedle);
244  _values.push_back(RightAlveoliLeak);
245  _values.push_back(RightChestLeak);
246  _values.push_back(RightNeedle);
247  }
248  return _values;
249  }
250  static bool HasValue(const std::string& v)
251  {
252  return std::find(_values.begin(), _values.end(), v) != _values.end();
253  }
254  static void AddValue(const std::string& v)
255  {
256  if (!HasValue(v))
257  {
258  ScopedMutex lock;
259  _values.push_back(v);
260  }
261  }
262  protected:
263  static std::vector<std::string> _values;
264  };
265 
266  class PulmonaryLink
267  {
268  public:
269  DEFINE_STATIC_STRING(EnvironmentToAirway);
270  DEFINE_STATIC_STRING(AirwayToPharynx);
271  DEFINE_STATIC_STRING(AirwayToStomach);
272  DEFINE_STATIC_STRING(PharynxToCarina);
273  DEFINE_STATIC_STRING(PharynxToEnvironment);
274  DEFINE_STATIC_STRING(CarinaToLeftAnatomicDeadSpace);
275  DEFINE_STATIC_STRING(LeftAnatomicDeadSpaceToLeftAlveolarDeadSpace);
276  DEFINE_STATIC_STRING(LeftAlveolarDeadSpaceToLeftAlveoli);
277  DEFINE_STATIC_STRING(CarinaToRightAnatomicDeadSpace);
278  DEFINE_STATIC_STRING(RightAnatomicDeadSpaceToRightAlveolarDeadSpace);
279  DEFINE_STATIC_STRING(RightAlveolarDeadSpaceToRightAlveoli);
280  DEFINE_STATIC_STRING(EnvironmentToLeftChestLeak);
281  DEFINE_STATIC_STRING(EnvironmentToRightChestLeak);
282  DEFINE_STATIC_STRING(LeftAlveoliLeakToLeftPleural);
283  DEFINE_STATIC_STRING(LeftAlveoliToLeftAlveoliLeak);
284  DEFINE_STATIC_STRING(LeftChestLeakToLeftPleural);
285  DEFINE_STATIC_STRING(LeftNeedleToLeftPleural);
286  DEFINE_STATIC_STRING(EnvironmentToLeftNeedle);
287  DEFINE_STATIC_STRING(RightAlveoliLeakToRightPleural);
288  DEFINE_STATIC_STRING(RightAlveoliToRightAlveoliLeak);
289  DEFINE_STATIC_STRING(RightChestLeakToRightPleural);
290  DEFINE_STATIC_STRING(RightNeedleToRightPleural);
291  DEFINE_STATIC_STRING(EnvironmentToRightNeedle);
292 
293  static const std::vector<std::string>& GetValues()
294  {
295  ScopedMutex lock;
296  if (_values.empty())
297  {
298  _values.push_back(EnvironmentToAirway);
299  _values.push_back(AirwayToPharynx);
300  _values.push_back(AirwayToStomach);
301  _values.push_back(PharynxToCarina);
302  _values.push_back(PharynxToEnvironment);
303  _values.push_back(CarinaToLeftAnatomicDeadSpace);
304  _values.push_back(LeftAnatomicDeadSpaceToLeftAlveolarDeadSpace);
305  _values.push_back(LeftAlveolarDeadSpaceToLeftAlveoli);
306  _values.push_back(CarinaToRightAnatomicDeadSpace);
307  _values.push_back(RightAnatomicDeadSpaceToRightAlveolarDeadSpace);
308  _values.push_back(RightAlveolarDeadSpaceToRightAlveoli);
309  _values.push_back(EnvironmentToLeftChestLeak);
310  _values.push_back(EnvironmentToRightChestLeak);
311  _values.push_back(LeftAlveoliLeakToLeftPleural);
312  _values.push_back(LeftAlveoliToLeftAlveoliLeak);
313  _values.push_back(LeftChestLeakToLeftPleural);
314  _values.push_back(LeftNeedleToLeftPleural);
315  _values.push_back(EnvironmentToLeftNeedle);
316  _values.push_back(RightAlveoliLeakToRightPleural);
317  _values.push_back(RightAlveoliToRightAlveoliLeak);
318  _values.push_back(RightChestLeakToRightPleural);
319  _values.push_back(RightNeedleToRightPleural);
320  _values.push_back(EnvironmentToRightNeedle);
321  }
322  return _values;
323  }
324  static bool HasValue(const std::string& v)
325  {
326  return std::find(_values.begin(), _values.end(), v)!=_values.end();
327  }
328  static void AddValue(const std::string& v)
329  {
330  if (!HasValue(v))
331  {
332  ScopedMutex lock;
333  _values.push_back(v);
334  }
335  }
336  protected:
337  static std::vector<std::string> _values;
338  };
339 
340  class ExpandedPulmonaryCompartment
341  {
342  public:
343 
344  static const std::vector<std::string>& GetValues()
345  {
346  ScopedMutex lock;
347  if (_values.empty())
348  {
349 
350  }
351  return _values;
352  }
353  static bool HasValue(const std::string& v)
354  {
355  return std::find(_values.begin(), _values.end(), v) != _values.end();
356  }
357  static void AddValue(const std::string& v)
358  {
359  if (!HasValue(v))
360  {
361  ScopedMutex lock;
362  _values.push_back(v);
363  }
364  }
365  protected:
366  static std::vector<std::string> _values;
367  };
368 
369  class ExpandedPulmonaryLink
370  {
371  public:
372 
373  static const std::vector<std::string>& GetValues()
374  {
375  ScopedMutex lock;
376  if (_values.empty())
377  {
378 
379  }
380  return _values;
381  }
382  static bool HasValue(const std::string& v)
383  {
384  return std::find(_values.begin(), _values.end(), v) != _values.end();
385  }
386  static void AddValue(const std::string& v)
387  {
388  if (!HasValue(v))
389  {
390  ScopedMutex lock;
391  _values.push_back(v);
392  }
393  }
394  protected:
395  static std::vector<std::string> _values;
396  };
397 
398  class TissueCompartment
399  {
400  public:
401  DEFINE_STATIC_STRING_EX(Bone, BoneTissue);
402  DEFINE_STATIC_STRING_EX(Brain, BrainTissue);
403  DEFINE_STATIC_STRING_EX(Fat, FatTissue);
404  DEFINE_STATIC_STRING_EX(Gut, GutTissue);
405  DEFINE_STATIC_STRING_EX(LeftKidney, LeftKidneyTissue);
406  DEFINE_STATIC_STRING_EX(LeftLung, LeftLungTissue);
407  DEFINE_STATIC_STRING_EX(Liver, LiverTissue);
408  DEFINE_STATIC_STRING_EX(Muscle, MuscleTissue);
409  DEFINE_STATIC_STRING_EX(Myocardium, MyocardiumTissue);
410  DEFINE_STATIC_STRING_EX(RightKidney, RightKidneyTissue);
411  DEFINE_STATIC_STRING_EX(RightLung, RightLungTissue);
412  DEFINE_STATIC_STRING_EX(Skin, SkinTissue);
413  DEFINE_STATIC_STRING_EX(Spleen, SpleenTissue);
414 
415  static const std::vector<std::string>& GetValues()
416  {
417  ScopedMutex lock;
418  if (_values.empty())
419  {
420  _values.push_back(Bone);
421  _values.push_back(Brain);
422  _values.push_back(Fat);
423  _values.push_back(Gut);
424  _values.push_back(LeftKidney);
425  _values.push_back(LeftLung);
426  _values.push_back(Liver);
427  _values.push_back(Muscle);
428  _values.push_back(Myocardium);
429  _values.push_back(RightKidney);
430  _values.push_back(RightLung);
431  _values.push_back(Skin);
432  _values.push_back(Spleen);
433  }
434  return _values;
435  }
436  static bool HasValue(const std::string& v)
437  {
438  return std::find(_values.begin(), _values.end(), v) != _values.end();
439  }
440  static void AddValue(const std::string& v)
441  {
442  if (!HasValue(v))
443  {
444  ScopedMutex lock;
445  _values.push_back(v);
446  }
447  }
448  protected:
449  static std::vector<std::string> _values;
450  };
451 
452  class ExtravascularCompartment
453  {
454  public:
455  DEFINE_STATIC_STRING_EX(BoneExtracellular, BoneTissueExtracellular);
456  DEFINE_STATIC_STRING_EX(BrainExtracellular, BrainTissueExtracellular);
457  DEFINE_STATIC_STRING_EX(FatExtracellular, FatTissueExtracellular);
458  DEFINE_STATIC_STRING_EX(GutExtracellular, GutTissueExtracellular);
459  DEFINE_STATIC_STRING_EX(LeftKidneyExtracellular, LeftKidneyTissueExtracellular);
460  DEFINE_STATIC_STRING_EX(LeftLungExtracellular, LeftLungTissueExtracellular);
461  DEFINE_STATIC_STRING_EX(LiverExtracellular, LiverTissueExtracellular);
462  DEFINE_STATIC_STRING_EX(MuscleExtracellular, MuscleTissueExtracellular);
463  DEFINE_STATIC_STRING_EX(MyocardiumExtracellular, MyocardiumTissueExtracellular);
464  DEFINE_STATIC_STRING_EX(RightKidneyExtracellular, RightKidneyTissueExtracellular);
465  DEFINE_STATIC_STRING_EX(RightLungExtracellular, RightLungTissueExtracellular);
466  DEFINE_STATIC_STRING_EX(SkinExtracellular, SkinTissueExtracellular);
467  DEFINE_STATIC_STRING_EX(SpleenExtracellular, SpleenTissueExtracellular);
468 
469  DEFINE_STATIC_STRING_EX(BoneIntracellular, BoneTissueIntracellular);
470  DEFINE_STATIC_STRING_EX(BrainIntracellular, BrainTissueIntracellular);
471  DEFINE_STATIC_STRING_EX(FatIntracellular, FatTissueIntracellular);
472  DEFINE_STATIC_STRING_EX(GutIntracellular, GutTissueIntracellular);
473  DEFINE_STATIC_STRING_EX(LeftKidneyIntracellular, LeftKidneyTissueIntracellular);
474  DEFINE_STATIC_STRING_EX(LeftLungIntracellular, LeftLungTissueIntracellular);
475  DEFINE_STATIC_STRING_EX(LiverIntracellular, LiverTissueIntracellular);
476  DEFINE_STATIC_STRING_EX(MuscleIntracellular, MuscleTissueIntracellular);
477  DEFINE_STATIC_STRING_EX(MyocardiumIntracellular, MyocardiumTissueIntracellular);
478  DEFINE_STATIC_STRING_EX(RightKidneyIntracellular, RightKidneyTissueIntracellular);
479  DEFINE_STATIC_STRING_EX(RightLungIntracellular, RightLungTissueIntracellular);
480  DEFINE_STATIC_STRING_EX(SkinIntracellular, SkinTissueIntracellular);
481  DEFINE_STATIC_STRING_EX(SpleenIntracellular, SpleenTissueIntracellular);
482 
483  static const std::vector<std::string>& GetValues()
484  {
485  ScopedMutex lock;
486  if (_values.empty())
487  {
488  _values.push_back(BoneExtracellular);
489  _values.push_back(BrainExtracellular);
490  _values.push_back(FatExtracellular);
491  _values.push_back(GutExtracellular);
492  _values.push_back(LeftKidneyExtracellular);
493  _values.push_back(LeftLungExtracellular);
494  _values.push_back(LiverExtracellular);
495  _values.push_back(MuscleExtracellular);
496  _values.push_back(MyocardiumExtracellular);
497  _values.push_back(RightKidneyExtracellular);
498  _values.push_back(RightLungExtracellular);
499  _values.push_back(SkinExtracellular);
500  _values.push_back(SpleenExtracellular);
501 
502  _values.push_back(BoneIntracellular);
503  _values.push_back(BrainIntracellular);
504  _values.push_back(FatIntracellular);
505  _values.push_back(GutIntracellular);
506  _values.push_back(LeftKidneyIntracellular);
507  _values.push_back(LeftLungIntracellular);
508  _values.push_back(LiverIntracellular);
509  _values.push_back(MuscleIntracellular);
510  _values.push_back(MyocardiumIntracellular);
511  _values.push_back(RightKidneyIntracellular);
512  _values.push_back(RightLungIntracellular);
513  _values.push_back(SkinIntracellular);
514  _values.push_back(SpleenIntracellular);
515  }
516  return _values;
517  }
518  static bool HasValue(const std::string& v)
519  {
520  return std::find(_values.begin(), _values.end(), v) != _values.end();
521  }
522  static void AddValue(const std::string& v)
523  {
524  if (!HasValue(v))
525  {
526  ScopedMutex lock;
527  _values.push_back(v);
528  }
529  }
530  protected:
531  static std::vector<std::string> _values;
532  };
533 
534  class VascularCompartment
535  {
536  public:
537  // Cardio
538  DEFINE_STATIC_STRING(Aorta);
539  DEFINE_STATIC_STRING(Heart);
540  DEFINE_STATIC_STRING_EX(Myocardium, MyocardiumVasculature);
541  DEFINE_STATIC_STRING(LeftHeart);
542  DEFINE_STATIC_STRING(RightHeart);
543  DEFINE_STATIC_STRING(Pericardium);
544  DEFINE_STATIC_STRING(VenaCava);
545  // Pulmonary
546  DEFINE_STATIC_STRING(PulmonaryArteries);
547  DEFINE_STATIC_STRING(PulmonaryCapillaries);
548  DEFINE_STATIC_STRING(PulmonaryVeins);
549  DEFINE_STATIC_STRING_EX(Lungs, LungsVasculature);
550  DEFINE_STATIC_STRING_EX(LeftLung, LeftLungVasculature);
551  /***/DEFINE_STATIC_STRING(LeftPulmonaryArteries);
552  /***/DEFINE_STATIC_STRING(LeftPulmonaryCapillaries);
553  /***/DEFINE_STATIC_STRING(LeftPulmonaryVeins);
554  DEFINE_STATIC_STRING_EX(RightLung, RightLungVasculature);
555  /***/DEFINE_STATIC_STRING(RightPulmonaryArteries);
556  /***/DEFINE_STATIC_STRING(RightPulmonaryCapillaries);
557  /***/DEFINE_STATIC_STRING(RightPulmonaryVeins);
558  // Renal
559  DEFINE_STATIC_STRING_EX(Kidneys, KidneyVasculature);
560  DEFINE_STATIC_STRING_EX(LeftKidney, LeftKidneyVasculature);
561  /***/DEFINE_STATIC_STRING(LeftRenalArtery);
562  /***/DEFINE_STATIC_STRING(LeftNephron);
563  /*********/DEFINE_STATIC_STRING(LeftAfferentArteriole);
564  /*********/DEFINE_STATIC_STRING(LeftGlomerularCapillaries);
565  /*********/DEFINE_STATIC_STRING(LeftEfferentArteriole);
566  /*********/DEFINE_STATIC_STRING(LeftPeritubularCapillaries);
567  /*********/DEFINE_STATIC_STRING(LeftBowmansCapsules);
568  /*********/DEFINE_STATIC_STRING(LeftTubules);
569  /***/DEFINE_STATIC_STRING(LeftRenalVein);
570  DEFINE_STATIC_STRING_EX(RightKidney, RightKidneyVasculature);
571  /***/DEFINE_STATIC_STRING(RightRenalArtery);
572  /***/DEFINE_STATIC_STRING(RightNephron);
573  /*********/DEFINE_STATIC_STRING(RightAfferentArteriole);
574  /*********/DEFINE_STATIC_STRING(RightGlomerularCapillaries);
575  /*********/DEFINE_STATIC_STRING(RightEfferentArteriole);
576  /*********/DEFINE_STATIC_STRING(RightPeritubularCapillaries);
577  /*********/DEFINE_STATIC_STRING(RightBowmansCapsules);
578  /*********/DEFINE_STATIC_STRING(RightTubules);
579  /***/DEFINE_STATIC_STRING(RightRenalVein);
580  // General Organs and Periphery
581  DEFINE_STATIC_STRING_EX(Bone, BoneVasculature);
582  DEFINE_STATIC_STRING_EX(Brain, BrainVasculature);
583  DEFINE_STATIC_STRING_EX(Fat, FatVasculature);
584  DEFINE_STATIC_STRING_EX(Gut, GutVasculature);
585  DEFINE_STATIC_STRING_EX(Splanchnic, SplanchnicVasculature);
586  DEFINE_STATIC_STRING_EX(SmallIntestine, SmallIntestineVasculature);
587  DEFINE_STATIC_STRING_EX(LargeIntestine, LargeIntestineVasculature);
588  DEFINE_STATIC_STRING_EX(Liver, LiverVasculature);
589  DEFINE_STATIC_STRING_EX(Spleen, SpleenVasculature);
590  DEFINE_STATIC_STRING_EX(Skin, SkinVasculature);
591  DEFINE_STATIC_STRING_EX(Muscle, MuscleVasculature);
592  DEFINE_STATIC_STRING_EX(LeftArm, LeftArmVasculature);
593  DEFINE_STATIC_STRING_EX(LeftLeg, LeftLegVasculature);
594  DEFINE_STATIC_STRING_EX(RightArm, RightArmVasculature);
595  DEFINE_STATIC_STRING_EX(RightLeg, RightLegVasculature);
596  DEFINE_STATIC_STRING(Abdomen);
597  DEFINE_STATIC_STRING(AbdominalCavity);
598 
599  DEFINE_STATIC_STRING(Ground);
600 
601 
602  static const std::vector<std::string>& GetValues()
603  {
604  ScopedMutex lock;
605  if (_values.empty())
606  {
607  _values.push_back(Aorta);
608  _values.push_back(Abdomen);
609  _values.push_back(Heart);
610  _values.push_back(Myocardium);
611  _values.push_back(LeftHeart);
612  _values.push_back(RightHeart);
613  _values.push_back(Pericardium);
614  _values.push_back(VenaCava);
615  _values.push_back(PulmonaryArteries);
616  _values.push_back(PulmonaryCapillaries);
617  _values.push_back(PulmonaryVeins);
618  _values.push_back(Lungs);
619  _values.push_back(LeftLung);
620  _values.push_back(LeftPulmonaryArteries);
621  _values.push_back(LeftPulmonaryCapillaries);
622  _values.push_back(LeftPulmonaryVeins);
623  _values.push_back(RightLung);
624  _values.push_back(RightPulmonaryArteries);
625  _values.push_back(RightPulmonaryCapillaries);
626  _values.push_back(RightPulmonaryVeins);
627  _values.push_back(Kidneys);
628  _values.push_back(LeftKidney);
629  _values.push_back(LeftRenalArtery);
630  _values.push_back(LeftNephron);
631  _values.push_back(LeftAfferentArteriole);
632  _values.push_back(LeftGlomerularCapillaries);
633  _values.push_back(LeftEfferentArteriole);
634  _values.push_back(LeftPeritubularCapillaries);
635  _values.push_back(LeftBowmansCapsules);
636  _values.push_back(LeftTubules);
637  _values.push_back(LeftRenalVein);
638  _values.push_back(RightKidney);
639  _values.push_back(RightRenalArtery);
640  _values.push_back(RightNephron);
641  _values.push_back(RightAfferentArteriole);
642  _values.push_back(RightGlomerularCapillaries);
643  _values.push_back(RightEfferentArteriole);
644  _values.push_back(RightPeritubularCapillaries);
645  _values.push_back(RightBowmansCapsules);
646  _values.push_back(RightTubules);
647  _values.push_back(RightRenalVein);
648  _values.push_back(Bone);
649  _values.push_back(Brain);
650  _values.push_back(Fat);
651  _values.push_back(Gut);
652  _values.push_back(Splanchnic);
653  _values.push_back(SmallIntestine);
654  _values.push_back(LargeIntestine);
655  _values.push_back(Liver);
656  _values.push_back(Spleen);
657  _values.push_back(Skin);
658  _values.push_back(Muscle);
659  _values.push_back(LeftArm);
660  _values.push_back(LeftLeg);
661  _values.push_back(RightArm);
662  _values.push_back(RightLeg);
663  //_values.push_back(Ground);
664  }
665  return _values;
666  }
667  static bool HasValue(const std::string& v)
668  {
669  return std::find(_values.begin(), _values.end(), v) != _values.end();
670  }
671  static void AddValue(const std::string& v)
672  {
673  if (!HasValue(v))
674  {
675  ScopedMutex lock;
676  _values.push_back(v);
677  }
678  }
679  protected:
680  static std::vector<std::string> _values;
681  };
682 
683  class VascularLink
684  {
685  public:
686  // Heart and Lungs
687  DEFINE_STATIC_STRING(VenaCavaToRightHeart);
688  DEFINE_STATIC_STRING(RightHeartToLeftPulmonaryArteries);
689  DEFINE_STATIC_STRING(LeftPulmonaryArteriesToCapillaries);
690  DEFINE_STATIC_STRING(LeftPulmonaryArteriesToVeins);
691  DEFINE_STATIC_STRING(LeftPulmonaryCapillariesToVeins);
692  DEFINE_STATIC_STRING(LeftPulmonaryVeinsLeak);
693  DEFINE_STATIC_STRING(LeftPulmonaryVeinsToLeftHeart);
694  DEFINE_STATIC_STRING(RightHeartToRightPulmonaryArteries);
695  DEFINE_STATIC_STRING(RightPulmonaryArteriesToCapillaries);
696  DEFINE_STATIC_STRING(RightPulmonaryArteriesToVeins);
697  DEFINE_STATIC_STRING(RightPulmonaryCapillariesToVeins);
698  DEFINE_STATIC_STRING(RightPulmonaryVeinsLeak);
699  DEFINE_STATIC_STRING(RightPulmonaryVeinsToLeftHeart);
700  DEFINE_STATIC_STRING(LeftHeartToAorta);
701  // Bone
702  DEFINE_STATIC_STRING(AortaToBone);
703  DEFINE_STATIC_STRING(BoneToVenaCava);
704  // Brain
705  DEFINE_STATIC_STRING(AortaToBrain);
706  DEFINE_STATIC_STRING(BrainToVenaCava);
707  // Fat
708  DEFINE_STATIC_STRING(AortaToFat);
709  DEFINE_STATIC_STRING(FatToVenaCava);
710  // Large Intestine
711  DEFINE_STATIC_STRING(AortaToLargeIntestine);
712  DEFINE_STATIC_STRING(LargeIntestineToLiver);
713  // Left Arm
714  DEFINE_STATIC_STRING(AortaToLeftArm);
715  DEFINE_STATIC_STRING(LeftArmToVenaCava);
716  // Left Kidney
717  DEFINE_STATIC_STRING(AortaToLeftKidney);
718  DEFINE_STATIC_STRING(LeftKidneyToVenaCava);
719  // Left Leg
720  DEFINE_STATIC_STRING(AortaToLeftLeg);
721  DEFINE_STATIC_STRING(LeftLegToVenaCava);
722  // Liver
723  DEFINE_STATIC_STRING(AortaToLiver);
724  DEFINE_STATIC_STRING(LiverToVenaCava);
725  // Muscle
726  DEFINE_STATIC_STRING(AortaToMuscle);
727  DEFINE_STATIC_STRING(MuscleToVenaCava);
728  // Myocardium
729  DEFINE_STATIC_STRING(AortaToMyocardium);
730  DEFINE_STATIC_STRING(MyocardiumToVenaCava);
731  // Right Arm
732  DEFINE_STATIC_STRING(AortaToRightArm);
733  DEFINE_STATIC_STRING(RightArmToVenaCava);
734  // Right Kidney
735  DEFINE_STATIC_STRING(AortaToRightKidney);
736  DEFINE_STATIC_STRING(RightKidneyToVenaCava);
737  // Right Leg
738  DEFINE_STATIC_STRING(AortaToRightLeg);
739  DEFINE_STATIC_STRING(RightLegToVenaCava);
740  // Skin
741  DEFINE_STATIC_STRING(AortaToSkin);
742  DEFINE_STATIC_STRING(SkinToVenaCava);
743  // Small Intestine
744  DEFINE_STATIC_STRING(AortaToSmallIntestine);
745  DEFINE_STATIC_STRING(SmallIntestineToLiver);
746  // Splanchnic
747  DEFINE_STATIC_STRING(AortaToSplanchnic);
748  DEFINE_STATIC_STRING(SplanchnicToLiver);
749  // Spleen
750  DEFINE_STATIC_STRING(AortaToSpleen);
751  DEFINE_STATIC_STRING(SpleenToLiver);
752 
753  // Hemorrhage and IV
754  DEFINE_STATIC_STRING(VenaCavaIV);
755 
756  // Vascular To Tissue Links
757  DEFINE_STATIC_STRING(BoneVascularToTissue);
758  DEFINE_STATIC_STRING(BrainVascularToTissue);
759  DEFINE_STATIC_STRING(FatVascularToTissue);
760  DEFINE_STATIC_STRING(SmallIntestineVascularToTissue);
761  DEFINE_STATIC_STRING(LargeIntestineVascularToTissue);
762  DEFINE_STATIC_STRING(SplanchnicVascularToTissue);
763  DEFINE_STATIC_STRING(LeftKidneyVascularToTissue);
764  DEFINE_STATIC_STRING(LeftLungVascularToTissue);
765  DEFINE_STATIC_STRING(LiverVascularToTissue);
766  DEFINE_STATIC_STRING(MuscleVascularToTissue);
767  DEFINE_STATIC_STRING(MyocardiumVascularToTissue);
768  DEFINE_STATIC_STRING(RightKidneyVascularToTissue);
769  DEFINE_STATIC_STRING(RightLungVascularToTissue);
770  DEFINE_STATIC_STRING(SkinVascularToTissue);
771  DEFINE_STATIC_STRING(SpleenVascularToTissue);
772 
773  // Renal Links
774  // Reusing 'AortaToLeftKidney' to connect the Aorta To Left Renal Artery
775  DEFINE_STATIC_STRING(LeftRenalArteryToAfferentArteriole);
776  DEFINE_STATIC_STRING(LeftAfferentArterioleToGlomerularCapillaries);
777  DEFINE_STATIC_STRING(LeftGlomerularCapillariesToEfferentArteriole);
778  DEFINE_STATIC_STRING(LeftGlomerularCapillariesToBowmansCapsules);
779  DEFINE_STATIC_STRING(LeftBowmansCapsulesToTubules);
780  DEFINE_STATIC_STRING(LeftTubulesToPeritubularCapillaries);
781  DEFINE_STATIC_STRING(LeftEfferentArterioleToPeritubularCapillaries);
782  DEFINE_STATIC_STRING(LeftPeritubularCapillariesToRenalVein);
783  // Reusing 'LeftKidneyToVenaCava' to connect the Left Renal Vein To Vena Cava
784 
785  // Reusing 'AortaToRightKidney' to connect the Aorta To Right Renal Artery
786  DEFINE_STATIC_STRING(RightRenalArteryToAfferentArteriole);
787  DEFINE_STATIC_STRING(RightAfferentArterioleToGlomerularCapillaries);
788  DEFINE_STATIC_STRING(RightGlomerularCapillariesToEfferentArteriole);
789  DEFINE_STATIC_STRING(RightGlomerularCapillariesToBowmansCapsules);
790  DEFINE_STATIC_STRING(RightBowmansCapsulesToTubules);
791  DEFINE_STATIC_STRING(RightTubulesToPeritubularCapillaries);
792  DEFINE_STATIC_STRING(RightEfferentArterioleToPeritubularCapillaries);
793  DEFINE_STATIC_STRING(RightPeritubularCapillariesToRenalVein);
794  // Reusing 'RightKidneyToVenaCava' to connect the Right Renal Vein To Vena Cava);
795 
796 
797  static const std::vector<std::string>& GetValues()
798  {
799  ScopedMutex lock;
800  if (_values.empty())
801  {
802  _values.push_back(VenaCavaToRightHeart);
803  _values.push_back(RightHeartToLeftPulmonaryArteries);
804  _values.push_back(LeftPulmonaryArteriesToCapillaries);
805  _values.push_back(LeftPulmonaryArteriesToVeins);
806  _values.push_back(LeftPulmonaryCapillariesToVeins);
807  _values.push_back(LeftPulmonaryVeinsLeak);
808  _values.push_back(LeftPulmonaryVeinsToLeftHeart);
809  _values.push_back(RightHeartToRightPulmonaryArteries);
810  _values.push_back(RightPulmonaryArteriesToCapillaries);
811  _values.push_back(RightPulmonaryArteriesToVeins);
812  _values.push_back(RightPulmonaryCapillariesToVeins);
813  _values.push_back(RightPulmonaryVeinsLeak);
814  _values.push_back(RightPulmonaryVeinsToLeftHeart);
815  _values.push_back(LeftHeartToAorta);
816  _values.push_back(AortaToBone);
817  _values.push_back(BoneToVenaCava);
818  _values.push_back(AortaToBrain);
819  _values.push_back(BrainToVenaCava);
820  _values.push_back(AortaToFat);
821  _values.push_back(FatToVenaCava);
822  _values.push_back(AortaToLargeIntestine);
823  _values.push_back(LargeIntestineToLiver);
824  _values.push_back(AortaToLeftArm);
825  _values.push_back(LeftArmToVenaCava);
826  _values.push_back(AortaToLeftKidney);
827  _values.push_back(LeftKidneyToVenaCava);
828  _values.push_back(AortaToLeftLeg);
829  _values.push_back(LeftLegToVenaCava);
830  _values.push_back(AortaToLiver);
831  _values.push_back(LiverToVenaCava);
832  _values.push_back(AortaToMuscle);
833  _values.push_back(MuscleToVenaCava);
834  _values.push_back(AortaToMyocardium);
835  _values.push_back(MyocardiumToVenaCava);
836  _values.push_back(AortaToRightArm);
837  _values.push_back(RightArmToVenaCava);
838  _values.push_back(AortaToRightKidney);
839  _values.push_back(RightKidneyToVenaCava);
840  _values.push_back(AortaToRightLeg);
841  _values.push_back(RightLegToVenaCava);
842  _values.push_back(AortaToSkin);
843  _values.push_back(SkinToVenaCava);
844  _values.push_back(AortaToSmallIntestine);
845  _values.push_back(SmallIntestineToLiver);
846  _values.push_back(AortaToSplanchnic);
847  _values.push_back(SplanchnicToLiver);
848  _values.push_back(AortaToSpleen);
849  _values.push_back(SpleenToLiver);
850 
851  _values.push_back(BoneVascularToTissue);
852  _values.push_back(BrainVascularToTissue);
853  _values.push_back(FatVascularToTissue);
854  _values.push_back(SmallIntestineVascularToTissue);
855  _values.push_back(LargeIntestineVascularToTissue);
856  _values.push_back(SplanchnicVascularToTissue);
857  _values.push_back(LeftKidneyVascularToTissue);
858  _values.push_back(LeftLungVascularToTissue);
859  _values.push_back(LiverVascularToTissue);
860  _values.push_back(MuscleVascularToTissue);
861  _values.push_back(MyocardiumVascularToTissue);
862  _values.push_back(RightKidneyVascularToTissue);
863  _values.push_back(RightLungVascularToTissue);
864  _values.push_back(SkinVascularToTissue);
865  _values.push_back(SpleenVascularToTissue);
866 
867  _values.push_back(LeftRenalArteryToAfferentArteriole);
868  _values.push_back(LeftAfferentArterioleToGlomerularCapillaries);
869  _values.push_back(LeftGlomerularCapillariesToEfferentArteriole);
870  _values.push_back(LeftGlomerularCapillariesToBowmansCapsules);
871  _values.push_back(LeftBowmansCapsulesToTubules);
872  _values.push_back(LeftTubulesToPeritubularCapillaries);
873  _values.push_back(LeftEfferentArterioleToPeritubularCapillaries);
874  _values.push_back(LeftPeritubularCapillariesToRenalVein);
875  _values.push_back(RightRenalArteryToAfferentArteriole);
876  _values.push_back(RightAfferentArterioleToGlomerularCapillaries);
877  _values.push_back(RightGlomerularCapillariesToEfferentArteriole);
878  _values.push_back(RightGlomerularCapillariesToBowmansCapsules);
879  _values.push_back(RightBowmansCapsulesToTubules);
880  _values.push_back(RightTubulesToPeritubularCapillaries);
881  _values.push_back(RightEfferentArterioleToPeritubularCapillaries);
882  _values.push_back(RightPeritubularCapillariesToRenalVein);
883  }
884  return _values;
885  }
886  static bool HasValue(const std::string& v)
887  {
888  return std::find(_values.begin(), _values.end(), v) != _values.end();
889  }
890  static void AddValue(const std::string& v)
891  {
892  if (!HasValue(v))
893  {
894  ScopedMutex lock;
895  _values.push_back(v);
896  }
897  }
898  protected:
899  static std::vector<std::string> _values;
900  };
901 
902  class ExpandedVascularCompartment
903  {
904  public:
905  // Cardio
906  DEFINE_STATIC_STRING(Aorta);
907  DEFINE_STATIC_STRING(ArterialBuffer);
908  DEFINE_STATIC_STRING(Heart);
909  DEFINE_STATIC_STRING_EX(Myocardium, MyocardiumVasculature);
910  DEFINE_STATIC_STRING(LeftHeart);
911  DEFINE_STATIC_STRING(RightHeart);
912  DEFINE_STATIC_STRING(Pericardium);
913  DEFINE_STATIC_STRING(VenaCava);
914  DEFINE_STATIC_STRING(VenousBuffer);
915  // Pulmonary
916  DEFINE_STATIC_STRING(PulmonaryArteries);
917  DEFINE_STATIC_STRING(PulmonaryCapillaries);
918  DEFINE_STATIC_STRING(PulmonaryVeins);
919  DEFINE_STATIC_STRING_EX(Lungs, LungsVasculature);
920  DEFINE_STATIC_STRING_EX(LeftLung, LeftLungVasculature);
921  /***/DEFINE_STATIC_STRING(LeftPulmonaryArteries);
922  /***/DEFINE_STATIC_STRING(LeftPulmonaryCapillaries);
923  /***/DEFINE_STATIC_STRING(LeftPulmonaryVeins);
924  DEFINE_STATIC_STRING_EX(RightLung, RightLungVasculature);
925  /***/DEFINE_STATIC_STRING(RightPulmonaryArteries);
926  /***/DEFINE_STATIC_STRING(RightPulmonaryCapillaries);
927  /***/DEFINE_STATIC_STRING(RightPulmonaryVeins);
928  // Renal
929  DEFINE_STATIC_STRING_EX(Kidneys, KidneyVasculature);
930  DEFINE_STATIC_STRING_EX(LeftKidney, LeftKidneyVasculature);
931  /***/DEFINE_STATIC_STRING(LeftRenalArtery);
932  /***/DEFINE_STATIC_STRING(LeftNephron);
933  /*********/DEFINE_STATIC_STRING(LeftAfferentArteriole);
934  /*********/DEFINE_STATIC_STRING(LeftGlomerularCapillaries);
935  /*********/DEFINE_STATIC_STRING(LeftEfferentArteriole);
936  /*********/DEFINE_STATIC_STRING(LeftPeritubularCapillaries);
937  /*********/DEFINE_STATIC_STRING(LeftBowmansCapsules);
938  /*********/DEFINE_STATIC_STRING(LeftTubules);
939  /***/DEFINE_STATIC_STRING(LeftRenalVein);
940  DEFINE_STATIC_STRING_EX(RightKidney, RightKidneyVasculature);
941  /***/DEFINE_STATIC_STRING(RightRenalArtery);
942  /***/DEFINE_STATIC_STRING(RightNephron);
943  /*********/DEFINE_STATIC_STRING(RightAfferentArteriole);
944  /*********/DEFINE_STATIC_STRING(RightGlomerularCapillaries);
945  /*********/DEFINE_STATIC_STRING(RightEfferentArteriole);
946  /*********/DEFINE_STATIC_STRING(RightPeritubularCapillaries);
947  /*********/DEFINE_STATIC_STRING(RightBowmansCapsules);
948  /*********/DEFINE_STATIC_STRING(RightTubules);
949  /***/DEFINE_STATIC_STRING(RightRenalVein);
950  // General Organs and Periphery
951  DEFINE_STATIC_STRING_EX(Bone, BoneVasculature);
952  DEFINE_STATIC_STRING_EX(Head, HeadVasculature);
953  DEFINE_STATIC_STRING_EX(Extracranial, ExtracranialVasculature);
954  DEFINE_STATIC_STRING_EX(Intracranial, IntracranialVasculature);
955  DEFINE_STATIC_STRING_EX(Fat, FatVasculature);
956  DEFINE_STATIC_STRING_EX(Gut, GutVasculature);
957  DEFINE_STATIC_STRING_EX(Gut1, Gut1Vasculature);
958  DEFINE_STATIC_STRING_EX(Splanchnic, SplanchnicVasculature);
959  DEFINE_STATIC_STRING_EX(SmallIntestine, SmallIntestineVasculature);
960  DEFINE_STATIC_STRING_EX(LargeIntestine, LargeIntestineVasculature);
961  DEFINE_STATIC_STRING_EX(LeftArm, LeftArmVasculature);
962  DEFINE_STATIC_STRING_EX(LeftArmArterioles, LeftArmArteriolesVasculature);
963  DEFINE_STATIC_STRING_EX(LeftArmBone, LeftArmBoneVasculature);
964  DEFINE_STATIC_STRING_EX(LeftArmFat, LeftArmFatVasculature);
965  DEFINE_STATIC_STRING(LeftArmMicrovasculature);
966  DEFINE_STATIC_STRING_EX(LeftArmMuscle, LeftArmMuscleVasculature);
967  DEFINE_STATIC_STRING_EX(LeftArmSkin, LeftArmSkinVasculature);
968  DEFINE_STATIC_STRING_EX(LeftArmVenules, LeftArmVenulesVasculature);
969  DEFINE_STATIC_STRING_EX(LeftLeg, LeftLegVasculature);
970  DEFINE_STATIC_STRING_EX(LeftLegArterioles, LeftLegArteriolesVasculature);
971  DEFINE_STATIC_STRING_EX(LeftLegBone, LeftLegBoneVasculature);
972  DEFINE_STATIC_STRING_EX(LeftLegFat, LeftLegFatVasculature);
973  DEFINE_STATIC_STRING(LeftLegMicrovasculature);
974  DEFINE_STATIC_STRING_EX(LeftLegMuscle, LeftLegMuscleVasculature);
975  DEFINE_STATIC_STRING_EX(LeftLegSkin, LeftLegSkinVasculature);
976  DEFINE_STATIC_STRING_EX(LeftLegVenules, LeftLegVenulesVasculature);
977  DEFINE_STATIC_STRING_EX(Liver, LiverVasculature);
978  DEFINE_STATIC_STRING_EX(Muscle, MuscleVasculature);
979  DEFINE_STATIC_STRING_EX(RightArm, RightArmVasculature);
980  DEFINE_STATIC_STRING_EX(RightArmArterioles, RightArmArteriolesVasculature);
981  DEFINE_STATIC_STRING_EX(RightArmBone, RightArmBoneVasculature);
982  DEFINE_STATIC_STRING_EX(RightArmFat, RightArmFatVasculature);
983  DEFINE_STATIC_STRING(RightArmMicrovasculature);
984  DEFINE_STATIC_STRING_EX(RightArmMuscle, RightArmMuscleVasculature);
985  DEFINE_STATIC_STRING_EX(RightArmSkin, RightArmSkinVasculature);
986  DEFINE_STATIC_STRING_EX(RightArmVenules, RightArmVenulesVasculature);
987  DEFINE_STATIC_STRING_EX(RightLeg, RightLegVasculature);
988  DEFINE_STATIC_STRING_EX(RightLegArterioles, RightLegArteriolesVasculature);
989  DEFINE_STATIC_STRING_EX(RightLegBone, RightLegBoneVasculature);
990  DEFINE_STATIC_STRING_EX(RightLegFat, RightLegFatVasculature);
991  DEFINE_STATIC_STRING(RightLegMicrovasculature);
992  DEFINE_STATIC_STRING_EX(RightLegMuscle, RightLegMuscleVasculature);
993  DEFINE_STATIC_STRING_EX(RightLegSkin, RightLegSkinVasculature);
994  DEFINE_STATIC_STRING_EX(RightLegVenules, RightLegVenulesVasculature);
995  DEFINE_STATIC_STRING_EX(Skin, SkinVasculature);
996  DEFINE_STATIC_STRING_EX(Spleen, SpleenVasculature);
997  DEFINE_STATIC_STRING_EX(Torso, TorsoVasculature);
998  DEFINE_STATIC_STRING_EX(TorsoArterioles, TorsoArteriolesVasculature);
999  DEFINE_STATIC_STRING_EX(TorsoBone, TorsoBoneVasculature);
1000  DEFINE_STATIC_STRING_EX(TorsoFat, TorsoFatVasculature);
1001  DEFINE_STATIC_STRING(TorsoMicrovasculature);
1002  DEFINE_STATIC_STRING_EX(TorsoMuscle, TorsoMuscleVasculature);
1003  DEFINE_STATIC_STRING_EX(TorsoSkin, TorsoSkinVasculature);
1004  DEFINE_STATIC_STRING_EX(TorsoVenules, TorsoVenulesVasculature);
1005  DEFINE_STATIC_STRING(Abdomen);
1006  DEFINE_STATIC_STRING(AbdominalCavity);
1007 
1008  DEFINE_STATIC_STRING(Ground);
1009 
1010 
1011  static const std::vector<std::string>& GetValues()
1012  {
1013  ScopedMutex lock;
1014  if (_values.empty())
1015  {
1016  _values.push_back(Aorta);
1017  _values.push_back(ArterialBuffer);
1018  _values.push_back(Abdomen);
1019  _values.push_back(Heart);
1020  _values.push_back(Myocardium);
1021  _values.push_back(LeftHeart);
1022  _values.push_back(RightHeart);
1023  _values.push_back(Pericardium);
1024  _values.push_back(VenaCava);
1025  _values.push_back(VenousBuffer);
1026  _values.push_back(PulmonaryArteries);
1027  _values.push_back(PulmonaryCapillaries);
1028  _values.push_back(PulmonaryVeins);
1029  _values.push_back(Lungs);
1030  _values.push_back(LeftLung);
1031  _values.push_back(LeftPulmonaryArteries);
1032  _values.push_back(LeftPulmonaryCapillaries);
1033  _values.push_back(LeftPulmonaryVeins);
1034  _values.push_back(RightLung);
1035  _values.push_back(RightPulmonaryArteries);
1036  _values.push_back(RightPulmonaryCapillaries);
1037  _values.push_back(RightPulmonaryVeins);
1038  _values.push_back(Kidneys);
1039  _values.push_back(LeftKidney);
1040  _values.push_back(LeftRenalArtery);
1041  _values.push_back(LeftNephron);
1042  _values.push_back(LeftAfferentArteriole);
1043  _values.push_back(LeftGlomerularCapillaries);
1044  _values.push_back(LeftEfferentArteriole);
1045  _values.push_back(LeftPeritubularCapillaries);
1046  _values.push_back(LeftBowmansCapsules);
1047  _values.push_back(LeftTubules);
1048  _values.push_back(LeftRenalVein);
1049  _values.push_back(RightKidney);
1050  _values.push_back(RightRenalArtery);
1051  _values.push_back(RightNephron);
1052  _values.push_back(RightAfferentArteriole);
1053  _values.push_back(RightGlomerularCapillaries);
1054  _values.push_back(RightEfferentArteriole);
1055  _values.push_back(RightPeritubularCapillaries);
1056  _values.push_back(RightBowmansCapsules);
1057  _values.push_back(RightTubules);
1058  _values.push_back(RightRenalVein);
1059  _values.push_back(Bone);
1060  _values.push_back(Head);
1061  _values.push_back(Extracranial);
1062  _values.push_back(Intracranial);
1063  _values.push_back(Fat);
1064  _values.push_back(Gut);
1065  _values.push_back(Gut1);
1066  _values.push_back(Splanchnic);
1067  _values.push_back(SmallIntestine);
1068  _values.push_back(LargeIntestine);
1069  _values.push_back(Liver);
1070  _values.push_back(Spleen);
1071  _values.push_back(Skin);
1072  _values.push_back(Muscle);
1073  _values.push_back(LeftArm);
1074  _values.push_back(LeftArmArterioles);
1075  _values.push_back(LeftArmFat);
1076  _values.push_back(LeftArmMuscle);
1077  _values.push_back(LeftArmSkin);
1078  _values.push_back(LeftArmBone);
1079  _values.push_back(LeftArmMicrovasculature);
1080  _values.push_back(LeftArmVenules);
1081  _values.push_back(LeftLeg);
1082  _values.push_back(LeftLegArterioles);
1083  _values.push_back(LeftLegFat);
1084  _values.push_back(LeftLegMuscle);
1085  _values.push_back(LeftLegSkin);
1086  _values.push_back(LeftLegBone);
1087  _values.push_back(LeftLegMicrovasculature);
1088  _values.push_back(LeftLegVenules);
1089  _values.push_back(RightArm);
1090  _values.push_back(RightArmArterioles);
1091  _values.push_back(RightArmFat);
1092  _values.push_back(RightArmMuscle);
1093  _values.push_back(RightArmSkin);
1094  _values.push_back(RightArmBone);
1095  _values.push_back(RightArmMicrovasculature);
1096  _values.push_back(RightArmVenules);
1097  _values.push_back(RightLeg);
1098  _values.push_back(RightLegArterioles);
1099  _values.push_back(RightLegFat);
1100  _values.push_back(RightLegMuscle);
1101  _values.push_back(RightLegSkin);
1102  _values.push_back(RightLegBone);
1103  _values.push_back(RightLegMicrovasculature);
1104  _values.push_back(RightLegVenules);
1105  _values.push_back(Torso);
1106  _values.push_back(TorsoArterioles);
1107  _values.push_back(TorsoBone);
1108  _values.push_back(TorsoFat);
1109  _values.push_back(TorsoMicrovasculature);
1110  _values.push_back(TorsoMuscle);
1111  _values.push_back(TorsoSkin);
1112  _values.push_back(TorsoVenules);
1113  //_values.push_back(Ground);
1114  }
1115  return _values;
1116  }
1117  static bool HasValue(const std::string& v)
1118  {
1119  return std::find(_values.begin(), _values.end(), v) != _values.end();
1120  }
1121  static void AddValue(const std::string& v)
1122  {
1123  if (!HasValue(v))
1124  {
1125  ScopedMutex lock;
1126  _values.push_back(v);
1127  }
1128  }
1129  protected:
1130  static std::vector<std::string> _values;
1131  };
1132 
1133  class ExpandedVascularLink
1134  {
1135  public:
1136  // Heart and Lungs
1137 
1138  DEFINE_STATIC_STRING(VenousBufferToVenaCava);
1139  DEFINE_STATIC_STRING(VenaCavaToRightHeart);
1140  DEFINE_STATIC_STRING(RightHeartToLeftPulmonaryArteries);
1141  DEFINE_STATIC_STRING(LeftPulmonaryArteriesToCapillaries);
1142  DEFINE_STATIC_STRING(LeftPulmonaryArteriesToVeins);
1143  DEFINE_STATIC_STRING(LeftPulmonaryCapillariesToVeins);
1144  DEFINE_STATIC_STRING(LeftPulmonaryVeinsToLeftHeart);
1145  DEFINE_STATIC_STRING(RightHeartToRightPulmonaryArteries);
1146  DEFINE_STATIC_STRING(RightPulmonaryArteriesToCapillaries);
1147  DEFINE_STATIC_STRING(RightPulmonaryArteriesToVeins);
1148  DEFINE_STATIC_STRING(RightPulmonaryCapillariesToVeins);
1149  DEFINE_STATIC_STRING(RightPulmonaryVeinsToLeftHeart);
1150  DEFINE_STATIC_STRING(LeftHeartToAorta);
1151  DEFINE_STATIC_STRING(AortaToArterialBuffer);
1152  // Head
1153  DEFINE_STATIC_STRING(AortaToIntracranial);
1154  DEFINE_STATIC_STRING(IntracranialToVenaCava);
1155  DEFINE_STATIC_STRING(AortaToExtracranial);
1156  DEFINE_STATIC_STRING(ExtracranialToVenaCava);
1157  // Left Arm
1158  DEFINE_STATIC_STRING(AortaToLeftArmArterioles);
1159  DEFINE_STATIC_STRING(LeftArmArteriolesToLeftArmBone);
1160  DEFINE_STATIC_STRING(LeftArmArteriolesToLeftArmFat);
1161  DEFINE_STATIC_STRING(LeftArmArteriolesToLeftArmMicrovasculature);
1162  DEFINE_STATIC_STRING(LeftArmArteriolesToLeftArmMuscle);
1163  DEFINE_STATIC_STRING(LeftArmArteriolesToLeftArmSkin);
1164 
1165  DEFINE_STATIC_STRING(LeftArmBoneToLeftArmVenules);
1166  DEFINE_STATIC_STRING(LeftArmFatToLeftArmVenules);
1167  DEFINE_STATIC_STRING(LeftArmMicrovasculatureToLeftArmVenules);
1168  DEFINE_STATIC_STRING(LeftArmMuscleToLeftArmVenules);
1169  DEFINE_STATIC_STRING(LeftArmSkinToLeftArmVenules);
1170  DEFINE_STATIC_STRING(LeftArmVenulesToVenaCava);
1171 
1172  // Left Kidney
1173  DEFINE_STATIC_STRING(AortaToLeftKidney);
1174  DEFINE_STATIC_STRING(LeftKidneyToVenaCava);
1175  // Left Leg
1176  DEFINE_STATIC_STRING(AortaToLeftLegArterioles);
1177  DEFINE_STATIC_STRING(LeftLegArteriolesToLeftLegBone);
1178  DEFINE_STATIC_STRING(LeftLegArteriolesToLeftLegFat);
1179  DEFINE_STATIC_STRING(LeftLegArteriolesToLeftLegMicrovasculature);
1180  DEFINE_STATIC_STRING(LeftLegArteriolesToLeftLegMuscle);
1181  DEFINE_STATIC_STRING(LeftLegArteriolesToLeftLegSkin);
1182 
1183  DEFINE_STATIC_STRING(LeftLegBoneToLeftLegVenules);
1184  DEFINE_STATIC_STRING(LeftLegFatToLeftLegVenules);
1185  DEFINE_STATIC_STRING(LeftLegMicrovasculatureToLeftLegVenules);
1186  DEFINE_STATIC_STRING(LeftLegMuscleToLeftLegVenules);
1187  DEFINE_STATIC_STRING(LeftLegSkinToLeftLegVenules);
1188  DEFINE_STATIC_STRING(LeftLegVenulesToVenaCava);
1189  // Gut
1190  DEFINE_STATIC_STRING(AortaToGut);
1192  DEFINE_STATIC_STRING(AortaToLargeIntestine);
1193  DEFINE_STATIC_STRING(LargeIntestineToLiver);
1195  DEFINE_STATIC_STRING(AortaToSmallIntestine);
1196  DEFINE_STATIC_STRING(SmallIntestineToLiver);
1198  DEFINE_STATIC_STRING(AortaToSplanchnic);
1199  DEFINE_STATIC_STRING(SplanchnicToLiver);
1201  DEFINE_STATIC_STRING(AortaToSpleen);
1202  DEFINE_STATIC_STRING(SpleenToLiver);
1204  DEFINE_STATIC_STRING(AortaToLiver);
1205  DEFINE_STATIC_STRING(LiverToVenaCava);
1206  // Myocardium
1207  DEFINE_STATIC_STRING(AortaToMyocardium);
1208  DEFINE_STATIC_STRING(MyocardiumToVenaCava);
1209  // Right Arm
1210  DEFINE_STATIC_STRING(AortaToRightArmArterioles);
1211  DEFINE_STATIC_STRING(RightArmArteriolesToRightArmBone);
1212  DEFINE_STATIC_STRING(RightArmArteriolesToRightArmFat);
1213  DEFINE_STATIC_STRING(RightArmArteriolesToRightArmMicrovasculature);
1214  DEFINE_STATIC_STRING(RightArmArteriolesToRightArmMuscle);
1215  DEFINE_STATIC_STRING(RightArmArteriolesToRightArmSkin);
1216 
1217  DEFINE_STATIC_STRING(RightArmBoneToRightArmVenules);
1218  DEFINE_STATIC_STRING(RightArmFatToRightArmVenules);
1219  DEFINE_STATIC_STRING(RightArmMicrovasculatureToRightArmVenules);
1220  DEFINE_STATIC_STRING(RightArmMuscleToRightArmVenules);
1221  DEFINE_STATIC_STRING(RightArmSkinToRightArmVenules);
1222  DEFINE_STATIC_STRING(RightArmVenulesToVenaCava);
1223 
1224  // Right Kidney
1225  DEFINE_STATIC_STRING(AortaToRightKidney);
1226  DEFINE_STATIC_STRING(RightKidneyToVenaCava);
1227  // Right Leg
1228  DEFINE_STATIC_STRING(AortaToRightLegArterioles);
1229  DEFINE_STATIC_STRING(RightLegArteriolesToRightLegBone);
1230  DEFINE_STATIC_STRING(RightLegArteriolesToRightLegFat);
1231  DEFINE_STATIC_STRING(RightLegArteriolesToRightLegMicrovasculature);
1232  DEFINE_STATIC_STRING(RightLegArteriolesToRightLegMuscle);
1233  DEFINE_STATIC_STRING(RightLegArteriolesToRightLegSkin);
1234 
1235  DEFINE_STATIC_STRING(RightLegBoneToRightLegVenules);
1236  DEFINE_STATIC_STRING(RightLegFatToRightLegVenules);
1237  DEFINE_STATIC_STRING(RightLegMicrovasculatureToRightLegVenules);
1238  DEFINE_STATIC_STRING(RightLegMuscleToRightLegVenules);
1239  DEFINE_STATIC_STRING(RightLegSkinToRightLegVenules);
1240  DEFINE_STATIC_STRING(RightLegVenulesToVenaCava);
1241 
1242  // Torso
1243  DEFINE_STATIC_STRING(AortaToTorsoArterioles);
1244  DEFINE_STATIC_STRING(TorsoArteriolesToTorsoBone);
1245  DEFINE_STATIC_STRING(TorsoArteriolesToTorsoFat);
1246  DEFINE_STATIC_STRING(TorsoArteriolesToTorsoMicrovasculature);
1247  DEFINE_STATIC_STRING(TorsoArteriolesToTorsoMuscle);
1248  DEFINE_STATIC_STRING(TorsoArteriolesToTorsoSkin);
1249 
1250  DEFINE_STATIC_STRING(TorsoSkinToTorsoVenules);
1251  DEFINE_STATIC_STRING(TorsoMuscleToTorsoVenules);
1252  DEFINE_STATIC_STRING(TorsoMicrovasculatureToTorsoVenules);
1253  DEFINE_STATIC_STRING(TorsoFatToTorsoVenules);
1254  DEFINE_STATIC_STRING(TorsoBoneToTorsoVenules);
1255  DEFINE_STATIC_STRING(TorsoVenulesToVenaCava);
1256  // Hemorrhage and IV
1257  DEFINE_STATIC_STRING(VenaCavaIV);
1258 
1259  // Vascular To Tissue Links
1260  DEFINE_STATIC_STRING(TorsoBoneVascularToTissue);
1261  DEFINE_STATIC_STRING(LeftArmBoneVascularToTissue);
1262  DEFINE_STATIC_STRING(LeftLegBoneVascularToTissue);
1263  DEFINE_STATIC_STRING(RightArmBoneVascularToTissue);
1264  DEFINE_STATIC_STRING(RightLegBoneVascularToTissue);
1265  DEFINE_STATIC_STRING(BrainVascularToTissue);
1266  DEFINE_STATIC_STRING(TorsoFatVascularToTissue);
1267  DEFINE_STATIC_STRING(LeftArmFatVascularToTissue);
1268  DEFINE_STATIC_STRING(LeftLegFatVascularToTissue);
1269  DEFINE_STATIC_STRING(RightArmFatVascularToTissue);
1270  DEFINE_STATIC_STRING(RightLegFatVascularToTissue);
1271  DEFINE_STATIC_STRING(SmallIntestineVascularToTissue);
1272  DEFINE_STATIC_STRING(LargeIntestineVascularToTissue);
1273  DEFINE_STATIC_STRING(SplanchnicVascularToTissue);
1274  DEFINE_STATIC_STRING(LeftKidneyVascularToTissue);
1275  DEFINE_STATIC_STRING(LeftLungVascularToTissue);
1276  DEFINE_STATIC_STRING(LiverVascularToTissue);
1277  DEFINE_STATIC_STRING(TorsoMuscleVascularToTissue);
1278  DEFINE_STATIC_STRING(LeftArmMuscleVascularToTissue);
1279  DEFINE_STATIC_STRING(LeftLegMuscleVascularToTissue);
1280  DEFINE_STATIC_STRING(RightArmMuscleVascularToTissue);
1281  DEFINE_STATIC_STRING(RightLegMuscleVascularToTissue);
1282  DEFINE_STATIC_STRING(MyocardiumVascularToTissue);
1283  DEFINE_STATIC_STRING(RightKidneyVascularToTissue);
1284  DEFINE_STATIC_STRING(RightLungVascularToTissue);
1285  DEFINE_STATIC_STRING(TorsoSkinVascularToTissue);
1286  DEFINE_STATIC_STRING(LeftArmSkinVascularToTissue);
1287  DEFINE_STATIC_STRING(LeftLegSkinVascularToTissue);
1288  DEFINE_STATIC_STRING(RightArmSkinVascularToTissue);
1289  DEFINE_STATIC_STRING(RightLegSkinVascularToTissue);
1290  DEFINE_STATIC_STRING(SpleenVascularToTissue);
1291 
1292  // Renal Links
1293  // Reusing 'AortaToLeftKidney' to connect the Aorta To Left Renal Artery
1294  DEFINE_STATIC_STRING(LeftRenalArteryToAfferentArteriole);
1295  DEFINE_STATIC_STRING(LeftAfferentArterioleToGlomerularCapillaries);
1296  DEFINE_STATIC_STRING(LeftGlomerularCapillariesToEfferentArteriole);
1297  DEFINE_STATIC_STRING(LeftGlomerularCapillariesToBowmansCapsules);
1298  DEFINE_STATIC_STRING(LeftBowmansCapsulesToTubules);
1299  DEFINE_STATIC_STRING(LeftTubulesToPeritubularCapillaries);
1300  DEFINE_STATIC_STRING(LeftEfferentArterioleToPeritubularCapillaries);
1301  DEFINE_STATIC_STRING(LeftPeritubularCapillariesToRenalVein);
1302  // Reusing 'LeftKidneyToVenaCava' to connect the Left Renal Vein To Vena Cava
1303 
1304  // Reusing 'AortaToRightKidney' to connect the Aorta To Right Renal Artery
1305  DEFINE_STATIC_STRING(RightRenalArteryToAfferentArteriole);
1306  DEFINE_STATIC_STRING(RightAfferentArterioleToGlomerularCapillaries);
1307  DEFINE_STATIC_STRING(RightGlomerularCapillariesToEfferentArteriole);
1308  DEFINE_STATIC_STRING(RightGlomerularCapillariesToBowmansCapsules);
1309  DEFINE_STATIC_STRING(RightBowmansCapsulesToTubules);
1310  DEFINE_STATIC_STRING(RightTubulesToPeritubularCapillaries);
1311  DEFINE_STATIC_STRING(RightEfferentArterioleToPeritubularCapillaries);
1312  DEFINE_STATIC_STRING(RightPeritubularCapillariesToRenalVein);
1313  // Reusing 'RightKidneyToVenaCava' to connect the Right Renal Vein To Vena Cava);
1314 
1315 
1316  static const std::vector<std::string>& GetValues()
1317  {
1318  ScopedMutex lock;
1319  if (_values.empty())
1320  {
1321  _values.push_back(VenaCavaToRightHeart);
1322  _values.push_back(RightHeartToLeftPulmonaryArteries);
1323  _values.push_back(LeftPulmonaryArteriesToCapillaries);
1324  _values.push_back(LeftPulmonaryArteriesToVeins);
1325  _values.push_back(LeftPulmonaryCapillariesToVeins);
1326  _values.push_back(LeftPulmonaryVeinsToLeftHeart);
1327  _values.push_back(RightHeartToRightPulmonaryArteries);
1328  _values.push_back(RightPulmonaryArteriesToCapillaries);
1329  _values.push_back(RightPulmonaryArteriesToVeins);
1330  _values.push_back(RightPulmonaryCapillariesToVeins);
1331  _values.push_back(RightPulmonaryVeinsToLeftHeart);
1332  _values.push_back(LeftHeartToAorta);
1333  _values.push_back(AortaToIntracranial);
1334  _values.push_back(IntracranialToVenaCava);
1335  _values.push_back(AortaToExtracranial);
1336  _values.push_back(ExtracranialToVenaCava);
1337  _values.push_back(AortaToLargeIntestine);
1338  _values.push_back(LargeIntestineToLiver);
1339  _values.push_back(LeftArmArteriolesToLeftArmBone);
1340  _values.push_back(LeftArmArteriolesToLeftArmFat);
1341  _values.push_back(LeftArmArteriolesToLeftArmMicrovasculature);
1342  _values.push_back(LeftArmArteriolesToLeftArmMuscle);
1343  _values.push_back(LeftArmArteriolesToLeftArmSkin);
1344 
1345  _values.push_back(AortaToLeftKidney);
1346  _values.push_back(LeftKidneyToVenaCava);
1347  _values.push_back(LeftLegArteriolesToLeftLegBone);
1348  _values.push_back(LeftLegArteriolesToLeftLegFat);
1349  _values.push_back(LeftLegArteriolesToLeftLegMicrovasculature);
1350  _values.push_back(LeftLegArteriolesToLeftLegMuscle);
1351  _values.push_back(LeftLegArteriolesToLeftLegSkin);
1352  _values.push_back(AortaToLiver);
1353  _values.push_back(LiverToVenaCava);
1354  _values.push_back(AortaToMyocardium);
1355  _values.push_back(MyocardiumToVenaCava);
1356  _values.push_back(RightArmArteriolesToRightArmBone);
1357  _values.push_back(RightArmArteriolesToRightArmFat);
1358  _values.push_back(RightArmArteriolesToRightArmMicrovasculature);
1359  _values.push_back(RightArmArteriolesToRightArmMuscle);
1360  _values.push_back(RightArmArteriolesToRightArmSkin);
1361 
1362  _values.push_back(AortaToRightKidney);
1363  _values.push_back(RightKidneyToVenaCava);
1364  _values.push_back(RightLegArteriolesToRightLegBone);
1365  _values.push_back(RightLegArteriolesToRightLegFat);
1366  _values.push_back(RightLegArteriolesToRightLegMicrovasculature);
1367  _values.push_back(RightLegArteriolesToRightLegMuscle);
1368  _values.push_back(RightLegArteriolesToRightLegSkin);
1369 
1370 
1371 
1372  _values.push_back(AortaToSmallIntestine);
1373  _values.push_back(SmallIntestineToLiver);
1374  _values.push_back(AortaToSplanchnic);
1375  _values.push_back(SplanchnicToLiver);
1376  _values.push_back(AortaToSpleen);
1377  _values.push_back(SpleenToLiver);
1378  _values.push_back(AortaToTorsoArterioles);
1379  _values.push_back(TorsoArteriolesToTorsoBone);
1380  _values.push_back(TorsoArteriolesToTorsoFat);
1381  _values.push_back(TorsoArteriolesToTorsoMicrovasculature);
1382  _values.push_back(TorsoArteriolesToTorsoMuscle);
1383  _values.push_back(TorsoArteriolesToTorsoSkin);
1384 
1385  _values.push_back(RightArmBoneToRightArmVenules);
1386  _values.push_back(RightArmFatToRightArmVenules);
1387  _values.push_back(RightArmMicrovasculatureToRightArmVenules);
1388  _values.push_back(RightArmMuscleToRightArmVenules);
1389  _values.push_back(RightArmSkinToRightArmVenules);
1390  _values.push_back(RightLegBoneToRightLegVenules);
1391  _values.push_back(RightLegFatToRightLegVenules);
1392  _values.push_back(RightLegMicrovasculatureToRightLegVenules);
1393  _values.push_back(RightLegMuscleToRightLegVenules);
1394  _values.push_back(RightLegSkinToRightLegVenules);
1395  _values.push_back(LeftArmBoneToLeftArmVenules);
1396  _values.push_back(LeftArmFatToLeftArmVenules);
1397  _values.push_back(LeftArmMicrovasculatureToLeftArmVenules);
1398  _values.push_back(LeftArmMuscleToLeftArmVenules);
1399  _values.push_back(LeftArmSkinToLeftArmVenules);
1400  _values.push_back(LeftLegBoneToLeftLegVenules);
1401  _values.push_back(LeftLegFatToLeftLegVenules);
1402  _values.push_back(LeftLegMicrovasculatureToLeftLegVenules);
1403  _values.push_back(LeftLegMuscleToLeftLegVenules);
1404  _values.push_back(LeftLegSkinToLeftLegVenules);
1405  _values.push_back(TorsoSkinToTorsoVenules);
1406  _values.push_back(TorsoMuscleToTorsoVenules);
1407  _values.push_back(TorsoMicrovasculatureToTorsoVenules);
1408  _values.push_back(TorsoFatToTorsoVenules);
1409  _values.push_back(TorsoBoneToTorsoVenules);
1410  _values.push_back(TorsoVenulesToVenaCava);
1411 
1412 
1413  _values.push_back(TorsoBoneVascularToTissue);
1414  _values.push_back(LeftArmBoneVascularToTissue);
1415  _values.push_back(LeftLegBoneVascularToTissue);
1416  _values.push_back(RightArmBoneVascularToTissue);
1417  _values.push_back(RightLegBoneVascularToTissue);
1418  _values.push_back(BrainVascularToTissue);
1419  _values.push_back(TorsoFatVascularToTissue);
1420  _values.push_back(LeftArmFatVascularToTissue);
1421  _values.push_back(LeftLegFatVascularToTissue);
1422  _values.push_back(RightArmFatVascularToTissue);
1423  _values.push_back(RightLegFatVascularToTissue);
1424  _values.push_back(SmallIntestineVascularToTissue);
1425  _values.push_back(LargeIntestineVascularToTissue);
1426  _values.push_back(SplanchnicVascularToTissue);
1427  _values.push_back(LeftKidneyVascularToTissue);
1428  _values.push_back(LeftLungVascularToTissue);
1429  _values.push_back(LiverVascularToTissue);
1430  _values.push_back(TorsoMuscleVascularToTissue);
1431  _values.push_back(LeftArmMuscleVascularToTissue);
1432  _values.push_back(LeftLegMuscleVascularToTissue);
1433  _values.push_back(RightArmMuscleVascularToTissue);
1434  _values.push_back(RightLegMuscleVascularToTissue);
1435  _values.push_back(MyocardiumVascularToTissue);
1436  _values.push_back(RightKidneyVascularToTissue);
1437  _values.push_back(RightLungVascularToTissue);
1438  _values.push_back(TorsoSkinVascularToTissue);
1439  _values.push_back(LeftArmSkinVascularToTissue);
1440  _values.push_back(LeftLegSkinVascularToTissue);
1441  _values.push_back(RightArmSkinVascularToTissue);
1442  _values.push_back(RightLegSkinVascularToTissue);
1443  _values.push_back(SpleenVascularToTissue);
1444 
1445  _values.push_back(LeftRenalArteryToAfferentArteriole);
1446  _values.push_back(LeftAfferentArterioleToGlomerularCapillaries);
1447  _values.push_back(LeftGlomerularCapillariesToEfferentArteriole);
1448  _values.push_back(LeftGlomerularCapillariesToBowmansCapsules);
1449  _values.push_back(LeftBowmansCapsulesToTubules);
1450  _values.push_back(LeftTubulesToPeritubularCapillaries);
1451  _values.push_back(LeftEfferentArterioleToPeritubularCapillaries);
1452  _values.push_back(LeftPeritubularCapillariesToRenalVein);
1453  _values.push_back(RightRenalArteryToAfferentArteriole);
1454  _values.push_back(RightAfferentArterioleToGlomerularCapillaries);
1455  _values.push_back(RightGlomerularCapillariesToEfferentArteriole);
1456  _values.push_back(RightGlomerularCapillariesToBowmansCapsules);
1457  _values.push_back(RightBowmansCapsulesToTubules);
1458  _values.push_back(RightTubulesToPeritubularCapillaries);
1459  _values.push_back(RightEfferentArterioleToPeritubularCapillaries);
1460  _values.push_back(RightPeritubularCapillariesToRenalVein);
1461  }
1462  return _values;
1463  }
1464  static bool HasValue(const std::string& v)
1465  {
1466  return std::find(_values.begin(), _values.end(), v) != _values.end();
1467  }
1468  static void AddValue(const std::string& v)
1469  {
1470  if (!HasValue(v))
1471  {
1472  ScopedMutex lock;
1473  _values.push_back(v);
1474  }
1475  }
1476  protected:
1477  static std::vector<std::string> _values;
1478  };
1479 
1480 
1481  class UrineCompartment
1482  {
1483  public:
1484  DEFINE_STATIC_STRING(Ureters);
1485  /*****/DEFINE_STATIC_STRING(LeftUreter);
1486  /*****/DEFINE_STATIC_STRING(RightUreter);
1487  DEFINE_STATIC_STRING(Bladder);
1488 
1489  static const std::vector<std::string>& GetValues()
1490  {
1491  ScopedMutex lock;
1492  if (_values.empty())
1493  {
1494  _values.push_back(Ureters);
1495  _values.push_back(LeftUreter);
1496  _values.push_back(RightUreter);
1497  _values.push_back(Bladder);
1498  }
1499  return _values;
1500  }
1501  static bool HasValue(const std::string& v)
1502  {
1503  return std::find(_values.begin(), _values.end(), v) != _values.end();
1504  }
1505  static void AddValue(const std::string& v)
1506  {
1507  if (!HasValue(v))
1508  {
1509  ScopedMutex lock;
1510  _values.push_back(v);
1511  }
1512  }
1513  protected:
1514  static std::vector<std::string> _values;
1515  };
1516 
1517  class UrineLink
1518  {
1519  public:
1520  DEFINE_STATIC_STRING(LeftTubulesToUreter);
1521  DEFINE_STATIC_STRING(LeftUreterToBladder);
1522 
1523  DEFINE_STATIC_STRING(RightTubulesToUreter);
1524  DEFINE_STATIC_STRING(RightUreterToBladder);
1525 
1526  DEFINE_STATIC_STRING(BladderToGround);
1527  DEFINE_STATIC_STRING(BladderToGroundSource);
1528 
1529  static const std::vector<std::string>& GetValues()
1530  {
1531  ScopedMutex lock;
1532  if (_values.empty())
1533  {
1534  _values.push_back(LeftTubulesToUreter);
1535  _values.push_back(LeftUreterToBladder);
1536  _values.push_back(RightTubulesToUreter);
1537  _values.push_back(RightUreterToBladder);
1538  _values.push_back(BladderToGround);
1539  _values.push_back(BladderToGroundSource);
1540  }
1541  return _values;
1542  }
1543  static bool HasValue(const std::string& v)
1544  {
1545  return std::find(_values.begin(), _values.end(), v) != _values.end();
1546  }
1547  static void AddValue(const std::string& v)
1548  {
1549  if (!HasValue(v))
1550  {
1551  ScopedMutex lock;
1552  _values.push_back(v);
1553  }
1554  }
1555  protected:
1556  static std::vector<std::string> _values;
1557  };
1558 
1559  class LymphCompartment
1560  {
1561  public:
1562  DEFINE_STATIC_STRING(Lymph);
1563 
1564  static const std::vector<std::string>& GetValues()
1565  {
1566  ScopedMutex lock;
1567  if (_values.empty())
1568  {
1569  _values.push_back(Lymph);
1570  }
1571  return _values;
1572  }
1573  static bool HasValue(const std::string& v)
1574  {
1575  return std::find(_values.begin(), _values.end(), v) != _values.end();
1576  }
1577  static void AddValue(const std::string& v)
1578  {
1579  if (!HasValue(v))
1580  {
1581  ScopedMutex lock;
1582  _values.push_back(v);
1583  }
1584  }
1585  protected:
1586  static std::vector<std::string> _values;
1587  };
1588 
1589  class LymphLink
1590  {
1591  public:
1592  DEFINE_STATIC_STRING(BoneTissueToLymph);
1593  DEFINE_STATIC_STRING(BrainTissueToLymph);
1594  DEFINE_STATIC_STRING(FatTissueToLymph);
1595  DEFINE_STATIC_STRING(GutTissueToLymph);
1596  DEFINE_STATIC_STRING(LeftKidneyTissueToLymph);
1597  DEFINE_STATIC_STRING(LeftLungTissueToLymph);
1598  DEFINE_STATIC_STRING(LiverTissueToLymph);
1599  DEFINE_STATIC_STRING(MuscleTissueToLymph);
1600  DEFINE_STATIC_STRING(MyocardiumTissueToLymph);
1601  DEFINE_STATIC_STRING(RightKidneyTissueToLymph);
1602  DEFINE_STATIC_STRING(RightLungTissueToLymph);
1603  DEFINE_STATIC_STRING(SkinTissueToLymph);
1604  DEFINE_STATIC_STRING(SpleenTissueToLymph);
1605 
1606  DEFINE_STATIC_STRING(LymphToVenaCava);
1607 
1608  static const std::vector<std::string>& GetValues()
1609  {
1610  ScopedMutex lock;
1611  if (_values.empty())
1612  {
1613  _values.push_back(BoneTissueToLymph);
1614  _values.push_back(BrainTissueToLymph);
1615  _values.push_back(FatTissueToLymph);
1616  _values.push_back(GutTissueToLymph);
1617  _values.push_back(LeftKidneyTissueToLymph);
1618  _values.push_back(LeftLungTissueToLymph);
1619  _values.push_back(LiverTissueToLymph);
1620  _values.push_back(MuscleTissueToLymph);
1621  _values.push_back(MyocardiumTissueToLymph);
1622  _values.push_back(RightKidneyTissueToLymph);
1623  _values.push_back(RightLungTissueToLymph);
1624  _values.push_back(SkinTissueToLymph);
1625  _values.push_back(SpleenTissueToLymph);
1626  _values.push_back(LymphToVenaCava);
1627  }
1628  return _values;
1629  }
1630  static bool HasValue(const std::string& v)
1631  {
1632  return std::find(_values.begin(), _values.end(), v) != _values.end();
1633  }
1634  static void AddValue(const std::string& v)
1635  {
1636  if (!HasValue(v))
1637  {
1638  ScopedMutex lock;
1639  _values.push_back(v);
1640  }
1641  }
1642  protected:
1643  static std::vector<std::string> _values;
1644  };
1645 
1646  class TemperatureCompartment
1647  {
1648  public:
1649  DEFINE_STATIC_STRING(Active);
1650  DEFINE_STATIC_STRING(Ambient);
1651  DEFINE_STATIC_STRING(Clothing);
1652  DEFINE_STATIC_STRING(Enclosure);
1653  DEFINE_STATIC_STRING(ExternalCore);
1654  DEFINE_STATIC_STRING(ExternalSkin);
1655  DEFINE_STATIC_STRING(ExternalGround);
1656  DEFINE_STATIC_STRING(InternalCore);
1657  DEFINE_STATIC_STRING(InternalSkin);
1658  DEFINE_STATIC_STRING(InternalGround);
1659 
1660  static const std::vector<std::string>& GetValues()
1661  {
1662  ScopedMutex lock;
1663  if (_values.empty())
1664  {
1665  _values.push_back(Active);
1666  _values.push_back(Ambient);
1667  _values.push_back(Clothing);
1668  _values.push_back(Enclosure);
1669  _values.push_back(ExternalCore);
1670  _values.push_back(ExternalSkin);
1671  _values.push_back(ExternalGround);
1672  _values.push_back(InternalCore);
1673  _values.push_back(InternalSkin);
1674  _values.push_back(InternalGround);
1675  }
1676  return _values;
1677  }
1678  static bool HasValue(const std::string& v)
1679  {
1680  return std::find(_values.begin(), _values.end(), v) != _values.end();
1681  }
1682  static void AddValue(const std::string& v)
1683  {
1684  if (!HasValue(v))
1685  {
1686  ScopedMutex lock;
1687  _values.push_back(v);
1688  }
1689  }
1690  protected:
1691  static std::vector<std::string> _values;
1692  };
1693 
1694  class TemperatureLink
1695  {
1696  public:
1697 
1698  DEFINE_STATIC_STRING(ActiveToClothing);
1699  DEFINE_STATIC_STRING(ClothingToEnclosure);
1700  DEFINE_STATIC_STRING(ClothingToEnvironment);
1701  DEFINE_STATIC_STRING(ExternalCoreToGround);
1702  DEFINE_STATIC_STRING(GroundToActive);
1703  DEFINE_STATIC_STRING(GroundToClothing);
1704  DEFINE_STATIC_STRING(GroundToEnclosure);
1705  DEFINE_STATIC_STRING(GroundToEnvironment);
1706  DEFINE_STATIC_STRING(ExternalSkinToGround);
1707  DEFINE_STATIC_STRING(ExternalSkinToClothing);
1708  DEFINE_STATIC_STRING(GroundToInternalCore);
1709  DEFINE_STATIC_STRING(InternalCoreToInternalSkin);
1710  DEFINE_STATIC_STRING(InternalCoreToGround);
1711  DEFINE_STATIC_STRING(InternalSkinToGround);
1712  DEFINE_STATIC_STRING(InternalCoreToExternalCore);
1713  DEFINE_STATIC_STRING(InternalSkinToExternalSkin);
1714 
1715  static const std::vector<std::string>& GetValues()
1716  {
1717  ScopedMutex lock;
1718  if (_values.empty())
1719  {
1720  _values.push_back(ActiveToClothing);
1721  _values.push_back(ClothingToEnclosure);
1722  _values.push_back(ClothingToEnvironment);
1723  _values.push_back(ExternalCoreToGround);
1724  _values.push_back(GroundToActive);
1725  _values.push_back(GroundToClothing);
1726  _values.push_back(GroundToEnclosure);
1727  _values.push_back(GroundToEnvironment);
1728  _values.push_back(ExternalSkinToGround);
1729  _values.push_back(ExternalSkinToClothing);
1730  _values.push_back(GroundToInternalCore);
1731  _values.push_back(InternalCoreToInternalSkin);
1732  _values.push_back(InternalCoreToGround);
1733  _values.push_back(InternalSkinToGround);
1734  _values.push_back(InternalCoreToExternalCore);
1735  _values.push_back(InternalSkinToExternalSkin);
1736  }
1737  return _values;
1738  }
1739  static bool HasValue(const std::string& v)
1740  {
1741  return std::find(_values.begin(), _values.end(), v) != _values.end();
1742  }
1743  static void AddValue(const std::string& v)
1744  {
1745  if (!HasValue(v))
1746  {
1747  ScopedMutex lock;
1748  _values.push_back(v);
1749  }
1750  }
1751  protected:
1752  static std::vector<std::string> _values;
1753  };
1754 
1755  class EnvironmentCompartment
1756  {
1757  public:
1758  DEFINE_STATIC_STRING(Ambient);
1759 
1760  static const std::vector<std::string>& GetValues()
1761  {
1762  ScopedMutex lock;
1763  if (_values.empty())
1764  {
1765  _values.push_back(Ambient);
1766  }
1767  return _values;
1768  }
1769  static bool HasValue(const std::string& v)
1770  {
1771  return std::find(_values.begin(), _values.end(), v) != _values.end();
1772  }
1773  static void AddValue(const std::string& v)
1774  {
1775  if (!HasValue(v))
1776  {
1777  ScopedMutex lock;
1778  _values.push_back(v);
1779  }
1780  }
1781  protected:
1782  static std::vector<std::string> _values;
1783  };
1784 
1785  class AnesthesiaMachineCompartment
1786  {
1787  public:
1788  DEFINE_STATIC_STRING_EX(Connection, AnesthesiaMachineConnection);
1789  DEFINE_STATIC_STRING_EX(ExpiratoryLimb, AnesthesiaMachineExpiratoryLimb);
1790  DEFINE_STATIC_STRING_EX(GasInlet, AnesthesiaMachineGasInlet);
1791  DEFINE_STATIC_STRING_EX(GasSource, AnesthesiaMachineGasSource);
1792  DEFINE_STATIC_STRING_EX(InspiratoryLimb, AnesthesiaMachineInspiratoryLimb);
1793  DEFINE_STATIC_STRING_EX(ReliefValve, AnesthesiaMachineReliefValve);
1794  DEFINE_STATIC_STRING_EX(Scrubber, AnesthesiaMachineScrubber);
1795  DEFINE_STATIC_STRING_EX(Selector, AnesthesiaMachineSelector);
1796  DEFINE_STATIC_STRING_EX(Ventilator, AnesthesiaMachineVentilator);
1797  DEFINE_STATIC_STRING_EX(YPiece, AnesthesiaMachineYPiece);
1798 
1799  static const std::vector<std::string>& GetValues()
1800  {
1801  ScopedMutex lock;
1802  if (_values.empty())
1803  {
1804  _values.push_back(Connection);
1805  _values.push_back(ExpiratoryLimb);
1806  _values.push_back(GasInlet);
1807  _values.push_back(GasSource);
1808  _values.push_back(InspiratoryLimb);
1809  _values.push_back(ReliefValve);
1810  _values.push_back(Scrubber);
1811  _values.push_back(Selector);
1812  _values.push_back(Ventilator);
1813  _values.push_back(YPiece);
1814  }
1815  return _values;
1816  }
1817  static bool HasValue(const std::string& v)
1818  {
1819  return std::find(_values.begin(), _values.end(), v) != _values.end();
1820  }
1821  static void AddValue(const std::string& v)
1822  {
1823  if (!HasValue(v))
1824  {
1825  ScopedMutex lock;
1826  _values.push_back(v);
1827  }
1828  }
1829  protected:
1830  static std::vector<std::string> _values;
1831  };
1832 
1833  class AnesthesiaMachineLink
1834  {
1835  public:
1836  DEFINE_STATIC_STRING_EX(EnvironmentToReliefValve, EnvironmentToAnesthesiaMachineReliefValve);
1837  DEFINE_STATIC_STRING_EX(VentilatorToSelector, AnesthesiaMachineVentilatorToSelector);
1838  DEFINE_STATIC_STRING_EX(SelectorToReliefValve, AnesthesiaMachineSelectorToReliefValve);
1839  DEFINE_STATIC_STRING_EX(SelectorToScrubber, AnesthesiaMachineSelectorToScrubber);
1840  DEFINE_STATIC_STRING_EX(ScrubberToGasInlet, AnesthesiaMachineScrubberToGasInlet);
1841  DEFINE_STATIC_STRING_EX(GasSourceToGasInlet, AnesthesiaMachineGasSourceToGasInlet);
1842  DEFINE_STATIC_STRING_EX(GasInletToInspiratoryLimb, AnesthesiaMachineGasInletToInspiratoryLimb);
1843  DEFINE_STATIC_STRING_EX(InspiratoryLimbToYPiece, AnesthesiaMachineInspiratoryLimbToYPiece);
1844  DEFINE_STATIC_STRING_EX(YPieceToExpiratoryLimb, AnesthesiaMachineYPieceToExpiratoryLimb);
1845  DEFINE_STATIC_STRING_EX(ExpiratoryLimbToSelector, AnesthesiaMachineExpiratoryLimbToSelector);
1846  DEFINE_STATIC_STRING_EX(YPieceToConnection, AnesthesiaMachineYPieceToConnection);
1847  DEFINE_STATIC_STRING_EX(ConnectionLeak, AnesthesiaMachineConnectionLeak);
1848  DEFINE_STATIC_STRING_EX(ConnectionToAirway, AnesthesiaMachineConnectionToAirway);
1849 
1850  static const std::vector<std::string>& GetValues()
1851  {
1852  ScopedMutex lock;
1853  if (_values.empty())
1854  {
1855  _values.push_back(EnvironmentToReliefValve);
1856  _values.push_back(VentilatorToSelector);
1857  _values.push_back(SelectorToReliefValve);
1858  _values.push_back(SelectorToScrubber);
1859  _values.push_back(ScrubberToGasInlet);
1860  _values.push_back(GasSourceToGasInlet);
1861  _values.push_back(GasInletToInspiratoryLimb);
1862  _values.push_back(InspiratoryLimbToYPiece);
1863  _values.push_back(YPieceToExpiratoryLimb);
1864  _values.push_back(ExpiratoryLimbToSelector);
1865  _values.push_back(YPieceToConnection);
1866  _values.push_back(ConnectionLeak);
1867  _values.push_back(ConnectionToAirway);
1868  }
1869  return _values;
1870  }
1871  static bool HasValue(const std::string& v)
1872  {
1873  return std::find(_values.begin(), _values.end(), v) != _values.end();
1874  }
1875  static void AddValue(const std::string& v)
1876  {
1877  if (!HasValue(v))
1878  {
1879  ScopedMutex lock;
1880  _values.push_back(v);
1881  }
1882  }
1883  protected:
1884  static std::vector<std::string> _values;
1885  };
1886 
1887  class BagValveMaskCompartment
1888  {
1889  public:
1890  DEFINE_STATIC_STRING_EX(Reservoir, BagValveMaskReservoir);
1891  DEFINE_STATIC_STRING_EX(Bag, BagValveMaskBag);
1892  DEFINE_STATIC_STRING_EX(Valve, BagValveMaskValve);
1893  DEFINE_STATIC_STRING_EX(Filter, BagValveMaskFilter);
1894  DEFINE_STATIC_STRING_EX(Connection, BagValveMaskConnection);
1895 
1896  static const std::vector<std::string>& GetValues()
1897  {
1898  ScopedMutex lock;
1899  if (_values.empty())
1900  {
1901  _values.push_back(Reservoir);
1902  _values.push_back(Bag);
1903  _values.push_back(Valve);
1904  _values.push_back(Filter);
1905  _values.push_back(Connection);
1906  }
1907  return _values;
1908  }
1909  protected:
1910  static std::vector<std::string> _values;
1911  };
1912 
1913  class BagValveMaskLink
1914  {
1915  public:
1916  DEFINE_STATIC_STRING_EX(ReservoirToBag, BagValveMaskReservoirToBag);
1917  DEFINE_STATIC_STRING_EX(BagToValve, BagValveMaskBagToValve);
1918  DEFINE_STATIC_STRING_EX(ValveToFilter, BagValveMaskValveToFilter);
1919  DEFINE_STATIC_STRING_EX(FilterToConnection, BagValveMaskFilterToConnection);
1920  DEFINE_STATIC_STRING_EX(ConnectionToEnvironment, BagValveMaskConnectionToEnvironment);
1921  DEFINE_STATIC_STRING_EX(ConnectionToAirway, BagValveMaskConnectionToAirway);
1922 
1923  static const std::vector<std::string>& GetValues()
1924  {
1925  ScopedMutex lock;
1926  if (_values.empty())
1927  {
1928  _values.push_back(ReservoirToBag);
1929  _values.push_back(BagToValve);
1930  _values.push_back(ValveToFilter);
1931  _values.push_back(FilterToConnection);
1932  _values.push_back(ConnectionToEnvironment);
1933  _values.push_back(ConnectionToAirway);
1934  }
1935  return _values;
1936  }
1937  protected:
1938  static std::vector<std::string> _values;
1939  };
1940 
1941  class ECMOCompartment
1942  {
1943  public:
1944  DEFINE_STATIC_STRING_EX(Oxygenator, ECMOOxygenator);
1945  DEFINE_STATIC_STRING_EX(BloodSamplingPort, ECMOBloodSamplingPort);
1946 
1947  static const std::vector<std::string>& GetValues()
1948  {
1949  ScopedMutex lock;
1950  if (_values.empty())
1951  {
1952  _values.push_back(Oxygenator);
1953  _values.push_back(BloodSamplingPort);
1954  }
1955  return _values;
1956  }
1957  static bool HasValue(const std::string& v)
1958  {
1959  return std::find(_values.begin(), _values.end(), v) != _values.end();
1960  }
1961  static void AddValue(const std::string& v)
1962  {
1963  if (!HasValue(v))
1964  {
1965  ScopedMutex lock;
1966  _values.push_back(v);
1967  }
1968  }
1969  protected:
1970  static std::vector<std::string> _values;
1971  };
1972 
1973  class ECMOLink
1974  {
1975  public:
1976  DEFINE_STATIC_STRING(OxygenatorToVasculature);
1977  DEFINE_STATIC_STRING(VasculatureToBloodSamplingPort);
1978  DEFINE_STATIC_STRING(BloodSamplingPortToOxygenator);
1979 
1980  static const std::vector<std::string>& GetValues()
1981  {
1982  ScopedMutex lock;
1983  if (_values.empty())
1984  {
1985  _values.push_back(OxygenatorToVasculature);
1986  _values.push_back(VasculatureToBloodSamplingPort);
1987  _values.push_back(BloodSamplingPortToOxygenator);
1988  }
1989  return _values;
1990  }
1991  static bool HasValue(const std::string& v)
1992  {
1993  return std::find(_values.begin(), _values.end(), v) != _values.end();
1994  }
1995  static void AddValue(const std::string& v)
1996  {
1997  if (!HasValue(v))
1998  {
1999  ScopedMutex lock;
2000  _values.push_back(v);
2001  }
2002  }
2003  protected:
2004  static std::vector<std::string> _values;
2005  };
2006 
2007  class InhalerCompartment
2008  {
2009  public:
2010  DEFINE_STATIC_STRING_EX(Mouthpiece, InhalerMouthpiece);
2011 
2012  static const std::vector<std::string>& GetValues()
2013  {
2014  ScopedMutex lock;
2015  if (_values.empty())
2016  {
2017  _values.push_back(Mouthpiece);
2018  }
2019  return _values;
2020  }
2021  static bool HasValue(const std::string& v)
2022  {
2023  return std::find(_values.begin(), _values.end(), v) != _values.end();
2024  }
2025  static void AddValue(const std::string& v)
2026  {
2027  if (!HasValue(v))
2028  {
2029  ScopedMutex lock;
2030  _values.push_back(v);
2031  }
2032  }
2033  protected:
2034  static std::vector<std::string> _values;
2035  };
2036 
2037  class InhalerLink
2038  {
2039  public:
2040  DEFINE_STATIC_STRING_EX(EnvironmentToMouthpiece, EnvironmentToInhalerMouthpiece);
2041  DEFINE_STATIC_STRING_EX(MouthpieceToAirway, InhalerMouthpieceToAirway);
2042 
2043  static const std::vector<std::string>& GetValues()
2044  {
2045  ScopedMutex lock;
2046  if (_values.empty())
2047  {
2048  _values.push_back(EnvironmentToMouthpiece);
2049  _values.push_back(MouthpieceToAirway);
2050  }
2051  return _values;
2052  }
2053  static bool HasValue(const std::string& v)
2054  {
2055  return std::find(_values.begin(), _values.end(), v) != _values.end();
2056  }
2057  static void AddValue(const std::string& v)
2058  {
2059  if (!HasValue(v))
2060  {
2061  ScopedMutex lock;
2062  _values.push_back(v);
2063  }
2064  }
2065  protected:
2066  static std::vector<std::string> _values;
2067  };
2068 
2069  class MechanicalVentilationCompartment
2070  {
2071  public:
2072  DEFINE_STATIC_STRING_EX(Connection, MechanicalVentilationConnection);
2073 
2074  static const std::vector<std::string>& GetValues()
2075  {
2076  ScopedMutex lock;
2077  if (_values.empty())
2078  {
2079  _values.push_back(Connection);
2080  }
2081  return _values;
2082  }
2083  static bool HasValue(const std::string& v)
2084  {
2085  return std::find(_values.begin(), _values.end(), v) != _values.end();
2086  }
2087  static void AddValue(const std::string& v)
2088  {
2089  if (!HasValue(v))
2090  {
2091  ScopedMutex lock;
2092  _values.push_back(v);
2093  }
2094  }
2095  protected:
2096  static std::vector<std::string> _values;
2097  };
2098 
2099  class MechanicalVentilationLink
2100  {
2101  public:
2102  DEFINE_STATIC_STRING_EX(ConnectionToAirway, MechanicalVentilationConnectionToAirway);
2103 
2104  static const std::vector<std::string>& GetValues()
2105  {
2106  ScopedMutex lock;
2107  if (_values.empty())
2108  {
2109  _values.push_back(ConnectionToAirway);
2110  }
2111  return _values;
2112  }
2113  static bool HasValue(const std::string& v)
2114  {
2115  return std::find(_values.begin(), _values.end(), v) != _values.end();
2116  }
2117  static void AddValue(const std::string& v)
2118  {
2119  if (!HasValue(v))
2120  {
2121  ScopedMutex lock;
2122  _values.push_back(v);
2123  }
2124  }
2125  protected:
2126  static std::vector<std::string> _values;
2127  };
2128 
2129  class MechanicalVentilatorCompartment
2130  {
2131  public:
2132  DEFINE_STATIC_STRING(MechanicalVentilator);
2133  DEFINE_STATIC_STRING_EX(ExpiratoryValve, MechanicalVentilatorExpiratoryValve);
2134  DEFINE_STATIC_STRING_EX(InspiratoryValve, MechanicalVentilatorInspiratoryValve);
2135  DEFINE_STATIC_STRING_EX(ExpiratoryLimb, MechanicalVentilatorExpiratoryLimb);
2136  DEFINE_STATIC_STRING_EX(InspiratoryLimb, MechanicalVentilatorInspiratoryLimb);
2137  DEFINE_STATIC_STRING_EX(YPiece, MechanicalVentilatorYPiece);
2138  DEFINE_STATIC_STRING_EX(ReliefValve, MechanicalVentilatorReliefValve);
2139  DEFINE_STATIC_STRING_EX(Connection, MechanicalVentilatorConnection);
2140 
2141  static const std::vector<std::string>& GetValues()
2142  {
2143  ScopedMutex lock;
2144  if (_values.empty())
2145  {
2146  _values.push_back(MechanicalVentilator);
2147  _values.push_back(ExpiratoryValve);
2148  _values.push_back(InspiratoryValve);
2149  _values.push_back(ExpiratoryLimb);
2150  _values.push_back(InspiratoryLimb);
2151  _values.push_back(YPiece);
2152  _values.push_back(ReliefValve);
2153  _values.push_back(Connection);
2154  }
2155  return _values;
2156  }
2157  static bool HasValue(const std::string& v)
2158  {
2159  return std::find(_values.begin(), _values.end(), v) != _values.end();
2160  }
2161  static void AddValue(const std::string& v)
2162  {
2163  if (!HasValue(v))
2164  {
2165  ScopedMutex lock;
2166  _values.push_back(v);
2167  }
2168  }
2169  protected:
2170  static std::vector<std::string> _values;
2171  };
2172 
2173  class MechanicalVentilatorLink
2174  {
2175  public:
2176  DEFINE_STATIC_STRING(MechanicalVentilatorToExpiratoryValve);
2177  DEFINE_STATIC_STRING(MechanicalVentilatorToInspiratoryValve);
2178  DEFINE_STATIC_STRING_EX(ExpiratoryLimbToExpiratoryValve, MechanicalVentilatorExpiratoryLimbToExpiratoryValve);
2179  DEFINE_STATIC_STRING_EX(InspiratoryValveToInspiratoryLimb, MechanicalVentilatorInspiratoryValveToInspiratoryLimb);
2180  DEFINE_STATIC_STRING_EX(ExpiratoryLimbToYPiece, MechanicalVentilatorExpiratoryLimbToYPiece);
2181  DEFINE_STATIC_STRING_EX(InspiratoryLimbToYPiece, MechanicalVentilatorInspiratoryLimbToYPiece);
2182  DEFINE_STATIC_STRING_EX(YPieceToConnection, MechanicalVentilatorYPieceToConnection);
2183  DEFINE_STATIC_STRING_EX(LeakConnectionToEnvironment, MechanicalVentilatorLeakConnectionToEnvironment);
2184  DEFINE_STATIC_STRING_EX(ConnectionToReliefValve, MechanicalVentilatorConnectionToReliefValve);
2185  DEFINE_STATIC_STRING_EX(EnvironmentToReliefValve, MechanicalVentilatorEnvironmentToReliefValve);
2186  DEFINE_STATIC_STRING_EX(ConnectionToEnvironment, MechanicalVentilatorConnectionToEnvironment);
2187  DEFINE_STATIC_STRING_EX(ConnectionToAirway, MechanicalVentilatorConnectionToAirway);
2188 
2189  static const std::vector<std::string>& GetValues()
2190  {
2191  ScopedMutex lock;
2192  if (_values.empty())
2193  {
2194  _values.push_back(MechanicalVentilatorToExpiratoryValve);
2195  _values.push_back(MechanicalVentilatorToInspiratoryValve);
2196  _values.push_back(ExpiratoryLimbToExpiratoryValve);
2197  _values.push_back(InspiratoryValveToInspiratoryLimb);
2198  _values.push_back(ExpiratoryLimbToYPiece);
2199  _values.push_back(InspiratoryLimbToYPiece);
2200  _values.push_back(YPieceToConnection);
2201  _values.push_back(LeakConnectionToEnvironment);
2202  _values.push_back(ConnectionToReliefValve);
2203  _values.push_back(EnvironmentToReliefValve);
2204  _values.push_back(ConnectionToEnvironment);
2205  _values.push_back(ConnectionToAirway);
2206  }
2207  return _values;
2208  }
2209  static bool HasValue(const std::string& v)
2210  {
2211  return std::find(_values.begin(), _values.end(), v) != _values.end();
2212  }
2213  static void AddValue(const std::string& v)
2214  {
2215  if (!HasValue(v))
2216  {
2217  ScopedMutex lock;
2218  _values.push_back(v);
2219  }
2220  }
2221  protected:
2222  static std::vector<std::string> _values;
2223  };
2224 
2225  class NasalCannulaCompartment
2226  {
2227  public:
2228  DEFINE_STATIC_STRING(NasalCannulaOxygenSource);
2229  DEFINE_STATIC_STRING(NasalCannula);
2230 
2231  static const std::vector<std::string>& GetValues()
2232  {
2233  ScopedMutex lock;
2234  if (_values.empty())
2235  {
2236  _values.push_back(NasalCannulaOxygenSource);
2237  _values.push_back(NasalCannula);
2238  }
2239  return _values;
2240  }
2241  static bool HasValue(const std::string& v)
2242  {
2243  return std::find(_values.begin(), _values.end(), v) != _values.end();
2244  }
2245  static void AddValue(const std::string& v)
2246  {
2247  if (!HasValue(v))
2248  {
2249  ScopedMutex lock;
2250  _values.push_back(v);
2251  }
2252  }
2253  protected:
2254  static std::vector<std::string> _values;
2255  };
2256 
2257  class NasalCannulaLink
2258  {
2259  public:
2260  DEFINE_STATIC_STRING(NasalCannulaOxygenInlet);
2261  DEFINE_STATIC_STRING(NasalCannulaSeal);
2262  DEFINE_STATIC_STRING(NasalCannulaToAirway);
2263 
2264  static const std::vector<std::string>& GetValues()
2265  {
2266  ScopedMutex lock;
2267  if (_values.empty())
2268  {
2269  _values.push_back(NasalCannulaOxygenInlet);
2270  _values.push_back(NasalCannulaSeal);
2271  _values.push_back(NasalCannulaToAirway);
2272  }
2273  return _values;
2274  }
2275  static bool HasValue(const std::string& v)
2276  {
2277  return std::find(_values.begin(), _values.end(), v) != _values.end();
2278  }
2279  static void AddValue(const std::string& v)
2280  {
2281  if (!HasValue(v))
2282  {
2283  ScopedMutex lock;
2284  _values.push_back(v);
2285  }
2286  }
2287  protected:
2288  static std::vector<std::string> _values;
2289  };
2290 
2291  class NonRebreatherMaskCompartment
2292  {
2293  public:
2294  DEFINE_STATIC_STRING(NonRebreatherMaskOxygenSource);
2295  DEFINE_STATIC_STRING(NonRebreatherMaskPorts);
2296  DEFINE_STATIC_STRING(NonRebreatherMaskBag);
2297  DEFINE_STATIC_STRING(NonRebreatherMask);
2298 
2299  static const std::vector<std::string>& GetValues()
2300  {
2301  ScopedMutex lock;
2302  if (_values.empty())
2303  {
2304  _values.push_back(NonRebreatherMaskOxygenSource);
2305  _values.push_back(NonRebreatherMaskPorts);
2306  _values.push_back(NonRebreatherMaskBag);
2307  _values.push_back(NonRebreatherMask);
2308  }
2309  return _values;
2310  }
2311  static bool HasValue(const std::string& v)
2312  {
2313  return std::find(_values.begin(), _values.end(), v) != _values.end();
2314  }
2315  static void AddValue(const std::string& v)
2316  {
2317  if (!HasValue(v))
2318  {
2319  ScopedMutex lock;
2320  _values.push_back(v);
2321  }
2322  }
2323  protected:
2324  static std::vector<std::string> _values;
2325  };
2326 
2327  class NonRebreatherMaskLink
2328  {
2329  public:
2330  DEFINE_STATIC_STRING(NonRebreatherMaskOxygenInlet);
2331  DEFINE_STATIC_STRING(NonRebreatherMaskReservoirValve);
2332  DEFINE_STATIC_STRING(NonRebreatherMaskSeal);
2333  DEFINE_STATIC_STRING(NonRebreatherMaskExhalationValves);
2334  DEFINE_STATIC_STRING(NonRebreatherMaskExhalation);
2335  DEFINE_STATIC_STRING(NonRebreatherMaskToAirway);
2336 
2337  static const std::vector<std::string>& GetValues()
2338  {
2339  ScopedMutex lock;
2340  if (_values.empty())
2341  {
2342  _values.push_back(NonRebreatherMaskOxygenInlet);
2343  _values.push_back(NonRebreatherMaskReservoirValve);
2344  _values.push_back(NonRebreatherMaskSeal);
2345  _values.push_back(NonRebreatherMaskExhalationValves);
2346  _values.push_back(NonRebreatherMaskExhalation);
2347  _values.push_back(NonRebreatherMaskToAirway);
2348  }
2349  return _values;
2350  }
2351  static bool HasValue(const std::string& v)
2352  {
2353  return std::find(_values.begin(), _values.end(), v) != _values.end();
2354  }
2355  static void AddValue(const std::string& v)
2356  {
2357  if (!HasValue(v))
2358  {
2359  ScopedMutex lock;
2360  _values.push_back(v);
2361  }
2362  }
2363  protected:
2364  static std::vector<std::string> _values;
2365  };
2366 
2367  class SimpleMaskCompartment
2368  {
2369  public:
2370  DEFINE_STATIC_STRING(SimpleMaskOxygenSource);
2371  DEFINE_STATIC_STRING(SimpleMask);
2372 
2373  static const std::vector<std::string>& GetValues()
2374  {
2375  ScopedMutex lock;
2376  if (_values.empty())
2377  {
2378  _values.push_back(SimpleMaskOxygenSource);
2379  _values.push_back(SimpleMask);
2380  }
2381  return _values;
2382  }
2383  static bool HasValue(const std::string& v)
2384  {
2385  return std::find(_values.begin(), _values.end(), v) != _values.end();
2386  }
2387  static void AddValue(const std::string& v)
2388  {
2389  if (!HasValue(v))
2390  {
2391  ScopedMutex lock;
2392  _values.push_back(v);
2393  }
2394  }
2395  protected:
2396  static std::vector<std::string> _values;
2397  };
2398 
2399  class SimpleMaskLink
2400  {
2401  public:
2402  DEFINE_STATIC_STRING(SimpleMaskOxygenInlet);
2403  DEFINE_STATIC_STRING(SimpleMaskSeal);
2404  DEFINE_STATIC_STRING(SimpleMaskPorts);
2405  DEFINE_STATIC_STRING(SimpleMaskToAirway);
2406 
2407  static const std::vector<std::string>& GetValues()
2408  {
2409  ScopedMutex lock;
2410  if (_values.empty())
2411  {
2412  _values.push_back(SimpleMaskOxygenInlet);
2413  _values.push_back(SimpleMaskSeal);
2414  _values.push_back(SimpleMaskPorts);
2415  _values.push_back(SimpleMaskToAirway);
2416  }
2417  return _values;
2418  }
2419  static bool HasValue(const std::string& v)
2420  {
2421  return std::find(_values.begin(), _values.end(), v) != _values.end();
2422  }
2423  static void AddValue(const std::string& v)
2424  {
2425  if (!HasValue(v))
2426  {
2427  ScopedMutex lock;
2428  _values.push_back(v);
2429  }
2430  }
2431  protected:
2432  static std::vector<std::string> _values;
2433  };
2434 END_NAMESPACE
Logger
Definition: Logger.h:71
ScopedMutex
Definition: ScopedMutex.h:7
pulse
Definition: Logger.h:14
PulseBuildInformation
Definition: PulseEngine.h:11
PulseBuildInformation::Version
static std::string Version()
PulseBuildInformation::Time
static std::string Time()
PulseBuildInformation::Hash
static std::string Hash()

Distributed under the Apache License, Version 2.0.

See accompanying NOTICE file for details.