boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctConstantVolumeFourPipeInduction( AirTerminalSingleDuctConstantVolumeFourPipeInduction & modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName(modelObject.name().get() + " Air Distribution Unit");
m_idfObjects.push_back(_airDistributionUnit);
// Name
IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_ConstantVolume_FourPipeInduction, modelObject);
// Availability Schedule Name
if( (temp = modelObject.availabilitySchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// Maximum Total Air Flow Rate
if( (d = modelObject.maximumTotalAirFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate,d.get());
}
else if( modelObject.isMaximumTotalAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate,"Autosize");
}
// Induction Ratio
if( (d = modelObject.inductionRatio()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InductionRatio,d.get());
}
// Supply Air Inlet Node Name
if( auto node = modelObject.inletModelObject() ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::SupplyAirInletNodeName,node->name().get());
}
// Induced Air Inlet Node Name
if( auto node = modelObject.inducedAirInletNode() ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InducedAirInletNodeName,node->name().get());
}
// Air Outlet Node Name
if( auto node = modelObject.outletModelObject() ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AirOutletNodeName,node->name().get());
}
// Hot Water Inlet Node Name
// deprecated
// Cold Water Inlet Node Name
//deprecated
// Heating Coil Object Type
// Heating Coil Name
boost::optional<IdfObject> _heatingCoil;
{
auto heatingCoil = modelObject.heatingCoil();
if( (_heatingCoil = translateAndMapModelObject(heatingCoil)) ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingCoilObjectType,_heatingCoil->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingCoilName,_heatingCoil->name().get());
}
}
// Maximum Hot Water Flow Rate
if( (d = modelObject.maximumHotWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate,d.get());
}
else if( modelObject.isMaximumHotWaterFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate,"Autosize");
}
// Minimum Hot Water Flow Rate
if( (d = modelObject.minimumHotWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumHotWaterFlowRate,d.get());
}
// Heating Convergence Tolerance
if( (d = modelObject.heatingConvergenceTolerance()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingConvergenceTolerance,d.get());
}
// Cooling Coil Object Type
// Cooling Coil Name
boost::optional<IdfObject> _coolingCoil;
if( auto coolingCoil = modelObject.coolingCoil() ) {
if( (_coolingCoil = translateAndMapModelObject(coolingCoil.get())) ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingCoilObjectType,_coolingCoil->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingCoilName,_coolingCoil->name().get());
}
}
// Maximum Cold Water Flow Rate
if( (d = modelObject.maximumColdWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate,d.get());
}
else if( modelObject.isMaximumColdWaterFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate,"Autosize");
}
// Minimum Cold Water Flow Rate
if( (d = modelObject.minimumColdWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumColdWaterFlowRate,d.get());
}
// Cooling Convergence Tolerance
if( (d = modelObject.coolingConvergenceTolerance()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingConvergenceTolerance,d.get());
}
// Zone Mixer Name
IdfObject _mixer(IddObjectType::AirLoopHVAC_ZoneMixer);
_mixer.setName(modelObject.name().get() + " Mixer");
m_idfObjects.push_back(_mixer);
_mixer.clearExtensibleGroups();
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::ZoneMixerName,_mixer.name().get());
std::string baseName = modelObject.name().get();
std::string heatingCoilInlet;
std::string heatingCoilOutlet;
std::string coolingCoilInlet;
std::string coolingCoilOutlet;
std::string mixerAirSystemInlet;
std::string mixerInducedInlet;
std::string mixerOutlet;
if( auto inducedAirInletNode = modelObject.inducedAirInletNode() ) {
heatingCoilInlet = inducedAirInletNode->name().get();
}
heatingCoilOutlet = baseName + " Heating Coil Outlet";
if( _coolingCoil ) {
coolingCoilInlet = heatingCoilOutlet;
coolingCoilOutlet = baseName + " Cooling Coil Outlet";
mixerInducedInlet = coolingCoilOutlet;
} else {
mixerInducedInlet = heatingCoilOutlet;
}
if( auto node = modelObject.inletModelObject() ) {
mixerAirSystemInlet = node->name().get();
}
if( auto node = modelObject.outletModelObject() ) {
mixerOutlet = node->name().get();
}
if( _heatingCoil && (_heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Water) ) {
_heatingCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,heatingCoilInlet);
_heatingCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,heatingCoilOutlet);
}
if( _coolingCoil && (_coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_Water) ) {
_coolingCoil->setString(Coil_Cooling_WaterFields::AirInletNodeName,coolingCoilInlet);
_coolingCoil->setString(Coil_Cooling_WaterFields::AirOutletNodeName,coolingCoilOutlet);
}
_mixer.setString(AirLoopHVAC_ZoneMixerFields::OutletNodeName,mixerOutlet);
IdfExtensibleGroup eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,mixerAirSystemInlet);
eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,mixerInducedInlet);
if( auto node = modelObject.outletModelObject() ) {
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,node->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctVAVReheat( AirTerminalSingleDuctVAVReheat & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
std::string baseName = modelObject.name().get();
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_VAV_Reheat);
idfObject.setName(baseName);
HVACComponent coil = modelObject.reheatCoil();
m_idfObjects.push_back(_airDistributionUnit);
m_idfObjects.push_back(idfObject);
boost::optional<IdfObject> _reheatCoil = translateAndMapModelObject(coil);
if( _reheatCoil && _reheatCoil->name() )
{
std::string damperOutletNodeName = modelObject.name().get() + " Damper Outlet";
boost::optional<std::string> inletNodeName;
boost::optional<std::string> outletNodeName;
if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )
{
if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )
{
inletNodeName = inletNode->name().get();
}
}
if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )
{
if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )
{
outletNodeName = outletNode->name().get();
}
}
// Reheat Coil Name
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::ReheatCoilName,_reheatCoil->name().get());
// Reheat Coil Type
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::ReheatCoilObjectType,_reheatCoil->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::DamperAirOutletNodeName,damperOutletNodeName);
if( outletNodeName && inletNodeName )
{
if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
_reheatCoil->setString(Coil_Heating_GasFields::AirInletNodeName,damperOutletNodeName);
_reheatCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_reheatCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,damperOutletNodeName);
_reheatCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_reheatCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,damperOutletNodeName);
_reheatCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,outletNodeName.get());
}
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::AirOutletNodeName,outletNodeName.get());
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::AirInletNodeName,inletNodeName.get());
}
}
else
{
LOG(Error,modelObject.briefDescription() << ": Could not translate heating coil");
return boost::none;
}
// AvailabilityScheduleName
Schedule availabilitySchedule = modelObject.availabilitySchedule();
boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule);
if( _availabilitySchedule && _availabilitySchedule->name() )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::AvailabilityScheduleName,_availabilitySchedule->name().get());
}
// MaximumAirFlowRate
boost::optional<double> value = modelObject.maximumAirFlowRate();
if( value )
{
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumAirFlowRate,value.get());
}
else if( modelObject.isMaximumAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumAirFlowRate,"Autosize");
}
// ZoneMinimumAirFlowMethod
s = modelObject.zoneMinimumAirFlowMethod();
if( s )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::ZoneMinimumAirFlowInputMethod,s.get());
}
// ConstantMinimumAirFlowFraction
value = modelObject.constantMinimumAirFlowFraction();
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::ConstantMinimumAirFlowFraction,value.get());
// FixedMinimumAirFlowRate
value = modelObject.fixedMinimumAirFlowRate();
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::FixedMinimumAirFlowRate,value.get());
// MinimumAirFlowFractionScheduleName
boost::optional<Schedule> minAirFlowFractionSchedule = modelObject.minimumAirFlowFractionSchedule();
if( minAirFlowFractionSchedule )
{
boost::optional<IdfObject> _minAirFlowFractionSchedule = translateAndMapModelObject(minAirFlowFractionSchedule.get());
if( _minAirFlowFractionSchedule && _minAirFlowFractionSchedule->name() )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::MinimumAirFlowFractionScheduleName,_minAirFlowFractionSchedule->name().get());
}
}
// MaximumHotWaterOrSteamFlowRate
value = modelObject.maximumHotWaterOrSteamFlowRate();
if( value )
{
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumHotWaterorSteamFlowRate,value.get());
}
else if( modelObject.isMaximumHotWaterOrSteamFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumHotWaterorSteamFlowRate,"Autosize");
}
// MinimumHotWaterOrSteamFlowRate
value = modelObject.minimumHotWaterOrSteamFlowRate();
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MinimumHotWaterorSteamFlowRate,value.get());
// ConvergenceTolerance
value = modelObject.convergenceTolerance();
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::ConvergenceTolerance,value.get());
// DamperHeatingAction
s = modelObject.damperHeatingAction();
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::DamperHeatingAction,s.get());
// MaximumFlowPerZoneFloorAreaDuringReheat
value = modelObject.maximumFlowPerZoneFloorAreaDuringReheat();
if( value )
{
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowperZoneFloorAreaDuringReheat,value.get());
}
else if ( modelObject.isMaximumFlowPerZoneFloorAreaDuringReheatAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowperZoneFloorAreaDuringReheat,"Autocalculate");
}
// MaximumFlowFractionDuringReheat
value = modelObject.maximumFlowFractionDuringReheat();
if( value )
{
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowFractionDuringReheat,value.get());
}
else if( modelObject.isMaximumFlowFractionDuringReheatAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumFlowFractionDuringReheat,"Autocalculate");
}
// MaximumReheatAirTemperature
value = modelObject.maximumReheatAirTemperature();
idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumReheatAirTemperature,value.get());
// Populate fields for AirDistributionUnit
if( boost::optional<ModelObject> outletNode = modelObject.outletModelObject() )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNode->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
// ControlForOutdoorAir
{
if( modelObject.controlForOutdoorAir() ) {
if( auto airLoopHVAC = modelObject.airLoopHVAC() ) {
auto zones = airLoopHVAC->demandComponents(modelObject,airLoopHVAC->demandOutletNode(),model::ThermalZone::iddObjectType());
if( ! zones.empty() ) {
auto zone = zones.front();
auto spaces = zone.cast<model::ThermalZone>().spaces();
if( ! spaces.empty() ) {
if( auto designSpecificationOutdoorAir = spaces.front().designSpecificationOutdoorAir() ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::DesignSpecificationOutdoorAirObjectName,
designSpecificationOutdoorAir->name().get());
}
}
}
}
}
}
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctParallelPIUReheat( AirTerminalSingleDuctParallelPIUReheat & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
boost::optional<double> value;
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName(modelObject.name().get() + " Air Distribution Unit");
m_idfObjects.push_back(_airDistributionUnit);
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_ParallelPIU_Reheat);
idfObject.setName(modelObject.name().get());
m_idfObjects.push_back(idfObject);
HVACComponent coil = modelObject.reheatCoil();
boost::optional<IdfObject> _reheatCoil = translateAndMapModelObject(coil);
HVACComponent fan = modelObject.fan();
boost::optional<IdfObject> _fan = translateAndMapModelObject(fan);
std::string fanOutletNodeName = modelObject.name().get() + " Fan Outlet";
std::string mixerOutletNodeName = modelObject.name().get() + " Mixer Outlet";
boost::optional<std::string> inletNodeName;
boost::optional<std::string> secondaryAirInletNodeName;
boost::optional<std::string> outletNodeName;
if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )
{
if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )
{
inletNodeName = inletNode->name().get();
}
}
if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )
{
if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )
{
outletNodeName = outletNode->name().get();
}
}
if( boost::optional<Node> secondaryInletNode = modelObject.secondaryAirInletNode() )
{
if( secondaryInletNode )
{
secondaryAirInletNodeName = secondaryInletNode->name().get();
}
}
if( outletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::OutletNodeName,outletNodeName.get());
}
if( inletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::SupplyAirInletNodeName,inletNodeName.get());
}
if( secondaryAirInletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::SecondaryAirInletNodeName,secondaryAirInletNodeName.get());
}
// Populate fields for AirDistributionUnit
if( outletNodeName )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNodeName.get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
// MixerName
IdfObject _mixer(IddObjectType::AirLoopHVAC_ZoneMixer);
_mixer.setName(modelObject.name().get() + " Mixer");
m_idfObjects.push_back(_mixer);
_mixer.clearExtensibleGroups();
_mixer.setString(AirLoopHVAC_ZoneMixerFields::OutletNodeName,mixerOutletNodeName);
IdfExtensibleGroup eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,fanOutletNodeName);
if( inletNodeName )
{
eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,inletNodeName.get());
}
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ZoneMixerName,_mixer.name().get());
// FanName
if( _fan || _fan->name() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::FanName,_fan->name().get());
if( secondaryAirInletNodeName )
{
_fan->setString(Fan_ConstantVolumeFields::AirInletNodeName,secondaryAirInletNodeName.get());
}
_fan->setString(Fan_ConstantVolumeFields::AirOutletNodeName,fanOutletNodeName);
}
// ReheatCoilName
if( _reheatCoil && _reheatCoil->name() )
{
// Reheat Coil Name
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ReheatCoilName,_reheatCoil->name().get());
// Reheat Coil Type
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ReheatCoilObjectType,_reheatCoil->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ReheatCoilAirInletNodeName,mixerOutletNodeName);
if( outletNodeName && inletNodeName )
{
if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Fuel )
{
_reheatCoil->setString(Coil_Heating_FuelFields::AirInletNodeName,mixerOutletNodeName);
_reheatCoil->setString(Coil_Heating_FuelFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_reheatCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,mixerOutletNodeName);
_reheatCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_reheatCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,mixerOutletNodeName);
_reheatCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,outletNodeName.get());
}
}
}
// AvailabilityScheduleName
Schedule availabilitySchedule = modelObject.availabilitySchedule();
boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule);
if( _availabilitySchedule && _availabilitySchedule->name() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::AvailabilityScheduleName,_availabilitySchedule->name().get());
}
// MaximumPrimaryAirFlowRate
if( modelObject.isMaximumPrimaryAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumPrimaryAirFlowRate,"Autosize");
}
else if( (value = modelObject.maximumPrimaryAirFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumPrimaryAirFlowRate,value.get());
}
// MaximumSecondaryAirFlowRate
if( modelObject.isMaximumSecondaryAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumSecondaryAirFlowRate,"Autosize");
}
else if( (value = modelObject.maximumSecondaryAirFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumSecondaryAirFlowRate,value.get());
}
// MinimumPrimaryAirFlowFraction
if( modelObject.isMinimumPrimaryAirFlowFractionAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MinimumPrimaryAirFlowFraction,"Autosize");
}
else if( (value = modelObject.minimumPrimaryAirFlowFraction()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MinimumPrimaryAirFlowFraction,value.get());
}
// FanOnFlowFraction
if( modelObject.isFanOnFlowFractionAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::FanOnFlowFraction,"Autosize");
}
else if( (value = modelObject.fanOnFlowFraction()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::FanOnFlowFraction,value.get());
}
// MaximumHotWaterorSteamFlowRate
if( modelObject.isMaximumHotWaterorSteamFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumHotWaterorSteamFlowRate,"Autosize");
}
else if( (value = modelObject.maximumHotWaterorSteamFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumHotWaterorSteamFlowRate,value.get());
}
// MinimumHotWaterorSteamFlowRate
if( (value = modelObject.minimumHotWaterorSteamFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MinimumHotWaterorSteamFlowRate,value.get());
}
// ConvergenceTolerance
if( (value = modelObject.convergenceTolerance()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ConvergenceTolerance,value.get());
}
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctConstantVolumeReheat( AirTerminalSingleDuctConstantVolumeReheat& modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
std::string baseName = modelObject.name().get();
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_ConstantVolume_Reheat);
idfObject.setName(baseName);
HVACComponent coil = modelObject.reheatCoil();
m_idfObjects.push_back(_airDistributionUnit);
m_idfObjects.push_back(idfObject);
boost::optional<IdfObject> _reheatCoil = translateAndMapModelObject(coil);
if( _reheatCoil && _reheatCoil->name() )
{
boost::optional<std::string> inletNodeName;
boost::optional<std::string> outletNodeName;
if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )
{
if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )
{
inletNodeName = inletNode->name().get();
}
}
if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )
{
if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )
{
outletNodeName = outletNode->name().get();
}
}
// Reheat Coil Name
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::ReheatCoilName,_reheatCoil->name().get());
// Reheat Coil Type
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::ReheatCoilObjectType,_reheatCoil->iddObject().name());
if( outletNodeName && inletNodeName )
{
if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
_reheatCoil->setString(Coil_Heating_GasFields::AirInletNodeName,inletNodeName.get());
_reheatCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_reheatCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,inletNodeName.get());
_reheatCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_reheatCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,inletNodeName.get());
_reheatCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,outletNodeName.get());
}
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::AirOutletNodeName,outletNodeName.get());
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::AirInletNodeName,inletNodeName.get());
}
}
else
{
LOG(Error,modelObject.briefDescription() << ": Could not translate heating coil");
return boost::none;
}
// AvailabilityScheduleName
Schedule availabilitySchedule = modelObject.availabilitySchedule();
boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule);
if( _availabilitySchedule && _availabilitySchedule->name() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::AvailabilityScheduleName,_availabilitySchedule->name().get());
}
// MaximumAirFlowRate
boost::optional<double> value = modelObject.maximumAirFlowRate();
if( value )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MaximumAirFlowRate,value.get());
}
else if( modelObject.isMaximumAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MaximumAirFlowRate,"Autosize");
}
// HotWaterorSteamInletNodeName
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::HotWaterorSteamInletNodeName,"");
// MaximumHotWaterOrSteamFlowRate
value = modelObject.maximumHotWaterorSteamFlowRate();
if( value )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MaximumHotWaterorSteamFlowRate,value.get());
}
else if( modelObject.isMaximumHotWaterorSteamFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MaximumHotWaterorSteamFlowRate,"Autosize");
}
// MinimumHotWaterOrSteamFlowRate
value = modelObject.minimumHotWaterorSteamFlowRate();
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MinimumHotWaterorSteamFlowRate,value.get());
// ConvergenceTolerance
value = modelObject.convergenceTolerance();
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::ConvergenceTolerance,value.get());
// MaximumReheatAirTemperature
value = modelObject.maximumReheatAirTemperature();
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MaximumReheatAirTemperature,value.get());
// Populate fields for AirDistributionUnit
if( boost::optional<ModelObject> outletNode = modelObject.outletModelObject() )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNode->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctVAVHeatAndCoolNoReheat( AirTerminalSingleDuctVAVHeatAndCoolNoReheat & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
boost::optional<double> value;
std::string baseName = modelObject.name().get();
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_VAV_HeatAndCool_NoReheat);
idfObject.setName(baseName);
m_idfObjects.push_back(_airDistributionUnit);
m_idfObjects.push_back(idfObject);
boost::optional<std::string> inletNodeName;
boost::optional<std::string> outletNodeName;
if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )
{
if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )
{
inletNodeName = inletNode->name().get();
}
}
if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )
{
if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )
{
outletNodeName = outletNode->name().get();
}
}
if( outletNodeName && inletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_NoReheatFields::AirOutletNodeName,outletNodeName.get());
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_NoReheatFields::AirInletNodeName,inletNodeName.get());
}
// AvailabilityScheduleName
if( auto schedule = modelObject.availabilitySchedule() ) {
if( auto _schedule = translateAndMapModelObject(schedule.get()) ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_NoReheatFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// MaximumAirFlowRate
if( modelObject.isMaximumAirFlowRateAutosized() ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_NoReheatFields::MaximumAirFlowRate,"AutoSize");
}
else if( (value = modelObject.maximumAirFlowRate()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_NoReheatFields::MaximumAirFlowRate,value.get());
}
// ZoneMinimumAirFlowFraction
if( (value = modelObject.zoneMinimumAirFlowFraction()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_NoReheatFields::ZoneMinimumAirFlowFraction,value.get());
}
// Populate fields for AirDistributionUnit
if( boost::optional<ModelObject> outletNode = modelObject.outletModelObject() )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNode->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctInletSideMixer( AirTerminalSingleDuctInletSideMixer & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
std::string baseName = modelObject.name().get();
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_InletSideMixer);
idfObject.setName(baseName);
m_idfObjects.push_back(_airDistributionUnit);
m_idfObjects.push_back(idfObject);
boost::optional<std::string> inletNodeName;
boost::optional<std::string> outletNodeName;
if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )
{
if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )
{
inletNodeName = inletNode->name().get();
}
}
if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )
{
if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )
{
outletNodeName = outletNode->name().get();
}
}
if( outletNodeName && inletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_InletSideMixerFields::TerminalUnitOutletNodeName,outletNodeName.get());
idfObject.setString(AirTerminal_SingleDuct_InletSideMixerFields::TerminalUnitPrimaryAirInletNodeName,inletNodeName.get());
}
if( boost::optional<AirLoopHVAC> airLoopHVAC = modelObject.airLoopHVAC() ) {
std::vector<ZoneHVACComponent> zoneHVACs = subsetCastVector<ZoneHVACComponent>(airLoopHVAC->demandComponents(modelObject,airLoopHVAC->demandOutletNode()));
if( ! zoneHVACs.empty() ) {
ZoneHVACComponent zoneHVAC = zoneHVACs.front();
if( boost::optional<IdfObject> _zoneHVAC= translateAndMapModelObject(zoneHVAC) ) {
idfObject.setString(AirTerminal_SingleDuct_InletSideMixerFields::ZoneHVACTerminalUnitObjectType,_zoneHVAC->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_InletSideMixerFields::ZoneHVACTerminalUnitName,_zoneHVAC->name().get());
}
}
}
// TerminalUnitSecondaryAirInletNodeName
if( boost::optional<Node> secondaryInletNode = modelObject.secondaryAirInletNode() ) {
idfObject.setString(AirTerminal_SingleDuct_InletSideMixerFields::TerminalUnitSecondaryAirInletNodeName,secondaryInletNode->name().get());
}
// Populate fields for AirDistributionUnit
if( boost::optional<ModelObject> outletNode = modelObject.outletModelObject() )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNode->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalDualDuctVAV( AirTerminalDualDuctVAV & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
std::string baseName = modelObject.name().get();
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_DualDuct_VAV);
idfObject.setName(baseName);
m_idfObjects.push_back(_airDistributionUnit);
m_idfObjects.push_back(idfObject);
if( auto schedule = modelObject.availabilitySchedule() ) {
if( auto idf = translateAndMapModelObject(schedule.get()) ) {
idfObject.setString(AirTerminal_DualDuct_VAVFields::AvailabilityScheduleName,idf->name().get());
}
}
if( auto mo = modelObject.outletModelObject() ) {
idfObject.setString(AirTerminal_DualDuct_VAVFields::AirOutletNodeName,mo->name().get());
}
if( auto mo = modelObject.inletModelObject(0) ) {
idfObject.setString(AirTerminal_DualDuct_VAVFields::HotAirInletNodeName,mo->name().get());
}
if( auto mo = modelObject.inletModelObject(1) ) {
idfObject.setString(AirTerminal_DualDuct_VAVFields::ColdAirInletNodeName,mo->name().get());
}
if( modelObject.isMaximumDamperAirFlowRateAutosized() ) {
idfObject.setString(AirTerminal_DualDuct_VAVFields::MaximumDamperAirFlowRate,"Autosize");
} else if ( auto value = modelObject.maximumDamperAirFlowRate() ) {
idfObject.setDouble(AirTerminal_DualDuct_VAVFields::MaximumDamperAirFlowRate,value.get());
}
{
auto value = modelObject.zoneMinimumAirFlowFraction();
idfObject.setDouble(AirTerminal_DualDuct_VAVFields::ZoneMinimumAirFlowFraction,value);
}
if( auto designOA = modelObject.designSpecificationOutdoorAirObject() ) {
if( auto idf = translateAndMapModelObject(designOA.get()) ) {
idfObject.setString(AirTerminal_DualDuct_VAVFields::DesignSpecificationOutdoorAirObjectName,idf->name().get());
}
}
// Populate fields for AirDistributionUnit
if( boost::optional<ModelObject> outletNode = modelObject.outletModelObject() )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNode->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctConstantVolumeCooledBeam(
AirTerminalSingleDuctConstantVolumeCooledBeam & modelObject ){
//Name
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_ConstantVolume_CooledBeam);
m_idfObjects.push_back(idfObject);
std:: string baseName = modelObject.name().get();
idfObject.setName(baseName);
//register the air distribution unit in the map rather than the chilled beam air terminal itself.
//this is necessary because the air distribution unit encapsulating the chilled beam air terminal
//goes on both the brachlist and the zone HVAC equipment list
//since the branches are translated first, when the chilled beam's coil is encountered in the branchlist, the air distribution unit
//that encapsulates the chilled beam is returned and put onto the branch list.
//When the chilled beam air terminal is encountered again on the zone HVAC equipment list,
//the map must return the air distribution unit to ensure that the air distribution unit is on the translated
//equipment list.
IdfObject _airDistributionUnit(IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit
m_idfObjects.push_back(_airDistributionUnit);
boost::optional<std::string> s;
boost::optional<double> value;
boost::optional<int> number;
boost::optional<ModelObject> temp;
// Forward Translate Cooling Coil
//get the cooling coil as a HVAC component, cast it to optional cool coil, if cast is successful,
//get the object of class CoilCoolingCooledBeam
HVACComponent coilCool = modelObject.coilCoolingCooledBeam();
boost::optional<CoilCoolingCooledBeam> optionalCoilCoolingCooledBeam = coilCool.optionalCast<CoilCoolingCooledBeam>();
// Field A2 Availability Schedule Name
if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// Field A3 Cooled Beam Type
if((s = modelObject.cooledBeamType()))
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::CooledBeamType,s.get());
}
// Field A4 Supply Air Inlet Node Name
temp = modelObject.inletModelObject();
if(temp)
{
if((s = temp->name()))
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::SupplyAirInletNodeName,s.get());
}
}
// Field A5 Supply Air Outlet Node Name
temp = modelObject.outletModelObject();
if(temp)
{
if((s = temp->name()))
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::SupplyAirOutletNodeName,s.get());
}
}
if (optionalCoilCoolingCooledBeam) {
CoilCoolingCooledBeam coilCoolingCooledBeam = *optionalCoilCoolingCooledBeam;
// Field A6 Chilled Water Inlet Node Name
temp = coilCoolingCooledBeam.inletModelObject();
if(temp)
{
if((s = temp->name()))
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ChilledWaterInletNodeName,s.get());
}
}
// Field A7 Chilled Water Outlet Node Name
temp = coilCoolingCooledBeam.outletModelObject();
if(temp)
{
if((s = temp->name()))
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ChilledWaterOutletNodeName,s.get());
}
}
// Field N1 Supply Air Volumetric Flow Rate
if(modelObject.isSupplyAirVolumetricFlowRateDefaulted())
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::SupplyAirVolumetricFlowRate,"autosize");
}
else if((value = modelObject.supplyAirVolumetricFlowRate()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::SupplyAirVolumetricFlowRate,value.get());
}
// Field N2 Maximum Total Chilled Water Volumetric Flow Rate
if(modelObject.isMaximumTotalChilledWaterVolumetricFlowRateDefaulted())
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::MaximumTotalChilledWaterVolumetricFlowRate,"autosize");
}
else if((value = modelObject.maximumTotalChilledWaterVolumetricFlowRate()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::MaximumTotalChilledWaterVolumetricFlowRate,value.get());
}
// Field N3 Number of Beams
if(modelObject.isNumberofBeamsDefaulted())
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::NumberofBeams,"autosize");
}
else if((number = modelObject.numberofBeams()))
{
idfObject.setInt(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::NumberofBeams,number.get());
}
// Field N4 Beam Length
if(modelObject.isBeamLengthDefaulted())
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::BeamLength,"autosize");
}
else if((value = modelObject.beamLength()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::BeamLength,value.get());
}
// Field N5 Design Inlet Water Temperature
if(modelObject.isDesignInletWaterTemperatureDefaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::DesignInletWaterTemperature,15.0);
}
else if((value = modelObject.designInletWaterTemperature()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::DesignInletWaterTemperature,value.get());
}
// Field N6 Design Outlet Water Temperature
if(modelObject.isDesignOutletWaterTemperatureDefaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::DesignOutletWaterTemperature,17.0);
}
else if((value = modelObject.designOutletWaterTemperature()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::DesignOutletWaterTemperature,value.get());
}
// Field N7 Coil Surface Area per Coil Length
if(coilCoolingCooledBeam.isCoilSurfaceAreaperCoilLengthDefaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::CoilSurfaceAreaperCoilLength,5.422);
}
else if((value = coilCoolingCooledBeam.coilSurfaceAreaperCoilLength()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::CoilSurfaceAreaperCoilLength,value.get());
}
// Field N8 Model Parameter a
if(coilCoolingCooledBeam.isModelParameteraDefaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametera,15.3);
}
else if((value = coilCoolingCooledBeam.modelParametera()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametera,value.get());
}
// Field N9 Model Parameter n1
if(coilCoolingCooledBeam.isModelParametern1Defaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern1,0);
}
else if((value = coilCoolingCooledBeam.modelParametern1()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern1,value.get());
}
// Field N10 Model Parameter n2
if(coilCoolingCooledBeam.isModelParametern2Defaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern2,0.84);
}
else if((value = coilCoolingCooledBeam.modelParametern2()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern2,value.get());
}
// Field N11 Model Parameter n3
if(coilCoolingCooledBeam.isModelParametern3Defaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern3,0.12);
}
else if((value = coilCoolingCooledBeam.modelParametern3()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern3,value.get());
}
// Field N12 Model Parameter a0
if(coilCoolingCooledBeam.isModelParametera0Defaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametera0,0.171);
}
else if((value = coilCoolingCooledBeam.modelParametera0()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametera0,value.get());
}
// Field N13 Model Parameter K1
if(coilCoolingCooledBeam.isModelParameterK1Defaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParameterK1,0.0057);
}
else if((value = coilCoolingCooledBeam.modelParameterK1()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParameterK1,value.get());
}
// Field N14 Model Parameter n
if(coilCoolingCooledBeam.isModelParameternDefaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern,0.4);
}
else if((value = coilCoolingCooledBeam.modelParametern()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::ModelParametern,value.get());
}
// Field N16 Leaving Pipe Inside Diameter
if(coilCoolingCooledBeam.isLeavingPipeInsideDiameterDefaulted())
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::LeavingPipeInsideDiameter,0.0145);
}
else if((value = coilCoolingCooledBeam.leavingPipeInsideDiameter()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::LeavingPipeInsideDiameter,value.get());
}
}
else
{
LOG(Error,modelObject.briefDescription() << ": Could not translate cooling coil");
return boost::none;
}
// Field N15 Coefficient of Induction Kin
if(modelObject.isCoefficientofInductionKinDefaulted())
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::CoefficientofInductionKin,"autocalculate");
}
if((value = modelObject.coefficientofInductionKin()))
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_CooledBeamFields::CoefficientofInductionKin,value.get());
}
// Populate fields for AirDistributionUnit
if( boost::optional<ModelObject> outletNode = modelObject.outletModelObject() )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNode->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctVAVHeatAndCoolReheat( AirTerminalSingleDuctVAVHeatAndCoolReheat & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
boost::optional<double> value;
std::string baseName = modelObject.name().get();
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_VAV_HeatAndCool_Reheat);
idfObject.setName(baseName);
m_idfObjects.push_back(_airDistributionUnit);
m_idfObjects.push_back(idfObject);
auto coil = modelObject.reheatCoil();
auto _coil = translateAndMapModelObject(coil);
boost::optional<std::string> inletNodeName;
boost::optional<std::string> outletNodeName;
if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )
{
if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )
{
inletNodeName = inletNode->name().get();
}
}
if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )
{
if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )
{
outletNodeName = outletNode->name().get();
}
}
std::string damperOutletNodeName = baseName + " Damper Outlet Node";
if( outletNodeName && inletNodeName )
{
if( _coil ) {
if( _coil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
_coil->setString(Coil_Heating_GasFields::AirInletNodeName,damperOutletNodeName);
_coil->setString(Coil_Heating_GasFields::AirOutletNodeName,outletNodeName.get());
}
else if( _coil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_coil->setString(Coil_Heating_ElectricFields::AirInletNodeName,damperOutletNodeName);
_coil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,outletNodeName.get());
}
else if( _coil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_coil->setString(Coil_Heating_WaterFields::AirInletNodeName,damperOutletNodeName);
_coil->setString(Coil_Heating_WaterFields::AirOutletNodeName,outletNodeName.get());
}
}
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::AirOutletNodeName,outletNodeName.get());
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::AirInletNodeName,inletNodeName.get());
}
// AvailabilityScheduleName
if( auto schedule = modelObject.availabilitySchedule() ) {
if( auto _schedule = translateAndMapModelObject(schedule.get()) ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// DamperAirOutletNodeName
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::DamperAirOutletNodeName,damperOutletNodeName);
// AirInletNodeName
if( auto node = modelObject.inletModelObject() ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::AirInletNodeName,node->name().get());
}
// MaximumAirFlowRate
if( modelObject.isMaximumAirFlowRateAutosized() ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::MaximumAirFlowRate,"AutoSize");
} else if( (value = modelObject.maximumAirFlowRate()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::MaximumAirFlowRate,value.get());
}
// ZoneMinimumAirFlowFraction
if( (value = modelObject.zoneMinimumAirFlowFraction()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::ZoneMinimumAirFlowFraction,value.get());
}
if( _coil ) {
// ReheatCoilObjectType
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::ReheatCoilObjectType,_coil->iddObject().name());
// ReheatCoilName
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::ReheatCoilName,_coil->name().get());
}
// MaximumHotWaterorSteamFlowRate
if( modelObject.isMaximumHotWaterorSteamFlowRateAutosized() ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::MaximumHotWaterorSteamFlowRate,"AutoSize");
} else if( (value = modelObject.maximumHotWaterorSteamFlowRate()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::MaximumHotWaterorSteamFlowRate,value.get());
}
// MinimumHotWaterorSteamFlowRate
if( (value = modelObject.minimumHotWaterorSteamFlowRate()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::MinimumHotWaterorSteamFlowRate,value.get());
}
// AirOutletNodeName
if( auto node = modelObject.outletModelObject() ) {
idfObject.setString(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::AirOutletNodeName,node->name().get());
}
// ConvergenceTolerance
if( (value = modelObject.convergenceTolerance()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::ConvergenceTolerance,value.get());
}
// MaximumReheatAirTemperature
if( (value = modelObject.maximumReheatAirTemperature()) ) {
idfObject.setDouble(AirTerminal_SingleDuct_VAV_HeatAndCool_ReheatFields::MaximumReheatAirTemperature,value.get());
}
// Populate fields for AirDistributionUnit
if( boost::optional<ModelObject> outletNode = modelObject.outletModelObject() )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNode->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
