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