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::translateCoolingTowerSingleSpeed( CoolingTowerSingleSpeed & modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
// Create a new IddObjectType::Fan_ConstantVolume
IdfObject idfObject(IddObjectType::CoolingTower_SingleSpeed);
m_idfObjects.push_back(idfObject);
// Name
s = modelObject.name();
if(s)
{
idfObject.setName(*s);
}
// WaterInletNodeName
temp = modelObject.inletModelObject();
if(temp)
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::WaterInletNodeName,temp->name().get());
}
// WaterOutletNodeName
temp = modelObject.outletModelObject();
if(temp)
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::WaterOutletNodeName,temp->name().get());
}
// DesignWaterFlowRate
if( istringEqual(modelObject.performanceInputMethod(),"NominalCapacity") )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::DesignWaterFlowRate,"");
}
else
{
if( (d = modelObject.designWaterFlowRate()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::DesignWaterFlowRate,d.get());
}
else if( modelObject.isDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::DesignWaterFlowRate,"Autosize");
}
}
// DesignAirFlowRate
if( (d = modelObject.designAirFlowRate()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::DesignAirFlowRate,d.get());
}
else if( modelObject.isDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::DesignAirFlowRate,"Autosize");
}
// FanPoweratDesignAirFlowRate
if( (d = modelObject.fanPoweratDesignAirFlowRate()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::FanPoweratDesignAirFlowRate,d.get());
}
else if( modelObject.isFanPoweratDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::FanPoweratDesignAirFlowRate,"Autosize");
}
// UFactorTimesAreaValueatDesignAirFlowRate
if( (d = modelObject.uFactorTimesAreaValueatDesignAirFlowRate()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::UFactorTimesAreaValueatDesignAirFlowRate,d.get());
}
else if( modelObject.isUFactorTimesAreaValueatFreeConvectionAirFlowRateAutosized() )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::UFactorTimesAreaValueatDesignAirFlowRate,"Autosize");
}
// AirFlowRateinFreeConvectionRegime
if( (d = modelObject.airFlowRateinFreeConvectionRegime()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::AirFlowRateinFreeConvectionRegime,d.get());
}
else if( modelObject.isAirFlowRateinFreeConvectionRegimeAutosized() )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::AirFlowRateinFreeConvectionRegime,"Autosize");
}
// UFactorTimesAreaValueatFreeConvectionAirFlowRate
if( (d = modelObject.uFactorTimesAreaValueatFreeConvectionAirFlowRate()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::UFactorTimesAreaValueatFreeConvectionAirFlowRate,d.get());
}
else if( modelObject.isUFactorTimesAreaValueatFreeConvectionAirFlowRateAutosized() )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::UFactorTimesAreaValueatFreeConvectionAirFlowRate,"Autosize");
}
// PerformanceInputMethod
if( (s = modelObject.performanceInputMethod()) )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::PerformanceInputMethod,s.get());
}
// NominalCapacity
if( (d = modelObject.nominalCapacity()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::NominalCapacity,d.get());
}
// FreeConvectionCapacity
if( (d = modelObject.freeConvectionCapacity()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::FreeConvectionCapacity,d.get());
}
// BasinHeaterCapacity
if( (d = modelObject.basinHeaterCapacity()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::BasinHeaterCapacity,d.get());
}
// BasinHeaterSetpointTemperature
if( (d = modelObject.basinHeaterSetpointTemperature()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::BasinHeaterSetpointTemperature,d.get());
}
// BasinHeaterOperatingSchedule
if( (temp = modelObject.basinHeaterOperatingSchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::BasinHeaterOperatingScheduleName,_schedule->name().get());
}
}
// EvaporationLossMode
if( (s = modelObject.evaporationLossMode()) )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::EvaporationLossMode,s.get());
}
// EvaporationLossFactor
if( (d = modelObject.evaporationLossFactor()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::EvaporationLossFactor,d.get());
}
// DriftLossPercent
if( (d = modelObject.driftLossPercent()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::DriftLossPercent,d.get());
}
// BlowdownCalculationMode
if( (s = modelObject.blowdownCalculationMode()) )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::BlowdownCalculationMode,s.get());
}
// BlowdownConcentrationRatio
if( (d = modelObject.blowdownConcentrationRatio()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::BlowdownConcentrationRatio,d.get());
}
// BlowdownMakeupWaterUsageScheduleName
if( (temp = modelObject.blowdownMakeupWaterUsageSchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::BlowdownMakeupWaterUsageScheduleName,_schedule->name().get());
}
}
// CapacityControl
if( (s = modelObject.capacityControl()) )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::CapacityControl,s.get());
}
// NumberofCells
if( int n = modelObject.numberofCells() )
{
idfObject.setUnsigned(openstudio::CoolingTower_SingleSpeedFields::NumberofCells,n);
}
// CellControl
if( (s = modelObject.cellControl()) )
{
idfObject.setString(openstudio::CoolingTower_SingleSpeedFields::CellControl,s.get());
}
// CellMinimumWaterFlowRateFraction
if( (d = modelObject.cellMinimumWaterFlowRateFraction()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::CellMinimumWaterFlowRateFraction,d.get());
}
// CellMaximumWaterFlowRateFraction
if( (d = modelObject.cellMaximumWaterFlowRateFraction()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::CellMaximumWaterFlowRateFraction,d.get());
}
// SizingFactor
if( (d = modelObject.sizingFactor()) )
{
idfObject.setDouble(openstudio::CoolingTower_SingleSpeedFields::SizingFactor,d.get());
}
return boost::optional<IdfObject>(idfObject);
}
boost::optional<IdfObject> ForwardTranslator::translateHumidifierSteamElectric( HumidifierSteamElectric & modelObject )
{
OptionalDouble d;
OptionalModelObject temp;
// Name
IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::Humidifier_Steam_Electric, modelObject);
// Availability Schedule Name
if( (temp = modelObject.availabilitySchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(Humidifier_Steam_ElectricFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// Rated Capacity
if( modelObject.isRatedCapacityAutosized() ) {
idfObject.setString(Humidifier_Steam_ElectricFields::RatedCapacity,"Autosize");
} if( (d = modelObject.ratedCapacity()) ) {
idfObject.setDouble(Humidifier_Steam_ElectricFields::RatedCapacity,d.get());
}
// Rated Power
if( (d = modelObject.ratedPower()) )
{
idfObject.setDouble(Humidifier_Steam_ElectricFields::RatedPower,d.get());
}
else if( modelObject.isRatedPowerAutosized() )
{
idfObject.setString(Humidifier_Steam_ElectricFields::RatedPower,"Autosize");
}
// Rated Fan Power
if( (d = modelObject.ratedFanPower()) )
{
idfObject.setDouble(Humidifier_Steam_ElectricFields::RatedFanPower,d.get());
}
// Standby Power
if( (d = modelObject.standbyPower()) )
{
idfObject.setDouble(Humidifier_Steam_ElectricFields::StandbyPower,d.get());
}
// Air Inlet Node Name
temp = modelObject.inletModelObject();
if(temp)
{
idfObject.setString(Humidifier_Steam_ElectricFields::AirInletNodeName,temp->name().get());
}
// Air Outlet Node Name
temp = modelObject.outletModelObject();
if(temp)
{
idfObject.setString(Humidifier_Steam_ElectricFields::AirOutletNodeName,temp->name().get());
}
// Water Storage Tank Name
// not currently used
return idfObject;
}
boost::optional<IdfObject> ForwardTranslator::translateCoolingTowerVariableSpeed( CoolingTowerVariableSpeed & modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
IdfObject idfObject(IddObjectType::CoolingTower_VariableSpeed);
m_idfObjects.push_back(idfObject);
// Name
s = modelObject.name();
if(s)
{
idfObject.setName(*s);
}
// WaterInletNodeName
temp = modelObject.inletModelObject();
if(temp)
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::WaterInletNodeName,temp->name().get());
}
// WaterOutletNodeName
temp = modelObject.outletModelObject();
if(temp)
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::WaterOutletNodeName,temp->name().get());
}
// ModelType
if( s = modelObject.modelType() )
{
idfObject.setString(CoolingTower_VariableSpeedFields::ModelType,s.get());
}
// ModelCoefficient
if( boost::optional<ModelObject> mo = modelObject.modelCoefficient() )
{
if( boost::optional<IdfObject> _mo = translateAndMapModelObject(mo.get()) )
{
idfObject.setString(CoolingTower_VariableSpeedFields::ModelCoefficientName,_mo->name().get());
}
}
// DesignInletAirWetBulbTemperature
if( d = modelObject.designInletAirWetBulbTemperature() )
{
idfObject.setDouble(CoolingTower_VariableSpeedFields::DesignInletAirWetBulbTemperature,d.get());
}
// DesignApproachTemperature
if( d = modelObject.designApproachTemperature() )
{
idfObject.setDouble(CoolingTower_VariableSpeedFields::DesignApproachTemperature,d.get());
}
// DesignRangeTemperature
if( d = modelObject.designRangeTemperature() )
{
idfObject.setDouble(CoolingTower_VariableSpeedFields::DesignRangeTemperature,d.get());
}
// DesignWaterFlowRate
if( (d = modelObject.designWaterFlowRate()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::DesignWaterFlowRate,d.get());
}
else if( modelObject.isDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::DesignWaterFlowRate,"Autosize");
}
// DesignAirFlowRate
if( (d = modelObject.designAirFlowRate()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::DesignAirFlowRate,d.get());
}
else if( modelObject.isDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::DesignAirFlowRate,"Autosize");
}
// DesignFanPower
if( d = modelObject.designFanPower() )
{
idfObject.setDouble(CoolingTower_VariableSpeedFields::DesignFanPower,d.get());
}
else if( modelObject.isDesignFanPowerAutosized() )
{
idfObject.setString(CoolingTower_VariableSpeedFields::DesignFanPower,"Autosize");
}
// FanPowerRatioFunctionofAirFlowRateRatioCurve
if( boost::optional<CurveCubic> curve = modelObject.fanPowerRatioFunctionofAirFlowRateRatioCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(CoolingTower_VariableSpeedFields::FanPowerRatioFunctionofAirFlowRateRatioCurveName,_curve->name().get());
}
}
// MinimumAirFlowRateRatio
if( d = modelObject.minimumAirFlowRateRatio() )
{
idfObject.setDouble(CoolingTower_VariableSpeedFields::MinimumAirFlowRateRatio,d.get());
}
// FractionofTowerCapacityinFreeConvectionRegime
if( d = modelObject.fractionofTowerCapacityinFreeConvectionRegime() )
{
idfObject.setDouble(CoolingTower_VariableSpeedFields::FractionofTowerCapacityinFreeConvectionRegime,d.get());
}
// BasinHeaterCapacity
if( (d = modelObject.basinHeaterCapacity()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::BasinHeaterCapacity,d.get());
}
// BasinHeaterSetpointTemperature
if( (d = modelObject.basinHeaterSetpointTemperature()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::BasinHeaterSetpointTemperature,d.get());
}
// BasinHeaterOperatingSchedule
if( (temp = modelObject.basinHeaterOperatingSchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::BasinHeaterOperatingScheduleName,_schedule->name().get());
}
}
// EvaporationLossMode
if( (s = modelObject.evaporationLossMode()) )
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::EvaporationLossMode,s.get());
}
// EvaporationLossFactor
if( (d = modelObject.evaporationLossFactor()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::EvaporationLossFactor,d.get());
}
// DriftLossPercent
if( (d = modelObject.driftLossPercent()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::DriftLossPercent,d.get());
}
// BlowdownCalculationMode
if( (s = modelObject.blowdownCalculationMode()) )
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::BlowdownCalculationMode,s.get());
}
// BlowdownConcentrationRatio
if( (d = modelObject.blowdownConcentrationRatio()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::BlowdownConcentrationRatio,d.get());
}
// BlowdownMakeupWaterUsageScheduleName
if( (temp = modelObject.blowdownMakeupWaterUsageSchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::BlowdownMakeupWaterUsageScheduleName,_schedule->name().get());
}
}
// NumberofCells
if( boost::optional<int> n = modelObject.numberofCells() )
{
idfObject.setUnsigned(openstudio::CoolingTower_VariableSpeedFields::NumberofCells,n.get());
}
// CellControl
if( (s = modelObject.cellControl()) )
{
idfObject.setString(openstudio::CoolingTower_VariableSpeedFields::CellControl,s.get());
}
// CellMinimumWaterFlowRateFraction
if( (d = modelObject.cellMinimumWaterFlowRateFraction()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::CellMinimumWaterFlowRateFraction,d.get());
}
// CellMaximumWaterFlowRateFraction
if( (d = modelObject.cellMaximumWaterFlowRateFraction()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::CellMaximumWaterFlowRateFraction,d.get());
}
// SizingFactor
if( (d = modelObject.sizingFactor()) )
{
idfObject.setDouble(openstudio::CoolingTower_VariableSpeedFields::SizingFactor,d.get());
}
return boost::optional<IdfObject>(idfObject);
}
boost::optional<IdfObject> ForwardTranslator::translateEvaporativeFluidCoolerSingleSpeed( EvaporativeFluidCoolerSingleSpeed & modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
// Create a new IddObjectType::Evaporative_FluidCoolerSingleSpeed
IdfObject idfObject(IddObjectType::EvaporativeFluidCooler_SingleSpeed);
m_idfObjects.push_back(idfObject);
//Name
s = modelObject.name();
if(s)
{
idfObject.setName(*s);
}
// WaterInletNodeName
temp = modelObject.inletModelObject();
if(temp)
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::WaterInletNodeName,temp->name().get());
}
// WaterOutletNodeName
temp = modelObject.outletModelObject();
if(temp)
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::WaterOutletNodeName,temp->name().get());
}
// DesignAirFlowRate
if( (d = modelObject.designAirFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRate,d.get());
}
else if( modelObject.isDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRate,"Autosize");
}
// FanPoweratDesignAirFlowRate
if( (d = modelObject.fanPoweratDesignAirFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateFanPower,d.get());
}
else if( modelObject.isFanPoweratDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateFanPower,"Autosize");
}
// DesignWaterFlowRate
if( (d = modelObject.designWaterFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignWaterFlowRate,d.get());
}
else if( modelObject.isDesignWaterFlowRateAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignWaterFlowRate,"Autosize");
}
// DesignSprayWaterFlowRate
if( (d = modelObject.designSprayWaterFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignSprayWaterFlowRate,d.get());
}
// PerformanceInputMethod
if( (s = modelObject.performanceInputMethod()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::PerformanceInputMethod,s.get());
}
// OutdoorAirInletNodeName
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::OutdoorAirInletNodeName,"");
// StandardDesignCapacity
if( (d = modelObject.standardDesignCapacity()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::StandardDesignCapacity,d.get());
}
// UFactorTimesAreaValueatDesignAirFlowRate
if( (d = modelObject.ufactorTimesAreaValueatDesignAirFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateUfactorTimesAreaValue,d.get());
}
else if( modelObject.isUfactorTimesAreaValueatDesignAirFlowRateAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateUfactorTimesAreaValue,"Autosize");
}
// UserSpecifiedDesignCapacity
if( (d = modelObject.userSpecifiedDesignCapacity()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::UserSpecifiedDesignCapacity,d.get());
}
// DesignEnteringWaterTemperature
if( (d = modelObject.designEnteringWaterTemperature()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringWaterTemperature,d.get());
}
// DesignEnteringAirTemperature
if( (d = modelObject.designEnteringAirTemperature()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringAirTemperature,d.get());
}
// DesignEnteringAirWetbulbTemperature
if( (d = modelObject.designEnteringAirWetbulbTemperature()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringAirWetbulbTemperature,d.get());
}
// CapacityControl
if( (s = modelObject.capacityControl()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::CapacityControl,s.get());
}
// SizingFactor
if( (d = modelObject.sizingFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::SizingFactor,d.get());
}
// EvaporationLossMode
if( (s = modelObject.evaporationLossMode()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossMode,s.get());
}
// EvaporationLossFactor
if( (d = modelObject.evaporationLossFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossFactor,d.get());
}
// DriftLossPercent
if( (d = modelObject.driftLossPercent()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::DriftLossPercent,d.get());
}
// BlowdownCalculationMode
if( (s = modelObject.blowdownCalculationMode()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::BlowdownCalculationMode,s.get());
}
// BlowdownConcentrationRatio
if( (d = modelObject.blowdownConcentrationRatio()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_SingleSpeedFields::BlowdownConcentrationRatio,d.get());
}
// BlowdownMakeupWaterUsageScheduleName
if( (temp = modelObject.blowdownMakeupWaterUsageSchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::BlowdownMakeupWaterUsageScheduleName,_schedule->name().get());
}
}
// supplyWaterStorageTankName
//if( (s = modelObject.supplyWaterStorageTankName()) )
//{
// idfObject.setString(openstudio::EvaporativeFluidCooler_SingleSpeedFields::SupplyWaterStorageTankName,s.get());
//}
return boost::optional<IdfObject>(idfObject);
}
boost::optional<IdfObject> ForwardTranslator::translateEvaporativeFluidCoolerTwoSpeed( EvaporativeFluidCoolerTwoSpeed & modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
//Name
IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::EvaporativeFluidCooler_TwoSpeed, modelObject);
// WaterInletNodeName
temp = modelObject.inletModelObject();
if(temp) {
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::WaterInletNodeName,temp->name().get());
}
// WaterOutletNodeName
temp = modelObject.outletModelObject();
if(temp) {
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::WaterOutletNodeName,temp->name().get());
}
// HighFanSpeedAirFlowRate
if( modelObject.isHighFanSpeedAirFlowRateAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighFanSpeedAirFlowRate,"Autosize");
}
else if( (d = modelObject.highFanSpeedAirFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighFanSpeedAirFlowRate,d.get());
}
// HighFanSpeedFanPower
if( modelObject.isHighFanSpeedFanPowerAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighFanSpeedFanPower,"Autosize");
}
else if( (d = modelObject.highFanSpeedFanPower()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighFanSpeedFanPower,d.get());
}
// LowFanSpeedAirFlowRate
if( modelObject.isLowFanSpeedAirFlowRateAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedAirFlowRate,"Autocalculate");
}
else if( (d = modelObject.lowFanSpeedAirFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedAirFlowRate,d.get());
}
// LowFanSpeedAirFlowRateSizingFactor
if( (d = modelObject.lowFanSpeedAirFlowRateSizingFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedAirFlowRateSizingFactor,d.get());
}
// LowFanSpeedFanPower
if( modelObject.isLowFanSpeedFanPowerAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedFanPower,"Autocalculate");
}
else if( (d = modelObject.lowFanSpeedFanPower()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedFanPower,d.get());
}
// LowFanSpeedFanPowerSizingFactor
if( (d = modelObject.lowFanSpeedFanPowerSizingFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedFanPowerSizingFactor,d.get());
}
// DesignSprayWaterFlowRate
if( (d = modelObject.designSprayWaterFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::DesignSprayWaterFlowRate,d.get());
}
// PerformanceInputMethod
if( (s = modelObject.performanceInputMethod()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::PerformanceInputMethod,s.get());
}
// OutdoorAirInletNodeName
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::OutdoorAirInletNodeName,"");
// HeatRejectionCapacityandNominalCapacitySizingRatio
if( (d = modelObject.heatRejectionCapacityandNominalCapacitySizingRatio()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HeatRejectionCapacityandNominalCapacitySizingRatio,d.get());
}
// HighSpeedStandardDesignCapacity
if( (d = modelObject.highSpeedStandardDesignCapacity()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighSpeedStandardDesignCapacity,d.get());
}
// LowSpeedStandardDesignCapacity
if( modelObject.isLowSpeedStandardDesignCapacityAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowSpeedStandardDesignCapacity,"Autosize");
}
else if( (d = modelObject.lowSpeedStandardDesignCapacity()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowSpeedStandardDesignCapacity,d.get());
}
// LowSpeedStandardCapacitySizingFactor
if( (d = modelObject.lowSpeedStandardCapacitySizingFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowSpeedStandardCapacitySizingFactor,d.get());
}
// HighFanSpeedUfactorTimesAreaValue
if( modelObject.isHighFanSpeedUfactorTimesAreaValueAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighFanSpeedUfactorTimesAreaValue,"Autosize");
}
else if( (d = modelObject.highFanSpeedUfactorTimesAreaValue()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighFanSpeedUfactorTimesAreaValue,d.get());
}
// LowFanSpeedUfactorTimesAreaValue
if( modelObject.isLowFanSpeedUfactorTimesAreaValueAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedUfactorTimesAreaValue,"Autocalculate");
}
else if( (d = modelObject.lowFanSpeedUfactorTimesAreaValue()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedUfactorTimesAreaValue,d.get());
}
// LowFanSpeedUFactorTimesAreaSizingFactor
if( (d = modelObject.lowFanSpeedUFactorTimesAreaSizingFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowFanSpeedUFactorTimesAreaSizingFactor,d.get());
}
// DesignWaterFlowRate
if( modelObject.isDesignWaterFlowRateAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::DesignWaterFlowRate,"Autosize");
}
else if( (d = modelObject.designWaterFlowRate()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::DesignWaterFlowRate,d.get());
}
// HighSpeedUserSpecifiedDesignCapacity
if( (d = modelObject.highSpeedUserSpecifiedDesignCapacity()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighSpeedUserSpecifiedDesignCapacity,d.get());
}
// LowSpeedUserSpecifiedDesignCapacity
if( modelObject.isLowSpeedUserSpecifiedDesignCapacityAutosized() )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowSpeedUserSpecifiedDesignCapacity,"Autocalculate");
}
else if( (d = modelObject.lowSpeedUserSpecifiedDesignCapacity()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowSpeedUserSpecifiedDesignCapacity,d.get());
}
// LowSpeedUserSpecifiedDesignCapacitySizingFactor
if( (d = modelObject.lowSpeedUserSpecifiedDesignCapacitySizingFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::LowSpeedUserSpecifiedDesignCapacitySizingFactor,d.get());
}
// DesignEnteringWaterTemperature
if( (d = modelObject.designEnteringWaterTemperature()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::DesignEnteringWaterTemperature,d.get());
}
// DesignEnteringAirTemperature
if( (d = modelObject.designEnteringAirTemperature()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::DesignEnteringAirTemperature,d.get());
}
// DesignEnteringAirWetbulbTemperature
if( (d = modelObject.designEnteringAirWetbulbTemperature()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::DesignEnteringAirWetbulbTemperature,d.get());
}
// HighSpeedSizingFactor
if( (d = modelObject.highSpeedSizingFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::HighSpeedSizingFactor,d.get());
}
// EvaporationLossMode
if( (s = modelObject.evaporationLossMode()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::EvaporationLossMode,s.get());
}
// EvaporationLossFactor
if( (d = modelObject.evaporationLossFactor()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::EvaporationLossFactor,d.get());
}
// DriftLossPercent
if( (d = modelObject.driftLossPercent()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::DriftLossPercent,d.get());
}
// BlowdownCalculationMode
if( (s = modelObject.blowdownCalculationMode()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::BlowdownCalculationMode,s.get());
}
// BlowdownConcentrationRatio
if( (d = modelObject.blowdownConcentrationRatio()) )
{
idfObject.setDouble(openstudio::EvaporativeFluidCooler_TwoSpeedFields::BlowdownConcentrationRatio,d.get());
}
// BlowdownMakeupWaterUsageScheduleName
if( (temp = modelObject.blowdownMakeupWaterUsageSchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(openstudio::EvaporativeFluidCooler_TwoSpeedFields::BlowdownMakeupWaterUsageScheduleName,_schedule->name().get());
}
}
// SupplyWaterStorageTankName
return idfObject;
}
