boost::optional<IdfObject> ForwardTranslator::translateCoilCoolingDXSingleSpeed( CoilCoolingDXSingleSpeed& modelObject )
{
IdfObject coilSystemCoolingDXIdf(IddObjectType::CoilSystem_Cooling_DX);
m_idfObjects.push_back(coilSystemCoolingDXIdf);
boost::optional<IdfObject> oIdfObject = translateCoilCoolingDXSingleSpeedWithoutUnitary(modelObject);
if( ! oIdfObject ) { return boost::none; }
IdfObject idfObject = oIdfObject.get();
OptionalString s;
s = modelObject.name();
if( s )
{
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::CoolingCoilObjectType,idfObject.iddObject().name());
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::CoolingCoilName,*s);
coilSystemCoolingDXIdf.setName(*s + " CoilSystem");
}
Schedule sched = modelObject.getAvailabilitySchedule();
translateAndMapModelObject(sched);
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::AvailabilityScheduleName,sched.name().get());
OptionalModelObject omo = modelObject.inletModelObject();
if( omo )
{
translateAndMapModelObject(*omo);
s = omo->name();
if(s)
{
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemInletNodeName,*s);
}
}
omo= modelObject.outletModelObject();
if( omo )
{
translateAndMapModelObject(*omo);
s = omo->name();
if(s)
{
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemOutletNodeName,*s);
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemSensorNodeName,*s);
}
}
return coilSystemCoolingDXIdf;
}
boost::optional<IdfObject> ForwardTranslator::translateZoneHVACPackagedTerminalAirConditioner(
ZoneHVACPackagedTerminalAirConditioner & modelObject )
{
boost::optional<std::string> s;
boost::optional<double> value;
IdfObject idfObject(IddObjectType::ZoneHVAC_PackagedTerminalAirConditioner);
m_idfObjects.push_back(idfObject);
// Name
std::string baseName = modelObject.name().get();
idfObject.setName(baseName);
std::string mixedAirNodeName = baseName + " Mixed Air Node";
std::string coolingCoilOutletNodeName = baseName + " Cooling Coil Outlet Node";
std::string heatingCoilOutletNodeName = baseName + " Heating Coil Outlet Node";
std::string reliefAirNodeName = baseName + " Relief Air Node";
std::string oaNodeName = baseName + " OA Node";
// AvailabilityScheduleName
if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// AirInletNodeName
boost::optional<std::string> airInletNodeName;
if( boost::optional<Node> node = modelObject.inletNode() )
{
if( (s = node->name()) )
{
airInletNodeName = s;
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AirInletNodeName,s.get());
}
}
// AirOutletNodeName
boost::optional<std::string> airOutletNodeName;
if( boost::optional<Node> node = modelObject.outletNode() )
{
if( (s = node->name()) )
{
airOutletNodeName = s;
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AirOutletNodeName,s.get());
}
}
// OutdoorAirMixerObjectType
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirMixerObjectType,
modelObject.outdoorAirMixerObjectType());
// OutdoorAirMixerName
std::string oaMixerName = modelObject.name().get() + " OA Mixer";
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirMixerName,oaMixerName);
IdfObject _outdoorAirMixer(IddObjectType::OutdoorAir_Mixer);
_outdoorAirMixer.setName(oaMixerName);
m_idfObjects.push_back(_outdoorAirMixer);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::MixedAirNodeName,mixedAirNodeName);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName,oaNodeName);
IdfObject _oaNodeList(openstudio::IddObjectType::OutdoorAir_NodeList);
_oaNodeList.setString(0,oaNodeName);
m_idfObjects.push_back(_oaNodeList);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::ReliefAirStreamNodeName,reliefAirNodeName);
if(airInletNodeName)
{
_outdoorAirMixer.setString(OutdoorAir_MixerFields::ReturnAirStreamNodeName,airInletNodeName.get());
}
// SupplyAirFlowRateDuringCoolingOperation
if( modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringCoolingOperation,"Autosize");
}
else if( (value = modelObject.supplyAirFlowRateDuringCoolingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringCoolingOperation,value.get());
}
// SupplyAirFlowRateDuringHeatingOperation
if( modelObject.isSupplyAirFlowRateDuringHeatingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringHeatingOperation,"Autosize");
}
else if( (value = modelObject.supplyAirFlowRateDuringHeatingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringHeatingOperation,value.get());
}
// SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded
if( modelObject.isSupplyAirFlowRateWhenNoCoolingorHeatingisNeededAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded,"Autosize");
}
else if( (value = modelObject.supplyAirFlowRateWhenNoCoolingorHeatingisNeeded()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded,value.get());
}
// OutdoorAirFlowRateDuringCoolingOperation
if( modelObject.isOutdoorAirFlowRateDuringCoolingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringCoolingOperation,"Autosize");
}
else if( (value = modelObject.outdoorAirFlowRateDuringCoolingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringCoolingOperation,value.get());
}
// OutdoorAirFlowRateDuringHeatingOperation
if( modelObject.isOutdoorAirFlowRateDuringHeatingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringHeatingOperation,"Autosize");
}
else if( (value = modelObject.outdoorAirFlowRateDuringHeatingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringHeatingOperation,value.get());
}
// OutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded
if( modelObject.isOutdoorAirFlowRateWhenNoCoolingorHeatingisNeededAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded,"Autosize");
}
else if( (value = modelObject.outdoorAirFlowRateWhenNoCoolingorHeatingisNeeded()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded,value.get());
}
// SupplyAirFanObjectType
HVACComponent supplyAirFan = modelObject.supplyAirFan();
if( boost::optional<IdfObject> _supplyAirFan = translateAndMapModelObject(supplyAirFan) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFanObjectType,_supplyAirFan->iddObject().name() );
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFanName,_supplyAirFan->name().get());
if( airOutletNodeName )
{
if( _supplyAirFan->iddObject().type() == IddObjectType::Fan_ConstantVolume )
{
_supplyAirFan->setString(Fan_ConstantVolumeFields::AirInletNodeName,heatingCoilOutletNodeName);
_supplyAirFan->setString(Fan_ConstantVolumeFields::AirOutletNodeName,airOutletNodeName.get());
}
}
}
// HeatingCoilObjectType
HVACComponent heatingCoil = modelObject.heatingCoil();
if( boost::optional<IdfObject> _heatingCoil = translateAndMapModelObject(heatingCoil) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::HeatingCoilObjectType,_heatingCoil->iddObject().name() );
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::HeatingCoilName,_heatingCoil->name().get() );
if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_heatingCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,coolingCoilOutletNodeName);
_heatingCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,heatingCoilOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
_heatingCoil->setString(Coil_Heating_GasFields::AirInletNodeName,coolingCoilOutletNodeName);
_heatingCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,heatingCoilOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_heatingCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,coolingCoilOutletNodeName);
_heatingCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,heatingCoilOutletNodeName);
}
}
// CoolingCoilObjectType
HVACComponent coolingCoil = modelObject.coolingCoil();
boost::optional<IdfObject> _coolingCoil;
if( boost::optional<CoilCoolingDXSingleSpeed> dxCoil = coolingCoil.optionalCast<CoilCoolingDXSingleSpeed>() )
{
_coolingCoil = translateCoilCoolingDXSingleSpeedWithoutUnitary(dxCoil.get());
m_map.insert(std::make_pair(coolingCoil.handle(),_coolingCoil.get()));
}
else
{
_coolingCoil = translateAndMapModelObject(coolingCoil);
}
if( _coolingCoil )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::CoolingCoilObjectType,_coolingCoil->iddObject().name() );
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::CoolingCoilName,_coolingCoil->name().get() );
if( _coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_DX_SingleSpeed )
{
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirInletNodeName,mixedAirNodeName);
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirOutletNodeName,coolingCoilOutletNodeName);
}
}
// FanPlacement
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::FanPlacement,modelObject.fanPlacement());
// SupplyAirFanOperatingModeScheduleName
if( boost::optional<Schedule> schedule = modelObject.supplyAirFanOperatingModeSchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFanOperatingModeScheduleName,_schedule->name().get());
}
}
return idfObject;
}
boost::optional<IdfObject> ForwardTranslator::translateAirLoopHVACUnitaryHeatPumpAirToAir( AirLoopHVACUnitaryHeatPumpAirToAir & modelObject )
{
boost::optional<std::string> s;
boost::optional<double> value;
IdfObject idfObject(IddObjectType::AirLoopHVAC_UnitaryHeatPump_AirToAir);
m_idfObjects.push_back(idfObject);
// Name
s = modelObject.name();
if( s )
{
idfObject.setName(*s);
}
// AvailabilityScheduleName
if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// AirInletNodeName
boost::optional<std::string> airInletNodeName;
if( boost::optional<ModelObject> mo = modelObject.inletModelObject() )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
if( s = node->name() )
{
airInletNodeName = s;
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::AirInletNodeName,s.get());
}
}
}
// AirOutletNodeName
boost::optional<std::string> airOutletNodeName;
if( boost::optional<ModelObject> mo = modelObject.outletModelObject() )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
if( s = node->name() )
{
airOutletNodeName = s;
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::AirOutletNodeName,s.get());
}
}
}
// SupplyAirFlowRateDuringCoolingOperation
if( modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized() )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFlowRateDuringCoolingOperation,"Autosize");
}
else if( value = modelObject.supplyAirFlowRateDuringCoolingOperation() )
{
idfObject.setDouble(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFlowRateDuringCoolingOperation,value.get());
}
// SupplyAirFlowRateDuringHeatingOperation
if( modelObject.isSupplyAirFlowRateDuringHeatingOperationAutosized() )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFlowRateDuringHeatingOperation,"Autosize");
}
else if( value = modelObject.supplyAirFlowRateDuringHeatingOperation() )
{
idfObject.setDouble(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFlowRateDuringHeatingOperation,value.get());
}
// SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded
if( modelObject.isSupplyAirFlowRateWhenNoCoolingorHeatingisNeededAutosized() )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded,"Autosize");
}
else if( value = modelObject.supplyAirFlowRateWhenNoCoolingorHeatingisNeeded() )
{
idfObject.setDouble(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded,value.get());
}
// ControllingZoneorThermostatLocation
if( boost::optional<ThermalZone> tz = modelObject.controllingZone() )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::ControllingZoneorThermostatLocation,tz->name().get() );
}
// SupplyAirFanName
HVACComponent fan = modelObject.supplyAirFan();
boost::optional<IdfObject> _fan = translateAndMapModelObject(fan);
if( _fan )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFanObjectType,_fan->iddObject().name() );
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFanName,_fan->name().get());
}
// HeatingCoilName
boost::optional<IdfObject> _heatingCoil;
HVACComponent heatingCoil = modelObject.heatingCoil();
if( boost::optional<CoilHeatingDXSingleSpeed> coilHeatingDXSingleSpeed = heatingCoil.optionalCast<CoilHeatingDXSingleSpeed>() )
{
_heatingCoil = translateCoilHeatingDXSingleSpeedWithoutUnitary(coilHeatingDXSingleSpeed.get());
if( _heatingCoil )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::HeatingCoilObjectType,_heatingCoil->iddObject().name());
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::HeatingCoilName,_heatingCoil->name().get());
}
}
// CoolingCoilName
boost::optional<IdfObject> _coolingCoil;
boost::optional<CoilCoolingDXSingleSpeed> coolingCoil = modelObject.coolingCoil().optionalCast<CoilCoolingDXSingleSpeed>();
if( coolingCoil )
{
_coolingCoil = translateCoilCoolingDXSingleSpeedWithoutUnitary(coolingCoil.get());
}
if( _coolingCoil )
{
m_map.insert(std::make_pair(coolingCoil->handle(),_coolingCoil.get()));
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::CoolingCoilObjectType,_coolingCoil->iddObject().name());
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::CoolingCoilName,_coolingCoil->name().get());
}
// SupplementalHeatingCoilName
boost::optional<IdfObject> _supplementalHeatingCoil;
boost::optional<HVACComponent> supplementalHeatingCoil = modelObject.supplementalHeatingCoil();
if( supplementalHeatingCoil )
{
_supplementalHeatingCoil = translateAndMapModelObject(supplementalHeatingCoil.get());
}
if( _supplementalHeatingCoil )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplementalHeatingCoilObjectType,
_supplementalHeatingCoil->iddObject().name());
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplementalHeatingCoilName,_supplementalHeatingCoil->name().get());
}
// MaximumSupplyAirTemperaturefromSupplementalHeater
if( modelObject.isMaximumSupplyAirTemperaturefromSupplementalHeaterAutosized() )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::MaximumSupplyAirTemperaturefromSupplementalHeater,"Autosize");
}
else if( value = modelObject.maximumSupplyAirTemperaturefromSupplementalHeater() )
{
idfObject.setDouble(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::MaximumSupplyAirTemperaturefromSupplementalHeater,value.get());
}
// MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation
if( value = modelObject.maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() )
{
idfObject.setDouble(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation,value.get());
}
// FanPlacement
if( s = modelObject.fanPlacement() )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::FanPlacement,s.get());
}
// SupplyAirFanOperatingModeScheduleName
if( boost::optional<Schedule> schedule = modelObject.supplyAirFanOperatingModeSchedule() )
{
boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get());
if( _schedule )
{
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::SupplyAirFanOperatingModeScheduleName,_schedule->name().get());
}
}
// Dehumidification Control Type
if (!modelObject.isDehumidificationControlTypeDefaulted()) {
idfObject.setString(AirLoopHVAC_UnitaryHeatPump_AirToAirFields::DehumidificationControlType,
modelObject.dehumidificationControlType());
}
// Fill in node names for inner components
if( airInletNodeName && _fan )
{
_fan->setString(Fan_ConstantVolumeFields::AirInletNodeName,airInletNodeName.get());
}
//if( airOutletNodeName && _heatingCoil )
//{
// //_heatingCoil->setString(Coil_Heating_DX_SingleSpeedFields::AirOutletNodeName,airOutletNodeName.get());
//}
if( _fan && _coolingCoil )
{
std::string nodeName = modelObject.name().get() + " Fan - Cooling Coil Node";
_fan->setString(Fan_ConstantVolumeFields::AirOutletNodeName,nodeName);
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirInletNodeName,nodeName);
}
if( _coolingCoil && _heatingCoil )
{
std::string nodeName = modelObject.name().get() + " Cooling Coil - Heating Coil Node";
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirOutletNodeName,nodeName);
_heatingCoil->setString(Coil_Heating_DX_SingleSpeedFields::AirInletNodeName,nodeName);
}
if( _supplementalHeatingCoil )
{
std::string nodeName = modelObject.name().get() + " Heating Coil - Supplemental Coil Node";
if( _heatingCoil )
{
_heatingCoil->setString(Coil_Heating_DX_SingleSpeedFields::AirOutletNodeName,nodeName);
}
if( _supplementalHeatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
if( airOutletNodeName )
{
_supplementalHeatingCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,airOutletNodeName.get());
_supplementalHeatingCoil->setString(Coil_Heating_GasFields::AirInletNodeName,nodeName);
}
}
else if( _supplementalHeatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
if( airOutletNodeName )
{
_supplementalHeatingCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,airOutletNodeName.get());
_supplementalHeatingCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,nodeName);
}
}
}
return idfObject;
}
boost::optional<IdfObject> ForwardTranslator::translateAirLoopHVACUnitaryHeatCoolVAVChangeoverBypass( AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass & modelObject )
{
boost::optional<std::string> s;
boost::optional<double> d;
// Name
IdfObject unitarySystem = createRegisterAndNameIdfObject(openstudio::IddObjectType::AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypass, modelObject);
// Availability Schedule Name
if( boost::optional<Schedule> availabilitySchedule = modelObject.availabilitySchedule() )
{
boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule.get());
if( _availabilitySchedule && _availabilitySchedule->name() )
{
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::AvailabilityScheduleName,_availabilitySchedule->name().get());
}
}
// SystemAirFlowRateDuringCoolingOperation
if( modelObject.isSystemAirFlowRateDuringCoolingOperationAutosized() ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::CoolingSupplyAirFlowRate,"AutoSize");
} else if( (d = modelObject.systemAirFlowRateDuringCoolingOperation()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::CoolingSupplyAirFlowRate,d.get());
}
// SystemAirFlowRateDuringHeatingOperation
if( modelObject.isSystemAirFlowRateDuringHeatingOperationAutosized() ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::HeatingSupplyAirFlowRate,"AutoSize");
} else if( (d = modelObject.systemAirFlowRateDuringHeatingOperation()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::HeatingSupplyAirFlowRate,d.get());
}
// SystemAirFlowRateWhenNoCoolingorHeatingisNeeded
if( modelObject.isSystemAirFlowRateWhenNoCoolingorHeatingisNeededAutosized() ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::NoLoadSupplyAirFlowRate,"AutoSize");
} else if( (d = modelObject.systemAirFlowRateWhenNoCoolingorHeatingisNeeded()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::NoLoadSupplyAirFlowRate,d.get());
}
// OutdoorAirFlowRateDuringCoolingOperation
if( modelObject.isOutdoorAirFlowRateDuringCoolingOperationAutosized() ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::CoolingOutdoorAirFlowRate,"AutoSize");
} else if( (d = modelObject.outdoorAirFlowRateDuringCoolingOperation()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::CoolingOutdoorAirFlowRate,d.get());
}
// OutdoorAirFlowRateDuringHeatingOperation
if( modelObject.isOutdoorAirFlowRateDuringHeatingOperationAutosized() ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::HeatingOutdoorAirFlowRate,"AutoSize");
} else if( (d = modelObject.outdoorAirFlowRateDuringHeatingOperation()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::HeatingOutdoorAirFlowRate,d.get());
}
// OutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded
if( modelObject.isOutdoorAirFlowRateWhenNoCoolingorHeatingisNeededAutosized() ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::NoLoadOutdoorAirFlowRate,"AutoSize");
} else if( (d = modelObject.outdoorAirFlowRateWhenNoCoolingorHeatingisNeeded()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::NoLoadOutdoorAirFlowRate,d.get());
}
// OutdoorAirFlowRateMultiplierScheduleName
if( boost::optional<Schedule> schedule = modelObject.outdoorAirFlowRateMultiplierSchedule() ) {
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::OutdoorAirFlowRateMultiplierScheduleName,_schedule->name().get());
}
}
boost::optional<std::string> airInletNodeName;
boost::optional<std::string> airOutletNodeName;
// Air Inlet Node Name
if( boost::optional<ModelObject> mo = modelObject.inletModelObject() )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
airInletNodeName = node->name().get();
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::AirInletNodeName,node->name().get());
}
}
// Air Outlet Node Name
if( boost::optional<ModelObject> mo = modelObject.outletModelObject() )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
airOutletNodeName = node->name().get();
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::AirOutletNodeName,node->name().get());
}
}
std::string baseName = modelObject.name().get();
// BypassDuctMixerNodeName
std::string bypassDuctMixerNodeName = baseName + " Bypass Duct Mixer Node";
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::BypassDuctMixerNodeName,bypassDuctMixerNodeName);
// BypassDuctSplitterNodeName
std::string bypassDuctSplitterNodeName = baseName + " Bypass Duct Splitter Node";
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::BypassDuctSplitterNodeName,bypassDuctSplitterNodeName);
// OutdoorAirMixerObjectType
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::OutdoorAirMixerObjectType,"OutdoorAir:Mixer");
// OutdoorAirMixerName
std::string outdoorAirMixerName = baseName + " Outdoor Air Mixer";
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::OutdoorAirMixerName,outdoorAirMixerName);
// SupplyAirFanName
boost::optional<IdfObject> _fan;
if( boost::optional<HVACComponent> fan = modelObject.supplyAirFan() ) {
if( (_fan = translateAndMapModelObject(fan.get())) ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::SupplyAirFanObjectType,_fan->iddObject().name());
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::SupplyAirFanName,_fan->name().get());
}
}
bool blowThroughFan = false;
// SupplyAirFanPlacement
if( (s = modelObject.supplyAirFanPlacement()) ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::SupplyAirFanPlacement,s.get());
if( istringEqual(s.get(),"BlowThrough") ) {
blowThroughFan = true;
}
}
// SupplyAirFanOperatingModeScheduleName
if( boost::optional<Schedule> schedule = modelObject.supplyAirFanOperatingModeSchedule() ) {
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::SupplyAirFanOperatingModeScheduleName,_schedule->name().get());
}
}
// Heating Coil Object Type
// Heating Coil Name
boost::optional<IdfObject> _heatingCoil;
if( boost::optional<HVACComponent> heatingCoil = modelObject.heatingCoil() )
{
_heatingCoil = translateAndMapModelObject(heatingCoil.get());
if( _heatingCoil && _heatingCoil->name() )
{
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::HeatingCoilObjectType,_heatingCoil->iddObject().name());
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::HeatingCoilName,_heatingCoil->name().get());
}
}
// Cooling Coil Object Type
// Cooling Coil Name
boost::optional<IdfObject> _coolingCoil;
if( boost::optional<HVACComponent> coolingCoil = modelObject.coolingCoil() )
{
if( boost::optional<CoilCoolingDXSingleSpeed> dxCoil = coolingCoil->optionalCast<CoilCoolingDXSingleSpeed>() ) {
_coolingCoil = translateCoilCoolingDXSingleSpeedWithoutUnitary(dxCoil.get());
m_map.insert(std::make_pair(coolingCoil->handle(),_coolingCoil.get()));
} else {
_coolingCoil = translateAndMapModelObject(coolingCoil.get());
}
if( _coolingCoil && _coolingCoil->name() )
{
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::CoolingCoilObjectType,_coolingCoil->iddObject().name());
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::CoolingCoilName,_coolingCoil->name().get());
}
}
// PriorityControlMode
if( (s = modelObject.priorityControlMode()) ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::PriorityControlMode,s.get());
}
// MinimumOutletAirTemperatureDuringCoolingOperation
if( (d = modelObject.minimumOutletAirTemperatureDuringCoolingOperation()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::MinimumOutletAirTemperatureDuringCoolingOperation,d.get());
}
// MaximumOutletAirTemperatureDuringHeatingOperation)(Maximum Outlet Air Temperature During Heating Operation))
if( (d = modelObject.maximumOutletAirTemperatureDuringHeatingOperation()) ) {
unitarySystem.setDouble(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::MaximumOutletAirTemperatureDuringHeatingOperation,d.get());
}
// DehumidificationControlType
if( (s = modelObject.dehumidificationControlType()) ) {
unitarySystem.setString(AirLoopHVAC_UnitaryHeatCool_VAVChangeoverBypassFields::DehumidificationControlType,s.get());
}
if( _fan && _coolingCoil && _heatingCoil )
{
std::string fanOutletNodeName;
std::string fanInletNodeName;
std::string heatOutletNodeName;
std::string heatInletNodeName;
std::string coolOutletNodeName;
std::string coolInletNodeName;
std::string mixedAirNodeName;
if( blowThroughFan ) {
mixedAirNodeName = baseName + " Mixed Air Node";
fanInletNodeName = mixedAirNodeName;
fanOutletNodeName = baseName + " Fan Outlet Node";
coolInletNodeName = fanOutletNodeName;
coolOutletNodeName = baseName + " Cooling Coil Outlet Node";
heatInletNodeName = coolOutletNodeName;
heatOutletNodeName = bypassDuctSplitterNodeName;
} else {
mixedAirNodeName = baseName + " Mixed Air Node";
coolInletNodeName = mixedAirNodeName;
coolOutletNodeName = baseName + " Cooling Coil Outlet Node";
heatInletNodeName = coolOutletNodeName;
heatOutletNodeName = baseName + " Heating Coil Outlet Node";
fanInletNodeName = heatOutletNodeName;
fanOutletNodeName = bypassDuctSplitterNodeName;
}
if( _fan->iddObject().type() == IddObjectType::Fan_ConstantVolume )
{
_fan->setString(Fan_ConstantVolumeFields::AirInletNodeName,fanInletNodeName);
_fan->setString(Fan_ConstantVolumeFields::AirOutletNodeName,fanOutletNodeName);
}
else if( _fan->iddObject().type() == IddObjectType::Fan_VariableVolume )
{
_fan->setString(Fan_VariableVolumeFields::AirInletNodeName,fanInletNodeName);
_fan->setString(Fan_VariableVolumeFields::AirOutletNodeName,fanOutletNodeName);
}
else if( _fan->iddObject().type() == IddObjectType::Fan_OnOff )
{
_fan->setString(Fan_OnOffFields::AirInletNodeName,fanInletNodeName);
_fan->setString(Fan_OnOffFields::AirOutletNodeName,fanOutletNodeName);
}
fixSPMsForUnitarySystem(modelObject,fanInletNodeName,fanOutletNodeName);
if( _coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_DX_SingleSpeed )
{
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirInletNodeName,coolInletNodeName);
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirOutletNodeName,coolOutletNodeName);
}
else if( _coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_DX_TwoSpeed )
{
_coolingCoil->setString(Coil_Cooling_DX_TwoSpeedFields::AirInletNodeName,coolInletNodeName);
_coolingCoil->setString(Coil_Cooling_DX_TwoSpeedFields::AirOutletNodeName,coolOutletNodeName);
}
else if( _coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_Water )
{
_coolingCoil->setString(Coil_Cooling_WaterFields::AirInletNodeName,coolInletNodeName);
_coolingCoil->setString(Coil_Cooling_WaterFields::AirOutletNodeName,coolOutletNodeName);
}
else if( _coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_WaterToAirHeatPump_EquationFit )
{
_coolingCoil->setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::AirInletNodeName,coolInletNodeName);
_coolingCoil->setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::AirOutletNodeName,coolOutletNodeName);
}
if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_DX_SingleSpeed )
{
_heatingCoil->setString(Coil_Heating_DX_SingleSpeedFields::AirInletNodeName,heatInletNodeName);
_heatingCoil->setString(Coil_Heating_DX_SingleSpeedFields::AirOutletNodeName,heatOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_heatingCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,heatInletNodeName);
_heatingCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,heatOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
_heatingCoil->setString(Coil_Heating_GasFields::AirInletNodeName,heatInletNodeName);
_heatingCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,heatOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_heatingCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,heatInletNodeName);
_heatingCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,heatOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Desuperheater )
{
_heatingCoil->setString(Coil_Heating_DesuperheaterFields::AirInletNodeName,heatInletNodeName);
_heatingCoil->setString(Coil_Heating_DesuperheaterFields::AirOutletNodeName,heatOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_WaterToAirHeatPump_EquationFit )
{
_heatingCoil->setString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::AirInletNodeName,heatInletNodeName);
_heatingCoil->setString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::AirOutletNodeName,heatOutletNodeName);
}
IdfObject _outdoorAirMixer(IddObjectType::OutdoorAir_Mixer);
_outdoorAirMixer.setName(outdoorAirMixerName);
m_idfObjects.push_back(_outdoorAirMixer);
std::string oaNodeName = baseName + " OA Node";
_outdoorAirMixer.setString(OutdoorAir_MixerFields::MixedAirNodeName,mixedAirNodeName);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName,oaNodeName);
IdfObject _oaNodeList(openstudio::IddObjectType::OutdoorAir_NodeList);
_oaNodeList.setString(0,oaNodeName);
m_idfObjects.push_back(_oaNodeList);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::ReliefAirStreamNodeName,baseName + " Relief Air Node");
_outdoorAirMixer.setString(OutdoorAir_MixerFields::ReturnAirStreamNodeName,bypassDuctMixerNodeName);
}
return unitarySystem;
}
