Got new skin circuit nodes working for head/torso. Ready to be tested and tuned. Also updated unit test, how-tos, stabilization, and physiology requests to match new changes. Still need to update all scenarios and expand to inlude arms and legs

Author: ntatum94

projects/biogears/libBiogears/include/biogears/cdm/system/physiology/SEEnergySystem.h

@@ -98,9 +98,13 @@ class BIOGEARS_API SEEnergySystem : public SESystem {
   SEScalarMass& GetPotassiumLostToSweat();
   double GetPotassiumLostToSweat(const MassUnit& unit) const;
 
-  bool HasSkinTemperature() const;
-  SEScalarTemperature& GetSkinTemperature();
-  double GetSkinTemperature(const TemperatureUnit& unit) const;
+  bool HasSkinTemperatureTorso() const;
+  SEScalarTemperature& GetSkinTemperatureTorso();
+  double GetSkinTemperatureTorso(const TemperatureUnit& unit) const;
+
+  bool HasSkinTemperatureHead() const;
+  SEScalarTemperature& GetSkinTemperatureHead();
+  double GetSkinTemperatureHead(const TemperatureUnit& unit) const;
 
   bool HasSodiumLostToSweat() const;
   SEScalarMass& GetSodiumLostToSweat();
@@ -129,7 +133,8 @@ class BIOGEARS_API SEEnergySystem : public SESystem {
   SEScalarFraction* m_FatigueLevel;
   SEScalarAmountPerTime* m_LactateProductionRate;
   SEScalarMass* m_PotassiumLostToSweat;
-  SEScalarTemperature* m_SkinTemperature;
+  SEScalarTemperature* m_SkinTemperatureTorso;
+  SEScalarTemperature* m_SkinTemperatureHead;
   SEScalarMass* m_SodiumLostToSweat;
   SEScalarMassPerTime* m_SweatRate;
   SEScalarPower* m_TotalMetabolicRate;

projects/biogears/libBiogears/include/biogears/engine/Systems/Energy.h

@@ -112,7 +112,9 @@ class BIOGEARS_API Energy : public SEEnergySystem, public BioGearsSystem {
   SELiquidSubstanceQuantity* m_SkinPotassium;
   //Nodes
   SEThermalCircuitNode* m_coreNode;
-  SEThermalCircuitNode* m_skinNode;
+  SEThermalCircuitNode* m_torsoSkinNode;
+  SEThermalCircuitNode* m_headSkinNode;
+  std::vector<SEThermalCircuitNode*> m_skinNodes;
   //Paths
   SEThermalCircuitPath* m_temperatureGroundToCorePath;
   std::vector<SEThermalCircuitPath*> m_coreToSkinPaths;

projects/biogears/libBiogears/src/cdm/system/physiology/SEEnergySystem.cpp

@@ -34,7 +34,8 @@ constexpr char idExerciseMeanArterialPressureDelta[] = "ExerciseMeanArterialPres
 constexpr char idFatigueLevel[] = "FatigueLevel";
 constexpr char idLactateProductionRate[] = "LactateProductionRate";
 constexpr char idPotassiumLostToSweat[] = "PotassiumLostToSweat";
-constexpr char idSkinTemperature[] = "SkinTemperature";
+constexpr char idSkinTemperatureTorso[] = "SkinTemperatureTorso";
+constexpr char idSkinTemperatureHead[] = "SkinTemperatureHead";
 constexpr char idSodiumLostToSweat[] = "SodiumLostToSweat";
 constexpr char idSweatRate[] = "SweatRate";
 constexpr char idTotalMetabolicRate[] = "TotalMetabolicRate";
@@ -53,7 +54,8 @@ SEEnergySystem::SEEnergySystem(Logger* logger)
   m_FatigueLevel = nullptr;
   m_LactateProductionRate = nullptr;
   m_PotassiumLostToSweat = nullptr;
-  m_SkinTemperature = nullptr;
+  m_SkinTemperatureTorso = nullptr;
+  m_SkinTemperatureHead = nullptr;
   m_SodiumLostToSweat = nullptr;
   m_SweatRate = nullptr;
   m_TotalMetabolicRate = nullptr;
@@ -81,7 +83,8 @@ void SEEnergySystem::Clear()
   SAFE_DELETE(m_FatigueLevel);
   SAFE_DELETE(m_LactateProductionRate);
   SAFE_DELETE(m_PotassiumLostToSweat);
-  SAFE_DELETE(m_SkinTemperature);
+  SAFE_DELETE(m_SkinTemperatureTorso);
+  SAFE_DELETE(m_SkinTemperatureHead);
   SAFE_DELETE(m_SodiumLostToSweat);
   SAFE_DELETE(m_SweatRate);
   SAFE_DELETE(m_TotalMetabolicRate);
@@ -114,8 +117,10 @@ const SEScalar* SEEnergySystem::GetScalar(const std::string& name)
     return &GetLactateProductionRate();
   if (name == idPotassiumLostToSweat)
     return &GetPotassiumLostToSweat();
-  if (name == idSkinTemperature)
-    return &GetSkinTemperature();
+  if (name == idSkinTemperatureTorso)
+    return &GetSkinTemperatureTorso();
+  if (name == idSkinTemperatureHead)
+    return &GetSkinTemperatureHead();
   if (name == idSodiumLostToSweat)
     return &GetSodiumLostToSweat();
   if (name == idSweatRate)
@@ -152,8 +157,10 @@ bool SEEnergySystem::Load(const CDM::EnergySystemData& in)
     GetLactateProductionRate().Load(in.LactateProductionRate().get());
   if (in.PotassiumLostToSweat().present())
     GetPotassiumLostToSweat().Load(in.PotassiumLostToSweat().get());
-  if (in.SkinTemperature().present())
-    GetSkinTemperature().Load(in.SkinTemperature().get());
+  if (in.SkinTemperatureTorso().present())
+    GetSkinTemperatureTorso().Load(in.SkinTemperatureTorso().get());
+  if (in.SkinTemperatureHead().present())
+    GetSkinTemperatureHead().Load(in.SkinTemperatureHead().get());
   if (in.SodiumLostToSweat().present())
     GetSodiumLostToSweat().Load(in.SodiumLostToSweat().get());
   if (in.SweatRate().present())
@@ -199,8 +206,10 @@ void SEEnergySystem::Unload(CDM::EnergySystemData& data) const
     data.LactateProductionRate(std::unique_ptr<CDM::ScalarAmountPerTimeData>(m_LactateProductionRate->Unload()));
   if (m_PotassiumLostToSweat != nullptr)
     data.PotassiumLostToSweat(std::unique_ptr<CDM::ScalarMassData>(m_PotassiumLostToSweat->Unload()));
-  if (m_SkinTemperature != nullptr)
-    data.SkinTemperature(std::unique_ptr<CDM::ScalarTemperatureData>(m_SkinTemperature->Unload()));
+  if (m_SkinTemperatureTorso != nullptr)
+    data.SkinTemperatureTorso(std::unique_ptr<CDM::ScalarTemperatureData>(m_SkinTemperatureTorso->Unload()));
+  if (m_SkinTemperatureHead != nullptr)
+    data.SkinTemperatureHead(std::unique_ptr<CDM::ScalarTemperatureData>(m_SkinTemperatureHead->Unload()));
   if (m_SodiumLostToSweat != nullptr)
     data.SodiumLostToSweat(std::unique_ptr<CDM::ScalarMassData>(m_SodiumLostToSweat->Unload()));
   if (m_SweatRate != nullptr)
@@ -407,24 +416,42 @@ double SEEnergySystem::GetPotassiumLostToSweat(const MassUnit& unit) const
   return m_PotassiumLostToSweat->GetValue(unit);
 }
 //-------------------------------------------------------------------------------
-
-bool SEEnergySystem::HasSkinTemperature() const
+bool SEEnergySystem::HasSkinTemperatureTorso() const
+{
+  return m_SkinTemperatureTorso == nullptr ? false : m_SkinTemperatureTorso->IsValid();
+}
+//-------------------------------------------------------------------------------
+SEScalarTemperature& SEEnergySystem::GetSkinTemperatureTorso()
+{
+  if (m_SkinTemperatureTorso == nullptr)
+    m_SkinTemperatureTorso = new SEScalarTemperature();
+  return *m_SkinTemperatureTorso;
+}
+//-------------------------------------------------------------------------------
+double SEEnergySystem::GetSkinTemperatureTorso(const TemperatureUnit& unit) const
+{
+  if (m_SkinTemperatureTorso == nullptr)
+    return SEScalar::dNaN();
+  return m_SkinTemperatureTorso->GetValue(unit);
+}
+//-------------------------------------------------------------------------------
+bool SEEnergySystem::HasSkinTemperatureHead() const
 {
-  return m_SkinTemperature == nullptr ? false : m_SkinTemperature->IsValid();
+  return m_SkinTemperatureHead == nullptr ? false : m_SkinTemperatureHead->IsValid();
 }
 //-------------------------------------------------------------------------------
-SEScalarTemperature& SEEnergySystem::GetSkinTemperature()
+SEScalarTemperature& SEEnergySystem::GetSkinTemperatureHead()
 {
-  if (m_SkinTemperature == nullptr)
-    m_SkinTemperature = new SEScalarTemperature();
-  return *m_SkinTemperature;
+  if (m_SkinTemperatureHead == nullptr)
+    m_SkinTemperatureHead = new SEScalarTemperature();
+  return *m_SkinTemperatureHead;
 }
 //-------------------------------------------------------------------------------
-double SEEnergySystem::GetSkinTemperature(const TemperatureUnit& unit) const
+double SEEnergySystem::GetSkinTemperatureHead(const TemperatureUnit& unit) const
 {
-  if (m_SkinTemperature == nullptr)
+  if (m_SkinTemperatureHead == nullptr)
     return SEScalar::dNaN();
-  return m_SkinTemperature->GetValue(unit);
+  return m_SkinTemperatureHead->GetValue(unit);
 }
 //-------------------------------------------------------------------------------
 
@@ -518,7 +545,8 @@ Tree<const char*> SEEnergySystem::GetPhysiologyRequestGraph() const
     .emplace_back(idFatigueLevel)
     .emplace_back(idLactateProductionRate)
     .emplace_back(idPotassiumLostToSweat)
-    .emplace_back(idSkinTemperature)
+    .emplace_back(idSkinTemperatureTorso)
+    .emplace_back(idSkinTemperatureHead)
     .emplace_back(idSodiumLostToSweat)
     .emplace_back(idSweatRate)
     .emplace_back(idTotalMetabolicRate)

projects/biogears/libBiogears/src/engine/Systems/Energy.cpp

@@ -80,7 +80,6 @@ void Energy::Clear()
   m_SkinChloride = nullptr;
   m_SkinPotassium = nullptr;
   m_coreNode = nullptr;
-  m_skinNode = nullptr;
   m_temperatureGroundToCorePath = nullptr;
   m_skinExtravascularToSweatingGroundPath = nullptr;
   m_InternalTemperatureCircuit = nullptr;
@@ -104,7 +103,8 @@ void Energy::Initialize()
   //Initialization of other system variables
   /// \cite herman2008physics
   GetCoreTemperature().SetValue(37.0, TemperatureUnit::C);
-  GetSkinTemperature().SetValue(33.0, TemperatureUnit::C);
+  GetSkinTemperatureTorso().SetValue(33.0, TemperatureUnit::C);
+  GetSkinTemperatureHead().SetValue(33.0, TemperatureUnit::C);
   /// \cite phypers2006lactate
   GetLactateProductionRate().SetValue(1.3, AmountPerTimeUnit::mol_Per_day);
   /// \cite guyton2006medical
@@ -182,7 +182,9 @@ void Energy::SetUp()
   m_InternalTemperatureCircuit = &m_data.GetCircuits().GetInternalTemperatureCircuit();
   //Nodes
   m_coreNode = m_InternalTemperatureCircuit->GetNode(BGE::InternalTemperatureNode::InternalCore);
-  m_skinNode = m_InternalTemperatureCircuit->GetNode(BGE::InternalTemperatureNode::InternalTorsoSkin); // NOTE this is currently used for vitals and sweat rate. First pass will use torso being the largest of the skin nodes
+  m_skinNodes.clear();
+  m_skinNodes.push_back(m_InternalTemperatureCircuit->GetNode(BGE::InternalTemperatureNode::InternalTorsoSkin));
+  m_skinNodes.push_back(m_InternalTemperatureCircuit->GetNode(BGE::InternalTemperatureNode::InternalHeadSkin));
   //Paths
   m_temperatureGroundToCorePath = m_InternalTemperatureCircuit->GetPath(BGE::InternalTemperaturePath::GroundToInternalCore);
   m_skinExtravascularToSweatingGroundPath = m_data.GetCircuits().GetActiveCardiovascularCircuit().GetPath(BGE::TissuePath::SkinSweating);
@@ -401,13 +403,15 @@ void Energy::PostProcess()
 void Energy::CalculateVitalSigns()
 {
   double coreTemperature_degC = m_coreNode->GetTemperature(TemperatureUnit::C);
-  double skinTemperature_degC = m_skinNode->GetTemperature(TemperatureUnit::C);
+  double skinTemperatureTorso_degC = m_skinNodes[0]->GetTemperature(TemperatureUnit::C);
+  double skinTemperatureHead_degC = m_skinNodes[1]->GetTemperature(TemperatureUnit::C);
   if (m_data.GetDrugs().HasFeverChange() && GetCoreTemperature().GetValue(TemperatureUnit::C) > 37.0) { // Modifier for current drugs should not be able to increase core temperature
     coreTemperature_degC += m_data.GetDrugs().GetFeverChange().GetValue(TemperatureUnit::C);
     LLIM(coreTemperature_degC, 36.5); // Tylenol will not lower your basal core temperature
   }
   GetCoreTemperature().SetValue(coreTemperature_degC, TemperatureUnit::C);
-  GetSkinTemperature().SetValue(skinTemperature_degC, TemperatureUnit::C);
+  GetSkinTemperatureTorso().SetValue(skinTemperatureTorso_degC, TemperatureUnit::C);
+  GetSkinTemperatureHead().SetValue(skinTemperatureHead_degC, TemperatureUnit::C);
   std::stringstream ss;
 
   //Hypothermia check
@@ -581,48 +585,51 @@ void Energy::CalculateSweatRate()
   double dWaterVaporPressureInAmbientAir_mmHg = GeneralMath::AntoineEquation(dAirTemperature_C);
   double m_dWaterVaporPressureInAmbientAir_Pa = Convert(dWaterVaporPressureInAmbientAir_mmHg, PressureUnit::mmHg, PressureUnit::Pa);
   // double ambientAtmosphericPressure_Pa = m_data.GetEnvironment().GetConditions().GetAtmosphericPressure().GetValue(PressureUnit::Pa);
-  double maximumEvaporativeCapacity_W = 14.21 * (m_Patient->GetSkinSurfaceArea().GetValue(AreaUnit::m2)) * effectiveClothingEvaporation_im_Per_clo * (133.322 * (std::pow(10, (8.1076 - (1750.286 / (235.0 + (m_skinNode->GetTemperature(TemperatureUnit::C))))))) - ((m_dWaterVaporPressureInAmbientAir_Pa))); //Still needs effective clothing evaporation
-
   double vaporizationEnergy_J_Per_kg = m_data.GetConfiguration().GetVaporizationEnergy(EnergyPerMassUnit::J_Per_kg);
   double sweatSodiumConcentration_mM = 51.0; /// \cite shirreffs1997whole
   double sweatPotassiumConcentration_mM = 6.0; /// \cite shirreffs1997whole
   double sweatChlorideConcentration_mM = 48.0; /// \cite shirreffs1997whole
-    // static double totalSweatLost_mL = 0; --Used to figure out total sweat loss during exercise scenario during debugging
-
-  double currentEvaporativeCapacity_W = sweatHeatTranferCoefficient_W_Per_K * (m_skinNode->GetTemperature(TemperatureUnit::K));
-  if (currentEvaporativeCapacity_W > maximumEvaporativeCapacity_W) {
+  // static double totalSweatLost_mL = 0; --Used to figure out total sweat loss during exercise scenario during debugging
 
-    sweatHeatTranferCoefficient_W_Per_K = maximumEvaporativeCapacity_W / (m_skinNode->GetTemperature(TemperatureUnit::K));
-  }
-
-  /// \todo Convert to sweat density once specific gravity calculation is in
+  double overallSweatRate_kg_Per_s = 0.0;
   SEScalarMassPerVolume sweatDensity;
-  GeneralMath::CalculateWaterDensity(m_skinNode->GetTemperature(), sweatDensity);
-  double dehydrationFraction = m_data.GetTissue().GetDehydrationFraction().GetValue();
+  for (SEThermalCircuitNode* skinNode : m_skinNodes) {
+    double maximumEvaporativeCapacity_W = 14.21 * (m_Patient->GetSkinSurfaceArea().GetValue(AreaUnit::m2)) * effectiveClothingEvaporation_im_Per_clo * (133.322 * (std::pow(10, (8.1076 - (1750.286 / (235.0 + (skinNode->GetTemperature(TemperatureUnit::C))))))) - ((m_dWaterVaporPressureInAmbientAir_Pa))); // Still needs effective clothing evaporation
+    double currentEvaporativeCapacity_W = sweatHeatTranferCoefficient_W_Per_K * (skinNode->GetTemperature(TemperatureUnit::K));
+    if (currentEvaporativeCapacity_W > maximumEvaporativeCapacity_W) {
 
-  //Calculate sweat rate (in kg/s) from core temperature feedback.
-  //The sweat rate heat transfer is determined from a control equation that attempts to keep the core temperature in line
-  /// \cite herman2008physics
-  //Sweat rate decreases as dehydration becomes more severe, with max reduction seen at 10% dehydration
-  double dehydrationScalingFactor = GeneralMath::LinearInterpolator(0, .1, 1, 0, dehydrationFraction);
-  BLIM(dehydrationScalingFactor, 0, 1);
-  double sweatRate_kg_Per_s = dehydrationScalingFactor * (0.25 * sweatHeatTranferCoefficient_W_Per_K / vaporizationEnergy_J_Per_kg) * (coreTemperature_degC - coreTemperatureHigh_degC);
+      sweatHeatTranferCoefficient_W_Per_K = maximumEvaporativeCapacity_W / (skinNode->GetTemperature(TemperatureUnit::K));
+    }
 
-  //The Sweat Scaling Factor is caused by changes in the Hyperhidrosis patient parameter to invoke either hyperhidrosis or hypohidrosis
-  /// \cite shih1983autonomic
-  double sweatScalingFactor = 0.0;
-  if (m_Patient->HasHyperhidrosis()) {
-    sweatScalingFactor = m_Patient->GetHyperhidrosis().GetValue();
-    sweatRate_kg_Per_s = (1 + sweatScalingFactor) * sweatRate_kg_Per_s;
+    double dehydrationFraction = m_data.GetTissue().GetDehydrationFraction().GetValue();
+
+    // Calculate sweat rate (in kg/s) from core temperature feedback.
+    // The sweat rate heat transfer is determined from a control equation that attempts to keep the core temperature in line
+    /// \cite herman2008physics
+    // Sweat rate decreases as dehydration becomes more severe, with max reduction seen at 10% dehydration
+    double dehydrationScalingFactor = GeneralMath::LinearInterpolator(0, .1, 1, 0, dehydrationFraction);
+    BLIM(dehydrationScalingFactor, 0, 1);
+    double sweatRate_kg_Per_s = dehydrationScalingFactor * (0.25 * sweatHeatTranferCoefficient_W_Per_K / vaporizationEnergy_J_Per_kg) * (coreTemperature_degC - coreTemperatureHigh_degC);
+
+    // The Sweat Scaling Factor is caused by changes in the Hyperhidrosis patient parameter to invoke either hyperhidrosis or hypohidrosis
+    /// \cite shih1983autonomic
+    double sweatScalingFactor = 0.0;
+    if (m_Patient->HasHyperhidrosis()) {
+      sweatScalingFactor = m_Patient->GetHyperhidrosis().GetValue();
+      sweatRate_kg_Per_s = (1 + sweatScalingFactor) * sweatRate_kg_Per_s;
+    }
+    overallSweatRate_kg_Per_s += sweatRate_kg_Per_s;
   }
+  /// \todo Convert to sweat density once specific gravity calculation is in
+  GeneralMath::CalculateWaterDensity(m_skinNodes[0]->GetTemperature(), sweatDensity); // using trunk as representation due to it having the largest surface area. This will likely be vectorized out later
 
   double maxSweatRate_kg_Per_s = 12.5 * m_Patient->GetSkinSurfaceArea().GetValue(AreaUnit::m2) / 60.0 / 1000.0; //10 - 15 g/min/m2
-  BLIM(sweatRate_kg_Per_s, 0.0, maxSweatRate_kg_Per_s);
+  BLIM(overallSweatRate_kg_Per_s, 0.0, maxSweatRate_kg_Per_s);
 
   //Account for mass lost by subtracting from the current patient mass
-  double massLost_kg = sweatRate_kg_Per_s * m_dT_s;
+  double massLost_kg = overallSweatRate_kg_Per_s * m_dT_s;
   m_Patient->GetWeight().IncrementValue(-massLost_kg, MassUnit::kg);
-  GetSweatRate().SetValue(sweatRate_kg_Per_s, MassPerTimeUnit::kg_Per_s);
+  GetSweatRate().SetValue(overallSweatRate_kg_Per_s, MassPerTimeUnit::kg_Per_s);
 
   //Calculate mass of ions lost in sweat (sodium, potassium, and chloride):  Converts kg sweat lost -> L sweat lost -> mmol ion lost -> mg ion lost
   double sodiumLost_mg = massLost_kg / sweatDensity.GetValue(MassPerVolumeUnit::kg_Per_L) * sweatSodiumConcentration_mM * m_data.GetSubstances().GetSodium().GetMolarMass(MassPerAmountUnit::mg_Per_mmol);
@@ -641,7 +648,7 @@ void Energy::CalculateSweatRate()
   m_SkinChloride->Balance(BalanceLiquidBy::Mass);
 
   //Set the flow source on the extravascular circuit to begin removing the fluid that is excreted
-  double sweatRate_mL_Per_s = sweatRate_kg_Per_s / sweatDensity.GetValue(MassPerVolumeUnit::kg_Per_mL);
+  double sweatRate_mL_Per_s = overallSweatRate_kg_Per_s / sweatDensity.GetValue(MassPerVolumeUnit::kg_Per_mL);
   m_skinExtravascularToSweatingGroundPath->GetNextFlowSource().SetValue(sweatRate_mL_Per_s, VolumePerTimeUnit::mL_Per_s);
 }
 
@@ -778,8 +785,10 @@ void Energy::ProcessOverride()
   if (override->HasLactateProductionRateOverride()) {
     GetLactateProductionRate().SetValue(override->GetLactateProductionRateOverride(AmountPerTimeUnit::mol_Per_s), AmountPerTimeUnit::mol_Per_s);
   }
+  // All skin nodes currently adjusted for a skin temperature override
   if (override->HasSkinTemperatureOverride()) {
-    GetSkinTemperature().SetValue(override->GetSkinTemperatureOverride(TemperatureUnit::C), TemperatureUnit::C);
+    GetSkinTemperatureTorso().SetValue(override->GetSkinTemperatureOverride(TemperatureUnit::C), TemperatureUnit::C);
+    GetSkinTemperatureHead().SetValue(override->GetSkinTemperatureOverride(TemperatureUnit::C), TemperatureUnit::C);
   }
   if (override->HasSweatRateOverride()) {
     GetSweatRate().SetValue(override->GetSweatRateOverride(MassPerTimeUnit::g_Per_s), MassPerTimeUnit::g_Per_s);

projects/biogears/libBiogears/src/engine/Systems/Environment.cpp

@@ -252,7 +252,7 @@ void Environment::PreProcess()
   // 0 is torso, gets 40 percent of clo
   // 1 is head, gets no clo (assume not hat/hair for now)
   m_SkinToClothingPaths[0]->GetNextResistance().SetValue(0.4 * skinToClothingResistance, HeatResistanceUnit::K_Per_W);
-  m_SkinToClothingPaths[1]->GetNextResistance().SetValue(0.0 * skinToClothingResistance, HeatResistanceUnit::K_Per_W);
+  m_SkinToClothingPaths[1]->GetNextResistance().SetValue(0.01 * skinToClothingResistance, HeatResistanceUnit::K_Per_W);
 
   //Set the skin heat loss
   double dSkinHeatLoss_W = 0.0;