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