src/plugins/chiller.cpp

   1 /* Copyright (c) 2023. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5 #include <simgrid/Exception.hpp>
   6 #include <simgrid/plugins/chiller.hpp>
   7 #include <simgrid/plugins/energy.h>
   8 #include <simgrid/simix.hpp>
   9 #include <xbt/asserts.h>
  10 #include <xbt/log.h>
  11
  12 #include "src/kernel/resource/CpuImpl.hpp"
  13 #include "src/simgrid/module.hpp"
  14
  15 SIMGRID_REGISTER_PLUGIN(chiller, "Chiller management", nullptr)
  16
  17 /** @defgroup plugin_chiller Plugin Chiller
  18
  19   @beginrst
  20
  21 This is the chiller plugin, enabling management of chillers.
  22
  23 Chiller
  24 .......
  25
  26 A chiller is placed inside a room with several machines. The role of the chiller is to keep the temperature of the room
  27 below a threshold. This plugin and its equations are based on the paper "Co-simulation of FMUs and Distributed
  28 Applications with SimGrid" by Camus et al. (https://hal.science/hal-01762540).
  29
  30 The heat generated inside the room :math:`Q_{room}` depends on the heat from the machines :math:`Q_{machines}` and
  31 from the heat of the other devices, such as lighing, accounted using a factor :math:`\alpha` such as:
  32
  33 .. math::
  34
  35   Q_{room} = (1 + \alpha) \times Q_{machines}
  36
  37 This energy heats the input temperature :math:`T_{in}` and gives an output temperature :math:`T_{out}` based on the
  38 mass of air inside the room :math:`m_{air}` and its specific heat :math:`C_{p}`:
  39
  40 .. math::
  41
  42   T_{out} = T_{in} + {Q_{room} \over m_{air} \times C_{p}}
  43
  44 If the output temperature is above the goal temperature :math:`T_{goal}` the chiller compensates the excessive heat
  45 using electrical energy :math:`Q_{cooling}` depending on its cooling efficiency :math:`\eta_{cooling}` :
  46
  47 .. math::
  48
  49   Q_{cooling} = (T_{out} - T_{goal}) \times m_{air} \times C_{p} / \eta_{cooling}
  50
  51 The chiller has a power threshold that cannot be exceeded. If the power needed is above this threshold, or if the
  52 chiller is not active, the temperature of the room increases.
  53
  54   @endrst
  55  */
  56
  57 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(Chiller, kernel, "Logging specific to the solar panel plugin");
  58
  59 namespace simgrid::plugins {
  60
  61 /* ChillerModel */
  62
  63 ChillerModel::ChillerModel() : Model("ChillerModel") {}
  64
  65 void ChillerModel::add_chiller(ChillerPtr c)
  66 {
  67   chillers_.push_back(c);
  68 }
  69
  70 void ChillerModel::update_actions_state(double now, double delta)
  71 {
  72   for (auto chiller : chillers_)
  73     chiller->update();
  74 }
  75
  76 double ChillerModel::next_occurring_event(double now)
  77 {
  78   static bool init = false;
  79   if (not init) {
  80     init = true;
  81     return 0;
  82   } else
  83     return -1;
  84 }
  85
  86 /* Chiller */
  87
  88 std::shared_ptr<ChillerModel> Chiller::chiller_model_;
  89
  90 void Chiller::init_plugin()
  91 {
  92   auto model = std::make_shared<ChillerModel>();
  93   simgrid::s4u::Engine::get_instance()->add_model(model);
  94   Chiller::chiller_model_ = model;
  95 }
  96
  97 void Chiller::update()
  98 {
  99   simgrid::kernel::actor::simcall_answered([this] {
 100     double now          = s4u::Engine::get_clock();
 101     double time_delta_s = now - last_updated_;
 102
 103     if (time_delta_s <= 0)
 104       return;
 105
 106     double hosts_power_w = 0;
 107     for (auto const& host : hosts_) {
 108       hosts_power_w += sg_host_get_current_consumption(host);
 109     }
 110
 111     double heat_generated_j = hosts_power_w * (1 + alpha_) * time_delta_s;
 112     temp_out_c_             = temp_in_c_ + heat_generated_j / (air_mass_kg_ * specific_heat_j_per_kg_per_c_);
 113     double cooling_demand_w =
 114         std::max(temp_out_c_ - goal_temp_c_, 0.0) * air_mass_kg_ * specific_heat_j_per_kg_per_c_ / time_delta_s;
 115     if (not active_)
 116       power_w_ = 0;
 117     else
 118       power_w_ = std::min(max_power_w_, cooling_demand_w / cooling_efficiency_);
 119     temp_in_c_ =
 120         temp_out_c_ - (power_w_ * time_delta_s * cooling_efficiency_) / (air_mass_kg_ * specific_heat_j_per_kg_per_c_);
 121     energy_consumed_j_ += power_w_ * time_delta_s;
 122     last_updated_ = now;
 123   });
 124 }
 125
 126 Chiller::Chiller(const std::string& name, double air_mass_kg, double specific_heat_j_per_kg_per_c, double alpha,
 127                  double cooling_efficiency, double initial_temp_c, double goal_temp_c, double max_power_w)
 128     : name_(name)
 129     , air_mass_kg_(air_mass_kg)
 130     , specific_heat_j_per_kg_per_c_(specific_heat_j_per_kg_per_c)
 131     , alpha_(alpha)
 132     , cooling_efficiency_(cooling_efficiency)
 133     , temp_in_c_(initial_temp_c)
 134     , temp_out_c_(initial_temp_c)
 135     , goal_temp_c_(goal_temp_c)
 136     , max_power_w_(max_power_w)
 137 {
 138   xbt_assert(air_mass_kg > 0, ": air mass must be > 0 (provided: %f)", air_mass_kg);
 139   xbt_assert(specific_heat_j_per_kg_per_c > 0, ": specific heat must be > 0 (provided: %f)",
 140              specific_heat_j_per_kg_per_c);
 141   xbt_assert(alpha >= 0, ": alpha must be >= 0 (provided: %f)", alpha);
 142   xbt_assert(cooling_efficiency >= 0 and cooling_efficiency <= 1,
 143              ": cooling efficiency must be in [0,1] (provided: %f)", cooling_efficiency);
 144   xbt_assert(max_power_w >= 0, ": maximal power must be >=0 (provided: %f)", max_power_w);
 145 }
 146
 147 /** @ingroup plugin_chiller
 148  *  @param name The name of the Chiller.
 149  *  @param air_mass_kg The air mass of the room managed by the Chiller in kg (> 0).
 150  *  @param specific_heat_j_per_kg_per_c The specific heat of air in J per kg per °C (> 0).
 151  *  @param alpha The ratio of the other devices in the total heat dissipation (e.g. lighting, Power Distribution Unit)
 152  * (>= 0).
 153  *  @param cooling_efficiency The cooling efficiency of the Chiller [0, 1].
 154  *  @param initial_temp_c The initial temperature of the room managed by the Chiller.
 155  *  @param goal_temp_c The goal temperature of the room. The Chiller is idle below this temperature.
 156  *  @param max_power_w The maximal power delivered by the Chiller in W (> 0). If this power is reached the room
 157  * temperature will raise above the goal temperature.
 158  *  @return A ChillerPtr pointing to the new Chiller.
 159  */
 160 ChillerPtr Chiller::init(const std::string& name, double air_mass_kg, double specific_heat_j_per_kg_per_c, double alpha,
 161                          double cooling_efficiency, double initial_temp_c, double goal_temp_c, double max_power_w)
 162 {
 163   static bool plugin_inited = false;
 164   if (not plugin_inited) {
 165     init_plugin();
 166     plugin_inited = true;
 167   }
 168   auto chiller = ChillerPtr(new Chiller(name, air_mass_kg, specific_heat_j_per_kg_per_c, alpha, cooling_efficiency,
 169                                         initial_temp_c, goal_temp_c, max_power_w));
 170   chiller_model_->add_chiller(chiller);
 171   return chiller;
 172 }
 173
 174 /** @ingroup plugin_chiller
 175  *  @param name The new name of the Chiller.
 176  *  @return A ChillerPtr pointing to the modified Chiller.
 177  */
 178 ChillerPtr Chiller::set_name(std::string name)
 179 {
 180   simgrid::kernel::actor::simcall_answered([this, name] { name_ = name; });
 181   return this;
 182 }
 183
 184 /** @ingroup plugin_chiller
 185  *  @param air_mass_kg The new air mass of the Chiller in kg.
 186  *  @return A ChillerPtr pointing to the modified Chiller.
 187  */
 188 ChillerPtr Chiller::set_air_mass(double air_mass_kg)
 189 {
 190   xbt_assert(air_mass_kg > 0, ": air mass must be > 0 (provided: %f)", air_mass_kg);
 191   simgrid::kernel::actor::simcall_answered([this, air_mass_kg] { air_mass_kg_ = air_mass_kg; });
 192   return this;
 193 }
 194
 195 /** @ingroup plugin_chiller
 196  *  @param specific_heat_j_per_kg_per_c The specific heat of the Chiller in J per kg per °C.
 197  *  @return A ChillerPtr pointing to the modified Chiller.
 198  */
 199 ChillerPtr Chiller::set_specific_heat(double specific_heat_j_per_kg_per_c)
 200 {
 201   xbt_assert(specific_heat_j_per_kg_per_c > 0, ": specific heat must be > 0 (provided: %f)",
 202              specific_heat_j_per_kg_per_c);
 203   simgrid::kernel::actor::simcall_answered(
 204       [this, specific_heat_j_per_kg_per_c] { specific_heat_j_per_kg_per_c_ = specific_heat_j_per_kg_per_c; });
 205   return this;
 206 }
 207
 208 /** @ingroup plugin_chiller
 209  *  @param alpha The new alpha of the Chiller.
 210  *  @return A ChillerPtr pointing to the modified Chiller.
 211  */
 212 ChillerPtr Chiller::set_alpha(double alpha)
 213 {
 214   xbt_assert(alpha >= 0, ": alpha must be >= 0 (provided: %f)", alpha);
 215   simgrid::kernel::actor::simcall_answered([this, alpha] { alpha_ = alpha; });
 216   return this;
 217 }
 218
 219 /** @ingroup plugin_chiller
 220  *  @param cooling_efficiency The new coolingefficiency of the Chiller.
 221  *  @return A ChillerPtr pointing to the modified Chiller.
 222  */
 223 ChillerPtr Chiller::set_cooling_efficiency(double cooling_efficiency)
 224 {
 225   xbt_assert(cooling_efficiency >= 0 and cooling_efficiency <= 1,
 226              ": cooling efficiency must be in [0,1] (provided: %f)", cooling_efficiency);
 227   simgrid::kernel::actor::simcall_answered([this, cooling_efficiency] { cooling_efficiency_ = cooling_efficiency; });
 228   return this;
 229 }
 230
 231 /** @ingroup plugin_chiller
 232  *  @param goal_temp_c The new goal temperature of the Chiller in °C.
 233  *  @return A ChillerPtr pointing to the modified Chiller.
 234  */
 235 ChillerPtr Chiller::set_goal_temp(double goal_temp_c)
 236 {
 237   simgrid::kernel::actor::simcall_answered([this, goal_temp_c] { goal_temp_c_ = goal_temp_c; });
 238   return this;
 239 }
 240
 241 /** @ingroup plugin_chiller
 242  *  @param max_power_w The new maximal power of the Chiller in W.
 243  *  @return A ChillerPtr pointing to the modified Chiller.
 244  */
 245 ChillerPtr Chiller::set_max_power(double max_power_w)
 246 {
 247   xbt_assert(max_power_w >= 0, ": maximal power must be >=0 (provided: %f)", max_power_w);
 248   simgrid::kernel::actor::simcall_answered([this, max_power_w] { max_power_w_ = max_power_w; });
 249   return this;
 250 }
 251
 252 /** @ingroup plugin_chiller
 253  *  @param active The new active status of the Chiller.
 254  *  @return A ChillerPtr pointing to the modified Chiller.
 255  */
 256 ChillerPtr Chiller::set_active(bool active)
 257 {
 258   simgrid::kernel::actor::simcall_answered([this, active] { active_ = active; });
 259   return this;
 260 }
 261
 262 /** @ingroup plugin_chiller
 263  *  @param host The host to add to the room managed by the Chiller.
 264  *  @return A ChillerPtr pointing to the modified Chiller.
 265  */
 266 ChillerPtr Chiller::add_host(s4u::Host* host)
 267 {
 268   simgrid::kernel::actor::simcall_answered([this, host] { hosts_.insert(host); });
 269   return this;
 270 }
 271
 272 /** @ingroup plugin_chiller
 273  *  @param host The host to remove from the room managed by the Chiller.
 274  *  @return A ChillerPtr pointing to the modified Chiller.
 275  */
 276 ChillerPtr Chiller::remove_host(s4u::Host* host)
 277 {
 278   simgrid::kernel::actor::simcall_answered([this, host] { hosts_.erase(host); });
 279   return this;
 280 }
 281
 282 /** @ingroup plugin_chiller
 283  *  @return The time to reach to goal temp, assuming that the system remain in the same state.
 284  */
 285 double Chiller::get_time_to_goal_temp()
 286 {
 287   if (goal_temp_c_ == temp_in_c_)
 288     return 0;
 289
 290   double heat_power_w = 0;
 291   for (auto const& host : hosts_)
 292     heat_power_w += sg_host_get_current_consumption(host);
 293   heat_power_w = heat_power_w * (1 + alpha_);
 294
 295   if (temp_in_c_ < goal_temp_c_)
 296     return air_mass_kg_ * (goal_temp_c_ - temp_in_c_) * specific_heat_j_per_kg_per_c_ / heat_power_w;
 297
 298   if (not active_)
 299     return -1;
 300   else
 301     return air_mass_kg_ * (temp_in_c_ - goal_temp_c_) * specific_heat_j_per_kg_per_c_ /
 302            (power_w_ * cooling_efficiency_ - heat_power_w);
 303 }
 304 } // namespace simgrid::plugins