Support CoilSystem:Cooling:Water

resources/model/OpenStudio.idd

@@ -18981,6 +18981,104 @@ OS:Coil:Cooling:DX:TwoSpeed,
        \type object-list
        \object-list ScheduleNames
 
+OS:CoilSystem:Cooling:Water,
+       \memo Virtual container component that consists of a water cooling coil
+       \memo and its associated controls. This control object supports the
+       \memo available water coil types and may be placed directly on an
+       \memo air loop branch or in an outdoor air equipment list.
+       \min-fields 12
+  A1,  \field Handle
+       \type handle
+       \required-field
+  A2,  \field Name
+       \required-field
+       \reference ConnectionObject
+  A3,  \field Air Inlet Node Name
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+  A4,  \field Air Outlet Node Name
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+  A5,  \field Availability Schedule Name
+       \note Availability schedule name for this system. Schedule value > 0
+       \note means the system is available.
+       \note If this field is blank, the system is always available.
+       \type object-list
+       \object-list ScheduleNames
+       \required-field
+  A6,  \field Cooling Coil
+       \required-field
+       \type object-list
+       \object-list CoolingCoilsWater
+  A7,  \field Dehumidification Control Type
+       \type choice
+       \key None
+       \key Multimode
+       \key CoolReheat
+       \required-field
+       \note None = meet sensible load only. Valid with all cooling coil types. When a heat
+       \note exchanger assisted cooling coil is used, the heat exchanger is locked on at all times.
+       \note Multimode = activate water coil and meet sensible load. If no sensible load exists,
+       \note and Run on Latent Load = Yes, and a latent load exists, the coil will operate to meet
+       \note the latent load. If the latent load cannot be met the heat exchanger will be activated.
+       \note Valid only with cooling coil type CoilSystem:Cooling:Water:HeatExchangerAssisted.
+       \note CoolReheat = cool beyond the dry-bulb setpoint as required to meet the humidity setpoint.
+       \note Valid with all cooling coil types. When a heat exchanger assisted cooling coil is used,
+       \note the heat exchanger is locked on at all times.
+       \note For all dehumidification controls, the max humidity setpoint on the Sensor Node is used.
+       \note SetpointManager:SingleZone:Humidity:Maximum,
+       \note SetpointManager:MultiZone:Humidity:Maximum, or
+       \note SetpointManager:MultiZone:MaximumHumidity:Average, and
+       \note SetpointManager:OutdoorAirPretreat (optional) objects.
+  A8,  \field Run on Sensible Load
+       \type choice
+       \key Yes
+       \key No
+       \required-field
+       \note If Yes, unit will run if there is a sensible load.
+       \note If No, unit will not run if there is only a sensible load.
+       \note Dehumidification controls will be active if specified.
+  A9,  \field Run on Latent Load
+       \type choice
+       \key Yes
+       \key No
+       \required-field
+       \note If Yes, unit will run if there is a latent load.
+       \note even if there is no sensible load.
+       \note If No, unit will not run if there is only a latent load.
+       \note Dehumidification controls will be active if specified.
+  N1,  \field Minimum Air To Water Temperature Offset
+       \note Coil will turn on as required when inlet air temperature is above
+       \note water temperature by amount of offset. To model a waterside
+       \note economizer connect to condenser loop and increase offset as desired.
+       \type real
+       \units deltaC
+       \minimum 0.0
+       \required-field
+  A10, \field Economizer Lockout
+       \type choice
+       \key Yes
+       \key No
+       \required-field
+       \note Yes means that the heat exchanger will be locked out (off)
+  N2, \field Minimum Water Loop Temperature For Heat Recovery
+       \note Only used for heat recovery loops.
+       \note Loop will turn off below this temperature.
+       \type real
+       \units C
+       \required-field
+  A11; \field Companion Coil Used For Heat Recovery
+       \note Only used for heat recovery loops.
+       \note Entering a coil name indicates a heat recovery loop is specified.
+       \note Coil listed is connected in series with this objects coil on demand side
+       \note branch of a plant loop. A dedicated plant loop with no supply side
+       \note equipment, other than a pump, is currently required.
+       \note Only Coil:Cooling:Water coil type is currently allowed for heat recovery loops.
+       \type object-list
+       \object-list CoolingCoilsWater
+
 OS:CoilSystem:Cooling:Water:HeatExchangerAssisted,
        \memo Virtual component consisting of a chilled-water cooling coil and an air-to-air heat
        \memo exchanger. The air-to-air heat exchanger precools the air entering the cooling coil

