boost::optional<IdfObject> ForwardTranslator::translateAirLoopHVACOutdoorAirSystem( AirLoopHVACOutdoorAirSystem & modelObject )
{
OptionalString s;
IdfObject idfObject(IddObjectType::AirLoopHVAC_OutdoorAirSystem);
m_idfObjects.push_back(idfObject);
// Name
std::string name = modelObject.name().get();
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::Name,name);
// Controller List
IdfObject controllerListIdf(IddObjectType::AirLoopHVAC_ControllerList);
controllerListIdf.setName(name + " Controller List");
controllerListIdf.clearExtensibleGroups();
m_idfObjects.push_back(controllerListIdf);
ControllerOutdoorAir controllerOutdoorAir = modelObject.getControllerOutdoorAir();
boost::optional<IdfObject> temp = translateAndMapModelObject(controllerOutdoorAir);
s = controllerListIdf.name();
if(s)
{
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::ControllerListName,*s);
}
s = temp->iddObject().name();
StringVector groupFields(2u);
bool addGroup(false);
if(s)
{
groupFields[0] = *s;
addGroup = true;
}
s = temp->name();
if(s)
{
groupFields[1] = *s;
addGroup = true;
}
if (addGroup) {
IdfExtensibleGroup eg = controllerListIdf.pushExtensibleGroup(groupFields);
OS_ASSERT(!eg.empty());
}
// Field: Availability Manager List Name //////////////////////////////////
IdfObject availabilityManagerListIdf(IddObjectType::AvailabilityManagerAssignmentList);
availabilityManagerListIdf.setName(name + " Availability Manager");
m_idfObjects.push_back(availabilityManagerListIdf);
IdfObject availabilityManagerScheduledIdf = IdfObject(openstudio::IddObjectType::AvailabilityManager_Scheduled);
availabilityManagerScheduledIdf.createName();
m_idfObjects.push_back(availabilityManagerScheduledIdf);
Schedule alwaysOn = modelObject.model().alwaysOnDiscreteSchedule();
IdfObject alwaysOnIdf = translateAndMapModelObject(alwaysOn).get();
s = availabilityManagerListIdf.getString(openstudio::AvailabilityManagerAssignmentListFields::Name);
if(s)
{
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::AvailabilityManagerListName,*s);
}
availabilityManagerListIdf.setString(1 + openstudio::AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerObjectType,
availabilityManagerScheduledIdf.iddObject().name());
availabilityManagerListIdf.setString(1 + openstudio::AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerName,
availabilityManagerScheduledIdf.name().get());
availabilityManagerScheduledIdf.setString(openstudio::AvailabilityManager_ScheduledFields::ScheduleName,alwaysOnIdf.name().get());
// OA Node List
s = modelObject.outboardOANode()->name();
IdfObject oaNodeListIdf(openstudio::IddObjectType::OutdoorAir_NodeList);
if(s)
{
oaNodeListIdf.setString(0,*s);
}
m_idfObjects.push_back(oaNodeListIdf);
///////////////////////////////////////////////////////////////////////////
// Field: Outdoor Air Equipment List Name /////////////////////////////////
IdfObject equipmentListIdf(IddObjectType::AirLoopHVAC_OutdoorAirSystem_EquipmentList);
equipmentListIdf.setName(name + " Equipment List");
m_idfObjects.push_back(equipmentListIdf);
IdfObject outdoorAirMixerIdf(IddObjectType::OutdoorAir_Mixer);
outdoorAirMixerIdf.setName(name + " Outdoor Air Mixer");
m_idfObjects.push_back(outdoorAirMixerIdf);
s = modelObject.mixedAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::MixedAirNodeName,*s);
}
s = modelObject.outdoorAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName,*s);
}
s = modelObject.reliefAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::ReliefAirStreamNodeName,*s);
}
s = modelObject.returnAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::ReturnAirStreamNodeName,*s);
}
s = outdoorAirMixerIdf.iddObject().name();
equipmentListIdf.setString(1,*s);
s = outdoorAirMixerIdf.name();
equipmentListIdf.setString(2,*s);
ModelObjectVector oaModelObjects = modelObject.oaComponents();
ModelObjectVector::iterator oaIt;
unsigned i = 3;
for( oaIt = oaModelObjects.begin();
oaIt != oaModelObjects.end();
++oaIt )
{
if( ! oaIt->optionalCast<Node>() )
{
s = stripOS2(oaIt->iddObject().name());
if(s)
equipmentListIdf.setString(i,*s);
i++;
s = oaIt->name();
if(s)
equipmentListIdf.setString(i,*s);
i++;
}
}
s = equipmentListIdf.name();
if(s)
{
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::OutdoorAirEquipmentListName,*s);
}
for( oaIt = oaModelObjects.begin();
oaIt != oaModelObjects.end();
++oaIt )
{
translateAndMapModelObject(*oaIt);
}
return boost::optional<IdfObject>(idfObject);
}
boost::optional<IdfObject> ForwardTranslator::translateAirLoopHVACOutdoorAirSystem( AirLoopHVACOutdoorAirSystem & modelObject )
{
OptionalString s;
IdfObject idfObject(IddObjectType::AirLoopHVAC_OutdoorAirSystem);
m_idfObjects.push_back(idfObject);
// Name
std::string name = modelObject.name().get();
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::Name,name);
// Controller List
IdfObject _controllerList(IddObjectType::AirLoopHVAC_ControllerList);
_controllerList.setName(name + " Controller List");
_controllerList.clearExtensibleGroups();
m_idfObjects.push_back(_controllerList);
ControllerOutdoorAir controllerOutdoorAir = modelObject.getControllerOutdoorAir();
boost::optional<IdfObject> _controllerOutdoorAir = translateAndMapModelObject(controllerOutdoorAir);
OS_ASSERT(_controllerOutdoorAir);
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::ControllerListName,_controllerList.name().get());
IdfExtensibleGroup eg = _controllerList.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ControllerListExtensibleFields::ControllerObjectType,_controllerOutdoorAir->iddObject().name());
eg.setString(AirLoopHVAC_ControllerListExtensibleFields::ControllerName,_controllerOutdoorAir->name().get());
std::vector<ModelObject> controllers;
auto components = modelObject.components();
for( const auto & component : components ) {
boost::optional<ControllerWaterCoil> controller;
if( auto coil = component.optionalCast<CoilCoolingWater>() ) {
controller = coil->controllerWaterCoil();
} else if ( auto coil = component.optionalCast<CoilHeatingWater>() ) {
controller = coil->controllerWaterCoil();
}
if( controller ) {
controllers.push_back(controller.get());
}
}
for( auto & controller: controllers ) {
auto _controller = translateAndMapModelObject(controller);
if( _controller ) {
IdfExtensibleGroup eg = _controllerList.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ControllerListExtensibleFields::ControllerObjectType,_controller->iddObject().name());
eg.setString(AirLoopHVAC_ControllerListExtensibleFields::ControllerName,_controller->name().get());
}
}
// Field: Availability Manager List Name //////////////////////////////////
IdfObject availabilityManagerListIdf(IddObjectType::AvailabilityManagerAssignmentList);
availabilityManagerListIdf.setName(name + " Availability Manager List");
m_idfObjects.push_back(availabilityManagerListIdf);
IdfObject availabilityManagerScheduledIdf = IdfObject(openstudio::IddObjectType::AvailabilityManager_Scheduled);
availabilityManagerScheduledIdf.setName(name + " Availability Manager");
m_idfObjects.push_back(availabilityManagerScheduledIdf);
Schedule alwaysOn = modelObject.model().alwaysOnDiscreteSchedule();
IdfObject alwaysOnIdf = translateAndMapModelObject(alwaysOn).get();
s = availabilityManagerListIdf.getString(openstudio::AvailabilityManagerAssignmentListFields::Name);
if(s)
{
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::AvailabilityManagerListName,*s);
}
availabilityManagerListIdf.setString(1 + openstudio::AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerObjectType,
availabilityManagerScheduledIdf.iddObject().name());
availabilityManagerListIdf.setString(1 + openstudio::AvailabilityManagerAssignmentListExtensibleFields::AvailabilityManagerName,
availabilityManagerScheduledIdf.name().get());
availabilityManagerScheduledIdf.setString(openstudio::AvailabilityManager_ScheduledFields::ScheduleName,alwaysOnIdf.name().get());
// OA Node List
s = modelObject.outboardOANode()->name();
IdfObject oaNodeListIdf(openstudio::IddObjectType::OutdoorAir_NodeList);
if(s)
{
oaNodeListIdf.setString(0,*s);
}
m_idfObjects.push_back(oaNodeListIdf);
///////////////////////////////////////////////////////////////////////////
// Field: Outdoor Air Equipment List Name /////////////////////////////////
IdfObject equipmentListIdf(IddObjectType::AirLoopHVAC_OutdoorAirSystem_EquipmentList);
equipmentListIdf.setName(name + " Equipment List");
m_idfObjects.push_back(equipmentListIdf);
IdfObject outdoorAirMixerIdf(IddObjectType::OutdoorAir_Mixer);
outdoorAirMixerIdf.setName(name + " Outdoor Air Mixer");
m_idfObjects.push_back(outdoorAirMixerIdf);
s = modelObject.mixedAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::MixedAirNodeName,*s);
}
s = modelObject.outdoorAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName,*s);
}
s = modelObject.reliefAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::ReliefAirStreamNodeName,*s);
}
s = modelObject.returnAirModelObject()->name();
if(s)
{
outdoorAirMixerIdf.setString(OutdoorAir_MixerFields::ReturnAirStreamNodeName,*s);
}
s = outdoorAirMixerIdf.iddObject().name();
equipmentListIdf.setString(1,*s);
s = outdoorAirMixerIdf.name();
equipmentListIdf.setString(2,*s);
unsigned i = 3;
ModelObjectVector oaModelObjects = modelObject.oaComponents();
for( ModelObjectVector::iterator oaIt = oaModelObjects.begin();
oaIt != oaModelObjects.end();
++oaIt )
{
if( ! oaIt->optionalCast<Node>() )
{
if( boost::optional<IdfObject> idfObject = translateAndMapModelObject(*oaIt) )
{
equipmentListIdf.setString(i,idfObject->iddObject().name());
i++;
equipmentListIdf.setString(i,idfObject->name().get());
i++;
}
}
}
ModelObjectVector reliefModelObjects = modelObject.reliefComponents();
for( ModelObjectVector::iterator reliefIt = reliefModelObjects.begin();
reliefIt != reliefModelObjects.end();
++reliefIt )
{
if( (! reliefIt->optionalCast<Node>()) && (! reliefIt->optionalCast<AirToAirComponent>()) )
{
if( boost::optional<IdfObject> idfObject = translateAndMapModelObject(*reliefIt) )
{
equipmentListIdf.setString(i,idfObject->iddObject().name());
i++;
equipmentListIdf.setString(i,idfObject->name().get());
i++;
}
}
}
s = equipmentListIdf.name();
if(s)
{
idfObject.setString(openstudio::AirLoopHVAC_OutdoorAirSystemFields::OutdoorAirEquipmentListName,*s);
}
return boost::optional<IdfObject>(idfObject);
}
boost::optional<IdfObject> ForwardTranslator::translateThermalStorageChilledWaterStratified( ThermalStorageChilledWaterStratified & modelObject )
{
boost::optional<std::string> s;
boost::optional<double> value;
boost::optional<Schedule> schedule;
// Name
IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ThermalStorage_ChilledWater_Stratified, modelObject);
// Tank Volume
value = modelObject.tankVolume();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::TankVolume, value.get());
}
// Tank Height
value = modelObject.tankHeight();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::TankHeight, value.get());
}
// Tank Shape
s = modelObject.tankShape();
if( s )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::TankShape, s.get());
}
// Tank Perimeter
value = modelObject.tankPerimeter();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::TankPerimeter, value.get());
}
// SetpointTemperatureScheduleName
schedule = modelObject.setpointTemperatureSchedule();
if( schedule )
{
auto _schedule = translateAndMapModelObject(schedule.get());
if( _schedule )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::SetpointTemperatureScheduleName,_schedule->name().get());
}
}
// DeadbandTemperatureDifference
value = modelObject.deadbandTemperatureDifference();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::DeadbandTemperatureDifference, value.get());
}
// TemperatureSensorHeight
value = modelObject.temperatureSensorHeight();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::TemperatureSensorHeight, value.get());
}
// Minimum Temperature Limit
value = modelObject.minimumTemperatureLimit();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::MinimumTemperatureLimit, value.get());
}
// NominalCoolingCapacity
value = modelObject.nominalCoolingCapacity();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::NominalCoolingCapacity, value.get());
}
// Ambient Temperature Indicator
s = modelObject.ambientTemperatureIndicator();
if( s )
{
if( istringEqual(s.get(),"ThermalZone") )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::AmbientTemperatureIndicator,"Zone");
}
else
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::AmbientTemperatureIndicator,s.get());
}
}
// Ambient Temperature Schedule Name
schedule = modelObject.ambientTemperatureSchedule();
if( schedule )
{
auto _schedule = translateAndMapModelObject(schedule.get());
if( _schedule )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::AmbientTemperatureScheduleName,_schedule->name().get());
}
}
// Ambient Temperature Zone Name
if( auto zone = modelObject.ambientTemperatureThermalZone() )
{
auto _zone = translateAndMapModelObject(zone.get());
if( _zone )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::AmbientTemperatureZoneName,_zone->name().get());
}
}
// Ambient Temperature Outdoor Air Node Name
s = modelObject.ambientTemperatureOutdoorAirNodeName();
if( s && (! s->empty()) )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::AmbientTemperatureOutdoorAirNodeName,s.get());
} else if( istringEqual(modelObject.ambientTemperatureIndicator(),"Outdoors") ) {
auto name = modelObject.name().get() + " OA Node";
IdfObject oaNodeListIdf(openstudio::IddObjectType::OutdoorAir_NodeList);
oaNodeListIdf.setString(0,name);
m_idfObjects.push_back(oaNodeListIdf);
idfObject.setString(openstudio::ThermalStorage_ChilledWater_StratifiedFields::AmbientTemperatureOutdoorAirNodeName, name);
}
// Uniform Skin Loss Coefficient per Unit Area to Ambient Temperature
value = modelObject.uniformSkinLossCoefficientperUnitAreatoAmbientTemperature();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::UniformSkinLossCoefficientperUnitAreatoAmbientTemperature, value.get());
}
// Use Side Inlet Node Name
if( auto mo = modelObject.supplyInletModelObject() )
{
if( auto node = mo->optionalCast<Node>() )
{
translateAndMapModelObject(node.get());
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::UseSideInletNodeName,node->name().get());
}
}
// Use Side Outlet Node Name
if( auto mo = modelObject.supplyOutletModelObject() )
{
if( auto node = mo->optionalCast<Node>() )
{
translateAndMapModelObject(node.get());
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::UseSideOutletNodeName,node->name().get());
}
}
// UseSideHeatTransferEffectiveness
value = modelObject.useSideHeatTransferEffectiveness();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::UseSideHeatTransferEffectiveness,value.get());
}
// UseSideAvailabilityScheduleName
if( (schedule = modelObject.useSideAvailabilitySchedule()) )
{
auto _schedule = translateAndMapModelObject(schedule.get());
if( _schedule )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::UseSideAvailabilityScheduleName, _schedule->name().get());
}
}
// Use Side Outlet Height
value = modelObject.useSideOutletHeight();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::UseSideOutletHeight,value.get());
}
// Use Side Inlet Height
if( modelObject.isUseSideInletHeightAutocalculated() )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::UseSideInletHeight, "Autocalculate");
}
else
{
value = modelObject.useSideInletHeight();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::UseSideInletHeight, value.get());
}
}
// Use Side Design Flow Rate
if( modelObject.isUseSideDesignFlowRateAutosized() )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::UseSideDesignFlowRate,"Autosize");
}
else
{
value = modelObject.useSideDesignFlowRate();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::UseSideDesignFlowRate,value.get());
}
}
// Source Side Inlet Node Name
if( auto mo = modelObject.demandInletModelObject() )
{
if( auto node = mo->optionalCast<Node>() )
{
translateAndMapModelObject(node.get());
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::SourceSideInletNodeName,node->name().get());
}
}
// Source Side Outlet Node Name
if( auto mo = modelObject.demandOutletModelObject() )
{
if( auto node = mo->optionalCast<Node>() )
{
translateAndMapModelObject(node.get());
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::SourceSideOutletNodeName,node->name().get());
}
}
// SourceSideHeatTransferEffectiveness
value = modelObject.sourceSideHeatTransferEffectiveness();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::SourceSideHeatTransferEffectiveness,value.get());
}
// SourceSideAvailabilityScheduleName
if( (schedule = modelObject.sourceSideAvailabilitySchedule()) )
{
auto _schedule = translateAndMapModelObject(schedule.get());
if( _schedule )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::SourceSideAvailabilityScheduleName, _schedule->name().get());
}
}
// Source Side Outlet Height
if( modelObject.isSourceSideOutletHeightAutocalculated() )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::SourceSideOutletHeight, "Autocalculate");
}
else
{
value = modelObject.sourceSideOutletHeight();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::SourceSideOutletHeight, value.get());
}
}
// Source Side Inlet Height
value = modelObject.sourceSideInletHeight();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::SourceSideInletHeight,value.get());
}
// Source Side Design Flow Rate
if( modelObject.isSourceSideDesignFlowRateAutosized() )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::SourceSideDesignFlowRate,"Autosize");
}
else
{
value = modelObject.sourceSideDesignFlowRate();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::SourceSideDesignFlowRate,value.get());
}
}
// TankRecoveryTime
value = modelObject.tankRecoveryTime();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::TankRecoveryTime,value.get());
}
// Inlet Mode
s = modelObject.inletMode();
if( s )
{
idfObject.setString(ThermalStorage_ChilledWater_StratifiedFields::InletMode, s.get());
}
// Number of Nodes
auto num_nodes = modelObject.numberofNodes();
if( num_nodes )
{
idfObject.setInt(ThermalStorage_ChilledWater_StratifiedFields::NumberofNodes,value.get());
}
// Additional Destratification Conductivity
value = modelObject.additionalDestratificationConductivity();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::AdditionalDestratificationConductivity,value.get());
}
// Node 1 Additional Loss Coefficient
value = modelObject.node1AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node1AdditionalLossCoefficient,value.get());
}
// Node 2 Additional Loss Coefficient
value = modelObject.node2AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node2AdditionalLossCoefficient,value.get());
}
// Node 3 Additional Loss Coefficient
value = modelObject.node3AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node3AdditionalLossCoefficient,value.get());
}
// Node 4 Additional Loss Coefficient
value = modelObject.node4AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node4AdditionalLossCoefficient,value.get());
}
// Node 5 Additional Loss Coefficient
value = modelObject.node5AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node5AdditionalLossCoefficient,value.get());
}
// Node 6 Additional Loss Coefficient
value = modelObject.node6AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node6AdditionalLossCoefficient,value.get());
}
// Node 7 Additional Loss Coefficient
value = modelObject.node7AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node7AdditionalLossCoefficient,value.get());
}
// Node 8 Additional Loss Coefficient
value = modelObject.node8AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node8AdditionalLossCoefficient,value.get());
}
// Node 9 Additional Loss Coefficient
value = modelObject.node9AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node9AdditionalLossCoefficient,value.get());
}
// Node 10 Additional Loss Coefficient
value = modelObject.node10AdditionalLossCoefficient();
if( value )
{
idfObject.setDouble(ThermalStorage_ChilledWater_StratifiedFields::Node10AdditionalLossCoefficient,value.get());
}
return idfObject;
}