src/energyplus/CMakeLists.txt

@@ -98,6 +98,7 @@ set(${target_name}_src
   ForwardTranslator/ForwardTranslateCoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit.cpp
   ForwardTranslator/ForwardTranslateCoilPerformanceDXCooling.cpp
   ForwardTranslator/ForwardTranslateCoilSystemCoolingDXHeatExchangerAssisted.cpp
+  ForwardTranslator/ForwardTranslateCoilSystemCoolingWater.cpp
   ForwardTranslator/ForwardTranslateCoilSystemCoolingWaterHeatExchangerAssisted.cpp
   ForwardTranslator/ForwardTranslateCoilSystemIntegratedHeatPumpAirSource.cpp
   ForwardTranslator/ForwardTranslateCoilUserDefined.cpp
@@ -710,6 +711,7 @@ set(${target_name}_test_src
   Test/CoilCoolingDXTwoSpeed_GTest.cpp
   Test/CoilCoolingDXTwoStageWithHumidityControlMode_GTest.cpp
   Test/CoilCoolingDXVariableSpeed_GTest.cpp
+  Test/CoilCoolingWater_GTest.cpp
   Test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp
   Test/CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit_GTest.cpp
   Test/CoilHeatingDXMultiSpeed_GTest.cpp
@@ -720,6 +722,8 @@ set(${target_name}_test_src
   Test/CoilHeatingGasMultiStage_GTest.cpp
   Test/CoilHeatingWaterToAirHeatPumpEquationFit_GTest.cpp
   Test/CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit_GTest.cpp
+  Test/CoilSystemCoolingWater_GTest.cpp
+  Test/CoilSystemCoolingWaterHeatExchangerAssisted_GTest.cpp
   Test/CoilSystemIntegratedHeatPumpAirSource_GTest.cpp
   Test/CoilUserDefined_GTest.cpp
   Test/CoilWaterHeatingAirToWaterHeatPump_GTest.cpp

src/energyplus/ForwardTranslator.cpp

@@ -1207,6 +1207,11 @@ namespace energyplus {
         retVal = translateCoilPerformanceDXCooling(mo);
         break;
       }
+      case openstudio::IddObjectType::OS_CoilSystem_Cooling_Water: {
+        auto mo = modelObject.cast<CoilSystemCoolingWater>();
+        retVal = translateCoilSystemCoolingWater(mo);
+        break;
+      }
       case openstudio::IddObjectType::OS_CoilSystem_Cooling_Water_HeatExchangerAssisted: {
         auto mo = modelObject.cast<CoilSystemCoolingWaterHeatExchangerAssisted>();
         retVal = translateCoilSystemCoolingWaterHeatExchangerAssisted(mo);

src/energyplus/ForwardTranslator.hpp

@@ -134,6 +134,7 @@ namespace model {
   class CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit;
   class CoilPerformanceDXCooling;
   class CoilSystemCoolingDXHeatExchangerAssisted;
+  class CoilSystemCoolingWater;
   class CoilSystemCoolingWaterHeatExchangerAssisted;
   class CoilSystemIntegratedHeatPumpAirSource;
   class CoilUserDefined;
@@ -844,6 +845,8 @@ namespace energyplus {
 
     boost::optional<IdfObject> translateCoilSystemCoolingDXHeatExchangerAssisted(model::CoilSystemCoolingDXHeatExchangerAssisted& modelObject);
 
+    boost::optional<IdfObject> translateCoilSystemCoolingWater(model::CoilSystemCoolingWater& modelObject);
+
     boost::optional<IdfObject> translateCoilSystemCoolingWaterHeatExchangerAssisted(model::CoilSystemCoolingWaterHeatExchangerAssisted& modelObject);
 
     boost::optional<IdfObject> translateCoilSystemIntegratedHeatPumpAirSource(model::CoilSystemIntegratedHeatPumpAirSource& modelObject);

src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVAC.cpp

@@ -18,6 +18,8 @@
 #include "../../model/SizingSystem_Impl.hpp"
 #include "../../model/CoilCoolingWater.hpp"
 #include "../../model/CoilCoolingWater_Impl.hpp"
+#include "../../model/CoilSystemCoolingWater.hpp"
+#include "../../model/CoilSystemCoolingWater_Impl.hpp"
 #include "../../model/CoilSystemCoolingWaterHeatExchangerAssisted.hpp"
 #include "../../model/CoilSystemCoolingWaterHeatExchangerAssisted_Impl.hpp"
 #include "../../model/CoilHeatingWater.hpp"
@@ -275,6 +277,13 @@ namespace energyplus {
           controller = supplyComponent.cast<CoilHeatingWater>().controllerWaterCoil();
           break;
         }
+        case openstudio::IddObjectType::OS_CoilSystem_Cooling_Water: {
+          auto coolingCoil = supplyComponent.cast<CoilSystemCoolingWater>().coolingCoil();
+          if (auto coilCoolingWater = coolingCoil.optionalCast<CoilCoolingWater>()) {
+            controller = coilCoolingWater->controllerWaterCoil();
+          }
+          break;
+        }
         case openstudio::IddObjectType::OS_CoilSystem_Cooling_Water_HeatExchangerAssisted: {
           auto coolingCoil = supplyComponent.cast<CoilSystemCoolingWaterHeatExchangerAssisted>().coolingCoil();
           if (auto coilCoolingWater = coolingCoil.optionalCast<CoilCoolingWater>()) {

src/energyplus/ForwardTranslator/ForwardTranslateCoilSystemCoolingWater.cpp

@@ -0,0 +1,201 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
+*  See also https://openstudio.net/license
+***********************************************************************************************************************/
+
+#include "../ForwardTranslator.hpp"
+#include "../../model/Model.hpp"
+#include "../../model/CoilSystemCoolingWater.hpp"
+#include "../../model/CoilSystemCoolingWater_Impl.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/Node_Impl.hpp"
+#include "../../model/Schedule.hpp"
+#include "../../model/Schedule_Impl.hpp"
+#include "../../model/CoilCoolingWater.hpp"
+#include "../../model/CoilCoolingWater_Impl.hpp"
+#include "../../model/ControllerWaterCoil.hpp"
+#include "../../model/ControllerWaterCoil_Impl.hpp"
+
+#include "../../model/AirLoopHVAC.hpp"
+#include "../../model/FanVariableVolume.hpp"
+#include "../../model/FanVariableVolume_Impl.hpp"
+#include "../../model/FanConstantVolume.hpp"
+#include "../../model/FanConstantVolume_Impl.hpp"
+#include "../../model/FanOnOff.hpp"
+#include "../../model/FanOnOff_Impl.hpp"
+#include "../../model/FanSystemModel.hpp"
+#include "../../model/FanSystemModel_Impl.hpp"
+#include "../../model/AirLoopHVACOutdoorAirSystem.hpp"
+#include "../../model/AirLoopHVACOutdoorAirSystem_Impl.hpp"
+
+#include <utilities/idd/CoilSystem_Cooling_Water_FieldEnums.hxx>
+#include <utilities/idd/Coil_Cooling_Water_FieldEnums.hxx>
+#include <utilities/idd/Controller_WaterCoil_FieldEnums.hxx>
+#include <utilities/idd/SetpointManager_MixedAir_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<IdfObject> ForwardTranslator::translateCoilSystemCoolingWater(model::CoilSystemCoolingWater& modelObject) {
+
+    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::CoilSystem_Cooling_Water, modelObject);
+
+    std::string airInletNodeName;
+    // InletNodeName
+    if (auto mo = modelObject.inletModelObject()) {
+      if (auto node = mo->optionalCast<Node>()) {
+        airInletNodeName = node->nameString();
+      }
+    }
+
+    std::string airOutletNodeName;
+    // OutletNodeName
+    if (auto mo = modelObject.outletModelObject()) {
+      if (auto node = mo->optionalCast<Node>()) {
+        airOutletNodeName = node->nameString();
+      }
+    }
+
+    idfObject.setString(CoilSystem_Cooling_WaterFields::AirInletNodeName, airInletNodeName);
+    idfObject.setString(CoilSystem_Cooling_WaterFields::AirOutletNodeName, airOutletNodeName);
+
+    // CoolingCoilObjectType
+    // CoolingCoilName
+    {
+      auto coolingCoil = modelObject.coolingCoil();
+      if (auto idf = translateAndMapModelObject(coolingCoil)) {
+        idfObject.setString(CoilSystem_Cooling_WaterFields::CoolingCoilObjectType, idf->iddObject().name());
+        idfObject.setString(CoilSystem_Cooling_WaterFields::CoolingCoilName, idf->nameString());
+        if (idf->iddObject().type() == IddObjectType::Coil_Cooling_Water) {
+          idf->setString(Coil_Cooling_WaterFields::AirInletNodeName, airInletNodeName);
+          idf->setString(Coil_Cooling_WaterFields::AirOutletNodeName, airOutletNodeName);
+          // Add IddObjectType::Coil_Cooling_Water_DetailedGeometry if implemented
+        } else {
+          // Shouldn't happen, accepts only Coil:Cooling:Water or Coil:Cooling:Water:DetailedGeometry
+          // Shouldn't happen, accepts only Coil:Cooling:DX:SingleSpeed or Coil:Cooling:DX:VariableSpeed
+          LOG(Fatal, modelObject.briefDescription()
+                       << " appears to have a cooling coil that shouldn't have been accepted: " << coolingCoil.briefDescription());
+          OS_ASSERT(false);
+        }
+      }
+      if (auto coilCoolingWater = coolingCoil.optionalCast<CoilCoolingWater>()) {
+        if (auto controller = coilCoolingWater->controllerWaterCoil()) {
+          if (auto idf = translateAndMapModelObject(controller.get())) {
+            idf->setString(Controller_WaterCoilFields::SensorNodeName, airOutletNodeName);
+          }
+        }
+      }
+
+      // Need a SPM:MixedAir on the Coil:Cooling:Water outlet node (that we **created** just above in IDF directly, so it won't get picked up by the
+      // ForwardTranslateAirLoopHVAC method)
+      if (boost::optional<AirLoopHVAC> airLoop_ = modelObject.airLoopHVAC()) {
+        std::vector<StraightComponent> fans;
+        std::vector<ModelObject> supplyComponents = airLoop_->supplyComponents();
+
+        for (auto it = supplyComponents.begin(); it != supplyComponents.end(); ++it) {
+          if (auto fan_ = it->optionalCast<FanVariableVolume>()) {
+            fans.insert(fans.begin(), std::move(*fan_));
+          } else if (auto fan_ = it->optionalCast<FanConstantVolume>()) {
+            fans.insert(fans.begin(), std::move(*fan_));
+          } else if (auto fan_ = it->optionalCast<FanSystemModel>()) {
+            fans.insert(fans.begin(), std::move(*fan_));
+          } else if (auto fan_ = it->optionalCast<FanOnOff>()) {
+            fans.insert(fans.begin(), std::move(*fan_));
+          }
+        }
+
+        if (!fans.empty()) {
+          // Fan closest to the supply outlet node
+          StraightComponent fan = fans.front();
+          OptionalNode inletNode = fan.inletModelObject()->optionalCast<Node>();
+          OptionalNode outletNode = fan.outletModelObject()->optionalCast<Node>();
+
+          // No reason this wouldn't be ok at this point really...
+          // TODO: change to OS_ASSERT?
+          if (inletNode && outletNode) {
+
+            IdfObject idf_spm(IddObjectType::SetpointManager_MixedAir);
+            idf_spm.setString(SetpointManager_MixedAirFields::Name, airOutletNodeName + " OS Default SPM");
+            idf_spm.setString(SetpointManager_MixedAirFields::ControlVariable, "Temperature");
+
+            Node supplyOutletNode = airLoop_->supplyOutletNode();
+            idf_spm.setString(SetpointManager_MixedAirFields::ReferenceSetpointNodeName, supplyOutletNode.nameString());
+
+            idf_spm.setString(SetpointManager_MixedAirFields::FanInletNodeName, inletNode->nameString());
+            idf_spm.setString(SetpointManager_MixedAirFields::FanOutletNodeName, outletNode->nameString());
+
+            idf_spm.setString(SetpointManager_MixedAirFields::SetpointNodeorNodeListName, airOutletNodeName);
+
+            m_idfObjects.push_back(idf_spm);
+          }
+        }
+      }
+    }
+
+    // Availability Schedule Name: Optional Object
+    if (boost::optional<Schedule> availabilitySchedule_ = modelObject.availabilitySchedule()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(availabilitySchedule_.get())) {
+        idfObject.setString(CoilSystem_Cooling_WaterFields::AvailabilityScheduleName, wo_->nameString());
+      }
+    }
+
+    // Dehumidification Control Type: Optional String
+    const std::string dehumidificationControlType = modelObject.dehumidificationControlType();
+    idfObject.setString(CoilSystem_Cooling_WaterFields::DehumidificationControlType, dehumidificationControlType);
+
+    // Run on Sensible Load: Optional Boolean
+    if (modelObject.runonSensibleLoad()) {
+      idfObject.setString(CoilSystem_Cooling_WaterFields::RunonSensibleLoad, "Yes");
+    } else {
+      idfObject.setString(CoilSystem_Cooling_WaterFields::RunonSensibleLoad, "No");
+    }
+
+    // Run on Latent Load: Optional Boolean
+    if (modelObject.runonLatentLoad()) {
+      idfObject.setString(CoilSystem_Cooling_WaterFields::RunonLatentLoad, "Yes");
+    } else {
+      idfObject.setString(CoilSystem_Cooling_WaterFields::RunonLatentLoad, "No");
+    }
+
+    // Minimum Air To Water Temperature Offset: Optional Double
+    const double minimumAirToWaterTemperatureOffset = modelObject.minimumAirToWaterTemperatureOffset();
+    idfObject.setDouble(CoilSystem_Cooling_WaterFields::MinimumAirToWaterTemperatureOffset, minimumAirToWaterTemperatureOffset);
+
+    // Economizer Lockout: Optional Boolean
+    if (modelObject.economizerLockout()) {
+      idfObject.setString(CoilSystem_Cooling_WaterFields::EconomizerLockout, "Yes");
+    } else {
+      idfObject.setString(CoilSystem_Cooling_WaterFields::EconomizerLockout, "No");
+    }
+
+    // Minimum Water Loop Temperature For Heat Recovery: Optional Double
+    const double minimumWaterLoopTemperatureForHeatRecovery = modelObject.minimumWaterLoopTemperatureForHeatRecovery();
+    idfObject.setDouble(CoilSystem_Cooling_WaterFields::MinimumWaterLoopTemperatureForHeatRecovery, minimumWaterLoopTemperatureForHeatRecovery);
+
+    // Companion Coil Used For Heat Recovery: Optional Object
+    if (boost::optional<WaterToAirComponent> companionCoilUsedForHeatRecovery_ = modelObject.companionCoilUsedForHeatRecovery()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(companionCoilUsedForHeatRecovery_.get())) {
+        idfObject.setString(CoilSystem_Cooling_WaterFields::CompanionCoilUsedForHeatRecovery, wo_->nameString());
+        if (wo_->iddObject().type() == IddObjectType::Coil_Cooling_Water) {
+          wo_->setString(Coil_Cooling_WaterFields::AirInletNodeName, modelObject.airLoopHVACOutdoorAirSystem()->reliefAirModelObject()->nameString());
+          wo_->setString(Coil_Cooling_WaterFields::AirOutletNodeName, wo_->nameString() + " Exhaust Outlet Node");  // FIXME
+          // Add IddObjectType::Coil_Cooling_Water_DetailedGeometry if implemented
+        } else {
+          // Shouldn't happen, accepts only Coil:Cooling:Water or Coil:Cooling:Water:DetailedGeometry
+          // Shouldn't happen, accepts only Coil:Cooling:DX:SingleSpeed or Coil:Cooling:DX:VariableSpeed
+          LOG(Fatal, modelObject.briefDescription() << " appears to have a companion coil used for heat recovery that shouldn't have been accepted: "
+                                                    << companionCoilUsedForHeatRecovery_.get().briefDescription());
+          OS_ASSERT(false);
+        }
+      }
+    }
+
+    return idfObject;
+  }  // End of translate function
+
+}  // end namespace energyplus
+}  // end namespace openstudio