boost::optional<IdfObject> ForwardTranslator::translateAirLoopHVACZoneMixer( AirLoopHVACZoneMixer & modelObject ) { std::string s; OptionalString optS; OptionalModelObject temp; IdfObject idfObject(openstudio::IddObjectType::AirLoopHVAC_ZoneMixer); m_idfObjects.push_back(idfObject); /////////////////////////////////////////////////////////////////////////// // Field: Name //////////////////////////////////////////////////////////// s = modelObject.name().get(); idfObject.setName(s); //////////////////////////////////////////////////////////////////////////// // Field: Outlet Node Name ///////////////////////////////////////////////// temp = modelObject.outletModelObject(); if(temp) { optS = temp->name(); if(optS) idfObject.setString(openstudio::AirLoopHVAC_ZoneMixerFields::OutletNodeName,*optS); } /////////////////////////////////////////////////////////////////////////// // Field: Inlet 1-N Node Name /////////////////////////////////////////////// std::vector<ModelObject> inletModelObjects = modelObject.inletModelObjects(); int i = 2; for( std::vector<ModelObject>::iterator it = inletModelObjects.begin(); it < inletModelObjects.end(); ++it ) { optS = it->name(); if(optS) { idfObject.setString(i,*optS); } i++; } return boost::optional<IdfObject>(idfObject); }
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::translateFanVariableVolume( FanVariableVolume& modelObject ) { OptionalString s; OptionalDouble d; OptionalModelObject temp; // Create a new IddObjectType::Fan_VariableVolume IdfObject idfObject(IddObjectType::Fan_VariableVolume); m_idfObjects.push_back(idfObject); // Field: Name //////////////////////////////////////////////////////////// s = modelObject.name(); if(s) { idfObject.setName(*s); } // AvailabilityScheduleName if( boost::optional<model::AirLoopHVAC> airLoopHVAC = modelObject.airLoopHVAC() ) { Schedule sched = airLoopHVAC->availabilitySchedule(); boost::optional<IdfObject> schedIdf = translateAndMapModelObject(sched); if( schedIdf ) { idfObject.setString(Fan_VariableVolumeFields::AvailabilityScheduleName,schedIdf->name().get()); } } else { Schedule sched = modelObject.availabilitySchedule(); translateAndMapModelObject(sched); idfObject.setString(Fan_VariableVolumeFields::AvailabilityScheduleName,sched.name().get()); } // Fan Efficiency ///////////////////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_VariableVolumeFields::FanTotalEfficiency,modelObject.fanEfficiency()); // Pressure Rise ////////////////////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_VariableVolumeFields::PressureRise,modelObject.pressureRise()); // Maximum Flow Rate ////////////////////////////////////////////////////// if( modelObject.isMaximumFlowRateAutosized() ) { idfObject.setString(openstudio::Fan_VariableVolumeFields::MaximumFlowRate,"AutoSize"); } else if( (d = modelObject.maximumFlowRate()) ) { idfObject.setDouble(openstudio::Fan_VariableVolumeFields::MaximumFlowRate,d.get()); } // FanPowerMinimumFlowRateInputMethod if( (s = modelObject.fanPowerMinimumFlowRateInputMethod()) ) { idfObject.setString(Fan_VariableVolumeFields::FanPowerMinimumFlowRateInputMethod,s.get()); } // FanPowerMinimumFlowFraction if( (d = modelObject.fanPowerMinimumFlowFraction()) ) { idfObject.setDouble(Fan_VariableVolumeFields::FanPowerMinimumFlowFraction,d.get()); } // FanPowerMinimumAirFlowRate if( (d = modelObject.fanPowerMinimumAirFlowRate()) ) { idfObject.setDouble(Fan_VariableVolumeFields::FanPowerMinimumAirFlowRate,d.get()); } // Motor Efficiency /////////////////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_VariableVolumeFields::MotorEfficiency,modelObject.motorEfficiency()); // FanPowerCoefficient1 if( (d = modelObject.fanPowerCoefficient1()) ) { idfObject.setDouble(Fan_VariableVolumeFields::FanPowerCoefficient1,d.get()); } // FanPowerCoefficient2 if( (d = modelObject.fanPowerCoefficient2()) ) { idfObject.setDouble(Fan_VariableVolumeFields::FanPowerCoefficient2,d.get()); } // FanPowerCoefficient3 if( (d = modelObject.fanPowerCoefficient3()) ) { idfObject.setDouble(Fan_VariableVolumeFields::FanPowerCoefficient3,d.get()); } // FanPowerCoefficient4 if( (d = modelObject.fanPowerCoefficient4()) ) { idfObject.setDouble(Fan_VariableVolumeFields::FanPowerCoefficient4,d.get()); } // FanPowerCoefficient5 if( (d = modelObject.fanPowerCoefficient5()) ) { idfObject.setDouble(Fan_VariableVolumeFields::FanPowerCoefficient5,d.get()); } // Motor In Airstream Fraction //////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_VariableVolumeFields::MotorInAirstreamFraction,modelObject.motorInAirstreamFraction()); // Air Inlet Node Name //////////////////////////////////////////////////// temp = modelObject.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::Fan_VariableVolumeFields::AirInletNodeName,*s); } } // Air Outlet Node Name /////////////////////////////////////////////////// temp = modelObject.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::Fan_VariableVolumeFields::AirOutletNodeName,*s); } } return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateCoilCoolingDXTwoSpeedWithoutUnitary( model::CoilCoolingDXTwoSpeed & modelObject ) { //setup two boost optionals to use to store get method returns boost::optional<std::string> s; boost::optional<double> d; //create the IdfObject that will be the coil IdfObject idfObject(IddObjectType::Coil_Cooling_DX_TwoSpeed); //Name m_idfObjects.push_back(idfObject); s = modelObject.name(); if( s ) { idfObject.setName(*s); } // A2 , \field Availability Schedule Name Schedule sched = modelObject.getAvailabilitySchedule(); translateAndMapModelObject(sched); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::AvailabilityScheduleName, sched.name().get() ); // N1 , \field Rated High Speed Total Cooling Capacity d = modelObject.getRatedHighSpeedTotalCoolingCapacity(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedTotalCoolingCapacity,*d); } else { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedTotalCoolingCapacity,"Autosize"); } // N2 , \field Rated High Speed Sensible Heat Ratio d = modelObject.getRatedHighSpeedSensibleHeatRatio(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedSensibleHeatRatio,*d); } else { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedSensibleHeatRatio,"Autosize"); } // N3 , \field Rated High Speed COP d = modelObject.getRatedHighSpeedCOP(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedCOP,*d); } // N4 , \field Rated High Speed Air Flow Rate d = modelObject.getRatedHighSpeedAirFlowRate(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedAirFlowRate,*d); } else { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedAirFlowRate,"Autosize"); } //A3 , \field Air Inlet Node Name OptionalModelObject omo = modelObject.inletModelObject(); if( omo ) { translateAndMapModelObject(*omo); s = omo->name(); if(s) { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::AirInletNodeName,*s ); } } //A4 , \field Air Outlet Node Name omo= modelObject.outletModelObject(); if( omo ) { translateAndMapModelObject(*omo); s = omo->name(); if(s) { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::AirOutletNodeName,*s); } } // A5 , \field Total Cooling Capacity Function of Temperature Curve Name Curve cb = modelObject.getTotalCoolingCapacityFunctionOfTemperatureCurve(); translateAndMapModelObject(cb); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::TotalCoolingCapacityFunctionofTemperatureCurveName, cb.name().get()); // A6 , \field Total Cooling Capacity Function of Flow Fraction Curve Name cb = modelObject.getTotalCoolingCapacityFunctionOfFlowFractionCurve(); translateAndMapModelObject(cb); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::TotalCoolingCapacityFunctionofFlowFractionCurveName, cb.name().get()); // A7 , \field Energy Input Ratio Function of Temperature Curve Name cb =modelObject.getEnergyInputRatioFunctionOfTemperatureCurve(); translateAndMapModelObject(cb); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofTemperatureCurveName, cb.name().get()); // A8 , \field Energy Input Ratio Function of Flow Fraction Curve Name Curve cq = modelObject.getEnergyInputRatioFunctionOfFlowFractionCurve(); translateAndMapModelObject(cq); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofFlowFractionCurveName, cq.name().get()); // A9 , \field Part Load Fraction Correlation Curve Name cq = modelObject.getPartLoadFractionCorrelationCurve(); translateAndMapModelObject(cq); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::PartLoadFractionCorrelationCurveName, cq.name().get()); // N5 , \field Rated Low Speed Total Cooling Capacity d = modelObject.getRatedLowSpeedTotalCoolingCapacity(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedTotalCoolingCapacity,*d); } else { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedTotalCoolingCapacity,"Autosize"); } // N6 , \field Rated Low Speed Sensible Heat Ratio d = modelObject.getRatedLowSpeedSensibleHeatRatio(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedSensibleHeatRatio,*d); } else { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedSensibleHeatRatio,"Autosize"); } // N7 , \field Rated Low Speed COP d = modelObject.getRatedLowSpeedCOP(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedCOP,*d); } // N8 , \field Rated Low Speed Air Flow Rate d = modelObject.getRatedLowSpeedAirFlowRate(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedAirFlowRate,*d); } else { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedAirFlowRate,"Autosize"); } // A10, \field Low Speed Total Cooling Capacity Function of Temperature Curve Name cq = modelObject.getLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(); translateAndMapModelObject(cq); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::LowSpeedTotalCoolingCapacityFunctionofTemperatureCurveName, cq.name().get()); // A11, \field Low Speed Energy Input Ratio Function of Temperature Curve Name cq = modelObject.getLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(); translateAndMapModelObject(cq); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEnergyInputRatioFunctionofTemperatureCurveName, cq.name().get()); // A12, \field Condenser Air Inlet Node Name s=modelObject.getCondenserAirInletNodeName(); if(s) { idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::CondenserAirInletNodeName,*s); } // A13, \field Condenser Type idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::CondenserType,modelObject.getCondenserType()); // N9, \field High Speed Evaporative Condenser Effectiveness d=modelObject.getHighSpeedEvaporativeCondenserEffectiveness(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserEffectiveness,*d); } // N10, \field High Speed Evaporative Condenser Air Flow Rate d=modelObject.getHighSpeedEvaporativeCondenserAirFlowRate(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserAirFlowRate,*d); } // N11, \field High Speed Evaporative Condenser Pump Rated Power Consumption d=modelObject.getHighSpeedEvaporativeCondenserPumpRatedPowerConsumption(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserPumpRatedPowerConsumption,*d); } // N12, \field Low Speed Evaporative Condenser Effectiveness d=modelObject.getLowSpeedEvaporativeCondenserEffectiveness(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserEffectiveness,*d); } // N13, \field Low Speed Evaporative Condenser Air Flow Rate d=modelObject.getLowSpeedEvaporativeCondenserAirFlowRate(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserAirFlowRate,*d); } // N14, \field Low Speed Evaporative Condenser Pump Rated Power Consumption d=modelObject.getLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserPumpRatedPowerConsumption,*d); } //TODO // A14, \field Supply Water Storage Tank Name //getSupplyWaterStorageTankName //TODO // A15, \field Condensate Collection Water Storage Tank Name //getCondensateCollectionWaterStorageTankName // N15, \field Basin Heater Capacity d=modelObject.getBasinHeaterCapacity(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::BasinHeaterCapacity,*d); } // N16, \field Basin Heater Setpoint Temperature d=modelObject.getBasinHeaterSetpointTemperature(); if(d) { idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::BasinHeaterSetpointTemperature,*d); } // A16; \field Basin Heater Operating Schedule Name OptionalSchedule os = modelObject.getBasinHeaterOperatingSchedule(); if( os ) { translateAndMapModelObject(*os); idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::BasinHeaterOperatingScheduleName, os->name().get() ); } return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateAirConditionerVariableRefrigerantFlow( AirConditionerVariableRefrigerantFlow & modelObject ) { boost::optional<std::string> s; boost::optional<double> value; IdfObject idfObject(IddObjectType::AirConditioner_VariableRefrigerantFlow); m_idfObjects.push_back(idfObject); // Name s = modelObject.name(); if( s ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatPumpName,*s); } // AvailabilityScheduleName if( boost::optional<model::Schedule> schedule = modelObject.availabilitySchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::AvailabilityScheduleName,_schedule->name().get()); } } // RatedTotalCoolingCapacity if( modelObject.isRatedTotalCoolingCapacityAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::GrossRatedTotalCoolingCapacity,"Autosize"); } else if( (value = modelObject.ratedTotalCoolingCapacity()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::GrossRatedTotalCoolingCapacity,value.get()); } // RatedCoolingCOP if( (value = modelObject.ratedCoolingCOP()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::GrossRatedCoolingCOP,value.get()); } // MinimumOutdoorTemperatureinCoolingMode if( (value = modelObject.minimumOutdoorTemperatureinCoolingMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinCoolingMode,value.get()); } // MaximumOutdoorTemperatureinCoolingMode if( (value = modelObject.maximumOutdoorTemperatureinCoolingMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinCoolingMode,value.get()); } // CoolingCapacityRatioModifierFunctionofLowTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingCapacityRatioModifierFunctionofLowTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCapacityRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get()); } } // CoolingCapacityRatioBoundaryCurveName if( boost::optional<model::CurveCubic> curve = modelObject.coolingCapacityRatioBoundaryCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCapacityRatioBoundaryCurveName,_curve->name().get()); } } // CoolingCapacityRatioModifierFunctionofHighTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingCapacityRatioModifierFunctionofHighTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCapacityRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get()); } } // CoolingEnergyInputRatioModifierFunctionofLowTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofLowTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get()); } } // CoolingEnergyInputRatioBoundaryCurveName if( boost::optional<model::CurveCubic> curve = modelObject.coolingEnergyInputRatioBoundaryCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioBoundaryCurveName,_curve->name().get()); } } // CoolingEnergyInputRatioModifierFunctionofHighTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofHighTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get()); } } // CoolingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName if( boost::optional<model::CurveCubic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName,_curve->name().get()); } } // CoolingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName if( boost::optional<model::CurveCubic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName,_curve->name().get()); } } // CoolingCombinationRatioCorrectionFactorCurveName if( boost::optional<model::CurveCubic> curve = modelObject.coolingCombinationRatioCorrectionFactorCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCombinationRatioCorrectionFactorCurveName,_curve->name().get()); } } // CoolingPartLoadFractionCorrelationCurveName if( boost::optional<model::CurveCubic> curve = modelObject.coolingPartLoadFractionCorrelationCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingPartLoadFractionCorrelationCurveName,_curve->name().get()); } } // RatedTotalHeatingCapacity if( modelObject.isRatedTotalHeatingCapacityAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::GrossRatedHeatingCapacity,"Autosize"); } else if( (value = modelObject.ratedTotalHeatingCapacity()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::GrossRatedHeatingCapacity,value.get()); } // RatedTotalHeatingCapacitySizingRatio if( (value = modelObject.ratedTotalHeatingCapacitySizingRatio()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatedHeatingCapacitySizingRatio,value.get()); } // RatedHeatingCOP if( (value = modelObject.ratedHeatingCOP()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::GrossRatedHeatingCOP,value.get()); } // MinimumOutdoorTemperatureinHeatingMode if( (value = modelObject.minimumOutdoorTemperatureinHeatingMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinHeatingMode,value.get()); } // MaximumOutdoorTemperatureinHeatingMode if( (value = modelObject.maximumOutdoorTemperatureinHeatingMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinHeatingMode,value.get()); } // HeatingCapacityRatioModifierFunctionofLowTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingCapacityRatioModifierFunctionofLowTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCapacityRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get()); } } // HeatingCapacityRatioBoundaryCurveName if( boost::optional<model::CurveCubic> curve = modelObject.heatingCapacityRatioBoundaryCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCapacityRatioBoundaryCurveName,_curve->name().get()); } } // HeatingCapacityRatioModifierFunctionofHighTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingCapacityRatioModifierFunctionofHighTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCapacityRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get()); } } // HeatingEnergyInputRatioModifierFunctionofLowTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofLowTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get()); } } // HeatingEnergyInputRatioBoundaryCurveName if( boost::optional<model::CurveCubic> curve = modelObject.heatingEnergyInputRatioBoundaryCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioBoundaryCurveName,_curve->name().get()); } } // HeatingEnergyInputRatioModifierFunctionofHighTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofHighTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get()); } } // HeatingPerformanceCurveOutdoorTemperatureType if( (s = modelObject.heatingPerformanceCurveOutdoorTemperatureType()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingPerformanceCurveOutdoorTemperatureType,s.get()); } // HeatingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName if( boost::optional<model::CurveCubic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName,_curve->name().get()); } } // HeatingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName if( boost::optional<model::CurveCubic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName,_curve->name().get()); } } // HeatingCombinationRatioCorrectionFactorCurveName if( boost::optional<model::CurveCubic> curve = modelObject.heatingCombinationRatioCorrectionFactorCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCombinationRatioCorrectionFactorCurveName,_curve->name().get()); } } // HeatingPartLoadFractionCorrelationCurveName if( boost::optional<model::CurveCubic> curve = modelObject.heatingPartLoadFractionCorrelationCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingPartLoadFractionCorrelationCurveName,_curve->name().get()); } } // MinimumHeatPumpPartLoadRatio if( (value = modelObject.minimumHeatPumpPartLoadRatio()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumHeatPumpPartLoadRatio,value.get()); } // ZoneNameforMasterThermostatLocation if( boost::optional<model::ThermalZone> zone = modelObject.zoneforMasterThermostatLocation() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ZoneNameforMasterThermostatLocation,zone->name().get()); } // MasterThermostatPriorityControlType if( (s = modelObject.masterThermostatPriorityControlType()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::MasterThermostatPriorityControlType,s.get()); } // ThermostatPriorityScheduleName if( boost::optional<model::Schedule> schedule = modelObject.thermostatPrioritySchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ThermostatPriorityScheduleName,_schedule->name().get()); } } // HeatPumpWasteHeatRecovery if( modelObject.heatPumpWasteHeatRecovery() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatPumpWasteHeatRecovery,"Yes"); } else { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatPumpWasteHeatRecovery,"No"); } // EquivalentPipingLengthusedforPipingCorrectionFactorinCoolingMode if( (value = modelObject.equivalentPipingLengthusedforPipingCorrectionFactorinCoolingMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EquivalentPipingLengthusedforPipingCorrectionFactorinCoolingMode,value.get()); } // VerticalHeightusedforPipingCorrectionFactor if( (value = modelObject.verticalHeightusedforPipingCorrectionFactor()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::VerticalHeightusedforPipingCorrectionFactor,value.get()); } // PipingCorrectionFactorforLengthinCoolingModeCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.pipingCorrectionFactorforLengthinCoolingModeCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforLengthinCoolingModeCurveName,_curve->name().get()); } } // PipingCorrectionFactorforHeightinCoolingModeCoefficient if( (value = modelObject.pipingCorrectionFactorforHeightinCoolingModeCoefficient()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforHeightinCoolingModeCoefficient,value.get()); } // EquivalentPipingLengthusedforPipingCorrectionFactorinHeatingMode if( (value = modelObject.equivalentPipingLengthusedforPipingCorrectionFactorinHeatingMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EquivalentPipingLengthusedforPipingCorrectionFactorinHeatingMode,value.get()); } // PipingCorrectionFactorforLengthinHeatingModeCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.pipingCorrectionFactorforLengthinHeatingModeCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforLengthinHeatingModeCurveName,_curve->name().get()); } } // PipingCorrectionFactorforHeightinHeatingModeCoefficient if( (value = modelObject.pipingCorrectionFactorforHeightinHeatingModeCoefficient()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforHeightinHeatingModeCoefficient,value.get()); } // CrankcaseHeaterPowerperCompressor if( (value = modelObject.crankcaseHeaterPowerperCompressor()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::CrankcaseHeaterPowerperCompressor,value.get()); } // NumberofCompressors { int number = modelObject.numberofCompressors(); idfObject.setUnsigned(AirConditioner_VariableRefrigerantFlowFields::NumberofCompressors,(unsigned)number); } // RatioofCompressorSizetoTotalCompressorCapacity if( (value = modelObject.ratioofCompressorSizetoTotalCompressorCapacity()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatioofCompressorSizetoTotalCompressorCapacity,value.get()); } // MaximumOutdoorDrybulbTemperatureforCrankcaseHeater if( (value = modelObject.maximumOutdoorDrybulbTemperatureforCrankcaseHeater()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeater,value.get()); } // DefrostStrategy if( (s = modelObject.defrostStrategy()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::DefrostStrategy,s.get()); } // DefrostControl if( (s = modelObject.defrostControl()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::DefrostControl,s.get()); } // DefrostEnergyInputRatioModifierFunctionofTemperatureCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.defrostEnergyInputRatioModifierFunctionofTemperatureCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::DefrostEnergyInputRatioModifierFunctionofTemperatureCurveName,_curve->name().get()); } } // DefrostTimePeriodFraction if( (value = modelObject.defrostTimePeriodFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::DefrostTimePeriodFraction,value.get()); } // ResistiveDefrostHeaterCapacity if( modelObject.isResistiveDefrostHeaterCapacityAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ResistiveDefrostHeaterCapacity,"Autosize"); } else if( (value = modelObject.resistiveDefrostHeaterCapacity()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::ResistiveDefrostHeaterCapacity,value.get()); } // MaximumOutdoorDrybulbTemperatureforDefrostOperation if( (value = modelObject.maximumOutdoorDrybulbTemperatureforDefrostOperation()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorDrybulbTemperatureforDefrostOperation,value.get()); } // CondenserInletNodeName if( boost::optional<model::ModelObject> mo = modelObject.inletModelObject() ) { if( boost::optional<IdfObject> _mo = translateAndMapModelObject(mo.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserInletNodeName,_mo->name().get()); } } // CondenserOutletNodeName if( boost::optional<model::ModelObject> mo = modelObject.outletModelObject() ) { if( boost::optional<IdfObject> _mo = translateAndMapModelObject(mo.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserOutletNodeName,_mo->name().get()); } } // WaterCondenserVolumeFlowRate if( modelObject.isWaterCondenserVolumeFlowRateAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,"Autosize"); } else if( (value = modelObject.waterCondenserVolumeFlowRate()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,value.get()); } // EvaporativeCondenserEffectiveness if( (value = modelObject.evaporativeCondenserEffectiveness()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserEffectiveness,value.get()); } // EvaporativeCondenserAirFlowRate if( modelObject.isEvaporativeCondenserAirFlowRateAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,"Autosize"); } else if( (value = modelObject.evaporativeCondenserAirFlowRate()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,value.get()); } // EvaporativeCondenserPumpRatedPowerConsumption if( modelObject.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,"Autosize"); } else if( ( value = modelObject.evaporativeCondenserPumpRatedPowerConsumption()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,value.get()); } // BasinHeaterCapacity if( (value = modelObject.basinHeaterCapacity()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterCapacity,value.get()); } // BasinHeaterSetpointTemperature if( (value = modelObject.basinHeaterSetpointTemperature()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterSetpointTemperature,value.get()); } // BasinHeaterOperatingScheduleName if( boost::optional<model::Schedule> schedule = modelObject.basinHeaterOperatingSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterOperatingScheduleName,_schedule->name().get()); } } // FuelType if( (s = modelObject.fuelType()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::FuelType,s.get()); } // MinimumOutdoorTemperatureinHeatRecoveryMode if( (value = modelObject.minimumOutdoorTemperatureinHeatRecoveryMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinHeatRecoveryMode,value.get()); } // MaximumOutdoorTemperatureinHeatRecoveryMode if( (value = modelObject.maximumOutdoorTemperatureinHeatingMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinHeatRecoveryMode,value.get()); } // HeatRecoveryCoolingCapacityModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingCapacityModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryCoolingCapacityFraction if( (value = modelObject.initialHeatRecoveryCoolingEnergyFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingCapacityFraction,value.get()); } // HeatRecoveryCoolingCapacityTimeConstant if( (value = modelObject.heatRecoveryCoolingCapacityTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityTimeConstant,value.get()); } // HeatRecoveryCoolingEnergyModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingEnergyModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryCoolingEnergyFraction if( (value = modelObject.initialHeatRecoveryCoolingEnergyFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingEnergyFraction,value.get()); } // HeatRecoveryCoolingEnergyTimeConstant if( (value = modelObject.heatRecoveryCoolingEnergyTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyTimeConstant,value.get()); } // HeatRecoveryHeatingCapacityModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingCapacityModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryHeatingCapacityFraction if( (value = modelObject.initialHeatRecoveryHeatingCapacityFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingCapacityFraction,value.get()); } // HeatRecoveryHeatingCapacityTimeConstant if( (value = modelObject.heatRecoveryHeatingCapacityTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityTimeConstant,value.get()); } // HeatRecoveryHeatingEnergyModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingEnergyModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryHeatingEnergyFraction if( (value = modelObject.initialHeatRecoveryHeatingEnergyFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingEnergyFraction,value.get()); } // HeatRecoveryHeatingEnergyTimeConstant if( (value = modelObject.heatRecoveryHeatingEnergyTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyTimeConstant,value.get()); } // Terminal Unit List IdfObject _zoneTerminalUnitList(IddObjectType::ZoneTerminalUnitList); std::string terminalUnitListName = modelObject.name().get() + " Terminal List"; _zoneTerminalUnitList.setString(ZoneTerminalUnitListFields::ZoneTerminalUnitListName,terminalUnitListName); idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ZoneTerminalUnitListName,terminalUnitListName); m_idfObjects.push_back(_zoneTerminalUnitList); std::vector<ZoneHVACTerminalUnitVariableRefrigerantFlow> terminals = modelObject.terminals(); for( auto & terminal : terminals ) { boost::optional<IdfObject> _terminal = translateAndMapModelObject(terminal); OS_ASSERT(_terminal); IdfExtensibleGroup eg = _zoneTerminalUnitList.pushExtensibleGroup(); eg.setString(ZoneTerminalUnitListExtensibleFields::ZoneTerminalUnitName,_terminal->name().get()); } // CondenserType if( modelObject.plantLoop() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserType,"WaterCooled"); } else { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserType,"AirCooled"); } // CondenserInletNodeName OptionalModelObject omo = modelObject.inletModelObject(); if( omo ) { translateAndMapModelObject(*omo); s = omo->name(); if(s) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserInletNodeName,*s ); } } // CondenserOutletNodeName omo = modelObject.outletModelObject(); if( omo ) { translateAndMapModelObject(*omo); s = omo->name(); if(s) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserOutletNodeName,*s ); } } // WaterCondenserVolumeFlowRate if( modelObject.isWaterCondenserVolumeFlowRateAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,"Autosize"); } else if( (value = modelObject.waterCondenserVolumeFlowRate()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,value.get()); } // EvaporativeCondenserEffectiveness if( (value = modelObject.evaporativeCondenserEffectiveness()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserEffectiveness,value.get()); } // EvaporativeCondenserAirFlowRate if( modelObject.isEvaporativeCondenserAirFlowRateAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,"Autosize"); } else if( (value = modelObject.evaporativeCondenserAirFlowRate()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,value.get()); } // EvaporativeCondenserPumpRatedPowerConsumption if( modelObject.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,"Autosize"); } else if( (value = modelObject.evaporativeCondenserPumpRatedPowerConsumption()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,value.get()); } // BasinHeaterCapacity if( (value = modelObject.basinHeaterCapacity()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterCapacity,value.get()); } // BasinHeaterSetpointTemperature if( (value = modelObject.basinHeaterSetpointTemperature()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterSetpointTemperature,value.get()); } // BasinHeaterOperatingScheduleName if( boost::optional<model::Schedule> schedule = modelObject.basinHeaterOperatingSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterOperatingScheduleName,_schedule->name().get()); } } // FuelType if( (s = modelObject.fuelType()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::FuelType,s.get()); } // MinimumOutdoorTemperatureinHeatRecoveryMode if( (value = modelObject.minimumOutdoorTemperatureinHeatRecoveryMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinHeatRecoveryMode,value.get()); } // MaximumOutdoorTemperatureinHeatRecoveryMode if( (value = modelObject.maximumOutdoorTemperatureinHeatRecoveryMode()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinHeatRecoveryMode,value.get()); } // HeatRecoveryCoolingCapacityModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingCapacityModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryCoolingCapacityFraction if( (value = modelObject.initialHeatRecoveryCoolingCapacityFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingCapacityFraction,value.get()); } // HeatRecoveryCoolingCapacityTimeConstant if( (value = modelObject.heatRecoveryCoolingEnergyTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityTimeConstant,value.get()); } // HeatRecoveryCoolingEnergyModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingEnergyModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryCoolingEnergyFraction if( (value = modelObject.initialHeatRecoveryCoolingEnergyFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingEnergyFraction,value.get()); } // HeatRecoveryCoolingEnergyTimeConstant if( (value = modelObject.heatRecoveryCoolingEnergyTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyTimeConstant,value.get()); } // HeatRecoveryHeatingCapacityModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingCapacityModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryHeatingCapacityFraction if( (value = modelObject.initialHeatRecoveryHeatingCapacityFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingCapacityFraction,value.get()); } // HeatRecoveryHeatingCapacityTimeConstant if( (value = modelObject.heatRecoveryHeatingCapacityTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityTimeConstant,value.get()); } // HeatRecoveryHeatingEnergyModifierCurveName if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingEnergyModifierCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyModifierCurveName,_curve->name().get()); } } // InitialHeatRecoveryHeatingEnergyFraction if( (value = modelObject.initialHeatRecoveryHeatingEnergyFraction()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingEnergyFraction,value.get()); } // HeatRecoveryHeatingEnergyTimeConstant if( (value = modelObject.heatRecoveryHeatingEnergyTimeConstant()) ) { idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyTimeConstant,value.get()); } return 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::translateRefrigerationCondenserWaterCooled( RefrigerationCondenserWaterCooled & modelObject ) { OptionalModelObject temp; OptionalString optS; boost::optional<std::string> s; boost::optional<double> d; // Name IdfObject waterCooled = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_Condenser_WaterCooled, modelObject); // Rated Effective Total Heat Rejection Rate d = modelObject.ratedEffectiveTotalHeatRejectionRate(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::RatedEffectiveTotalHeatRejectionRate,d.get()); } // Rated Condensing Temperature d = modelObject.ratedCondensingTemperature(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::RatedCondensingTemperature,d.get()); } // Rated Subcooling Temperature Difference d = modelObject.ratedSubcoolingTemperatureDifference(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::RatedSubcoolingTemperatureDifference,d.get()); } // Rated Water Inlet Temperature d = modelObject.ratedWaterInletTemperature(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::RatedWaterInletTemperature,d.get()); } // Water Inlet Node Name if( (temp = modelObject.inletModelObject()) ) { if(temp->name()) { waterCooled.setString(Refrigeration_Condenser_WaterCooledFields::WaterInletNodeName,temp->name().get()); } } // Water Outlet Node Name if( (temp = modelObject.outletModelObject()) ) { if(temp->name()) { waterCooled.setString(Refrigeration_Condenser_WaterCooledFields::WaterOutletNodeName,temp->name().get()); } } // Water-Cooled Loop Flow Type s = modelObject.waterCooledLoopFlowType(); if (s) { waterCooled.setString(Refrigeration_Condenser_WaterCooledFields::WaterCooledLoopFlowType,s.get()); } // Water Outlet Temperature Schedule Name boost::optional<Schedule> waterOutletTemperatureSchedule = modelObject.waterOutletTemperatureSchedule(); if( waterOutletTemperatureSchedule ) { boost::optional<IdfObject> _waterOutletTemperatureSchedule = translateAndMapModelObject(waterOutletTemperatureSchedule.get()); if( _waterOutletTemperatureSchedule && _waterOutletTemperatureSchedule->name() ) { waterCooled.setString(Refrigeration_Condenser_WaterCooledFields::WaterOutletTemperatureScheduleName,_waterOutletTemperatureSchedule->name().get()); } } // Water Design Flow Rate d = modelObject.waterDesignFlowRate(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::WaterDesignFlowRate,d.get()); } // Water Maximum Flow Rate d = modelObject.waterMaximumFlowRate(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::WaterMaximumFlowRate,d.get()); } // Water Maximum Water Outlet Temperature d = modelObject.waterMaximumWaterOutletTemperature(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::WaterMaximumWaterOutletTemperature,d.get()); } // Water Minimum Water Inlet Temperature d = modelObject.waterMinimumWaterInletTemperature(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::WaterMinimumWaterInletTemperature,d.get()); } // End-Use Subcategory s = modelObject.endUseSubcategory(); if (s) { waterCooled.setString(Refrigeration_Condenser_WaterCooledFields::EndUseSubcategory,s.get()); } // Condenser Refrigerant Operating Charge Inventory d = modelObject.condenserRefrigerantOperatingChargeInventory(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::CondenserRefrigerantOperatingChargeInventory,d.get()); } // Condensate Receiver Refrigerant Inventory d = modelObject.condensateReceiverRefrigerantInventory(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::CondensateReceiverRefrigerantInventory,d.get()); } //Condensate Piping Refrigerant Inventory d = modelObject.condensatePipingRefrigerantInventory(); if (d) { waterCooled.setDouble(Refrigeration_Condenser_WaterCooledFields::CondensatePipingRefrigerantInventory,d.get()); } return waterCooled; }
boost::optional<IdfObject> ForwardTranslator::translateCoilHeatingGas( CoilHeatingGas & modelObject ) { OptionalString s; OptionalModelObject temp; // Create a new IddObjectType::Fan_OnOff IdfObject idfObject(IddObjectType::Coil_Heating_Gas); /////////////////////////////////////////////////////////////////////////// // Field: Name //////////////////////////////////////////////////////////// s = modelObject.name(); if( s ) { idfObject.setName(*s); } /////////////////////////////////////////////////////////////////////////// // hook up required objects try { Schedule sched = modelObject.availableSchedule(); translateAndMapModelObject(sched); idfObject.setString(Coil_Heating_GasFields::AvailabilityScheduleName, sched.name().get() ); } catch (std::exception& e) { LOG(Error,"Could not translate " << modelObject.briefDescription() << ", because " << e.what() << "."); return boost::none; } /////////////////////////////////////////////////////////////////////////// // Field: Gas Burner Efficiency /////////////////////////////////////////// idfObject.setDouble(openstudio::Coil_Heating_GasFields::GasBurnerEfficiency,modelObject.gasBurnerEfficiency()); /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Field: Nominal Capacity //////////////////////////////////////////////// OptionalDouble d=modelObject.nominalCapacity(); if(d) { idfObject.setDouble(openstudio::Coil_Heating_GasFields::NominalCapacity,*d); } else { idfObject.setString(openstudio::Coil_Heating_GasFields::NominalCapacity,"AutoSize"); } /////////////////////////////////////////////////////////////////////////// idfObject.setDouble(openstudio::Coil_Heating_GasFields::ParasiticElectricLoad,modelObject.parasiticElectricLoad()); idfObject.setDouble(openstudio::Coil_Heating_GasFields::ParasiticGasLoad,modelObject.parasiticGasLoad()); /////////////////////////////////////////////////////////////////////////// // Field: Air Inlet Node Name ///////////////////////////////////////////// temp = modelObject.inletModelObject(); if(temp) { s=temp->name(); if( s ) { idfObject.setString(openstudio::Coil_Heating_GasFields::AirInletNodeName,*s); } } /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Field: Air Outlet Node Name //////////////////////////////////////////// temp = modelObject.outletModelObject(); if(temp) { s=temp->name(); if( s) { idfObject.setString(openstudio::Coil_Heating_GasFields::AirOutletNodeName,*s); idfObject.setString(openstudio::Coil_Heating_GasFields::TemperatureSetpointNodeName,*s); } } /////////////////////////////////////////////////////////////////////////// m_idfObjects.push_back(idfObject); // Part Load Fraction Correlation Curve if( boost::optional<model::Curve> curve = modelObject.partLoadFractionCorrelationCurve() ) { if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) ) { idfObject.setString(Coil_Heating_GasFields::PartLoadFractionCorrelationCurveName,_curve->name().get()); } } return boost::optional<IdfObject>(idfObject); }
boost::optional<IdfObject> ForwardTranslator::translateCoilCoolingDXSingleSpeedWithoutUnitary( model::CoilCoolingDXSingleSpeed & modelObject ) { OptionalString s; IdfObject idfObject(IddObjectType::Coil_Cooling_DX_SingleSpeed); s = modelObject.name(); if( s ) { idfObject.setName(*s); } // hook up required objects try { Schedule sched = modelObject.getAvailabilitySchedule(); translateAndMapModelObject(sched); idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::AvailabilityScheduleName, sched.name().get() ); Curve cb = modelObject.getTotalCoolingCapacityFunctionOfTemperatureCurve(); translateAndMapModelObject(cb); idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::TotalCoolingCapacityFunctionofTemperatureCurveName, cb.name().get()); Curve cq = modelObject.getTotalCoolingCapacityFunctionOfFlowFractionCurve(); translateAndMapModelObject(cq); idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::TotalCoolingCapacityFunctionofFlowFractionCurveName, cq.name().get()); cb =modelObject.getEnergyInputRatioFunctionOfTemperatureCurve(); translateAndMapModelObject(cb); idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::EnergyInputRatioFunctionofTemperatureCurveName, cb.name().get()); cq=modelObject.getEnergyInputRatioFunctionOfFlowFractionCurve(); translateAndMapModelObject(cq); idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::EnergyInputRatioFunctionofFlowFractionCurveName, cq.name().get()); cq=modelObject.getPartLoadFractionCorrelationCurve(); translateAndMapModelObject(cq); idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::PartLoadFractionCorrelationCurveName, cq.name().get()); } catch (std::exception& e) { LOG(Error,"Could not translate " << modelObject.briefDescription() << ", because " << e.what() << "."); return boost::none; } OptionalDouble d = modelObject.ratedTotalCoolingCapacity(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::GrossRatedTotalCoolingCapacity,*d); } else { idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::GrossRatedTotalCoolingCapacity,"Autosize"); } d = modelObject.ratedSensibleHeatRatio(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::GrossRatedSensibleHeatRatio,*d); } else { idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::GrossRatedSensibleHeatRatio,"Autosize"); } d = modelObject.getRatedCOP(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::GrossRatedCoolingCOP,*d); } d = modelObject.ratedAirFlowRate(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::RatedAirFlowRate,*d); } else { idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::RatedAirFlowRate,"Autosize"); } d = modelObject.getRatedEvaporatorFanPowerPerVolumeFlowRate(); if( d ) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::RatedEvaporatorFanPowerPerVolumeFlowRate,*d); } OptionalModelObject omo = modelObject.inletModelObject(); if( omo ) { translateAndMapModelObject(*omo); s = omo->name(); if(s) { idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::AirInletNodeName,*s ); } } omo= modelObject.outletModelObject(); if( omo ) { translateAndMapModelObject(*omo); s = omo->name(); if(s) { idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::AirOutletNodeName,*s); } } d=modelObject.getNominalTimeForCondensateRemovalToBegin(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::NominalTimeforCondensateRemovaltoBegin,*d); } d=modelObject.getRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity,*d); } d=modelObject.getMaximumCyclingRate(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::MaximumCyclingRate,*d); } d=modelObject.getLatentCapacityTimeConstant(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::LatentCapacityTimeConstant,*d); } s=modelObject.getCondenserAirInletNodeName(); if(s) { idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::CondenserAirInletNodeName,*s); } idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::CondenserType,modelObject.getCondenserType()); d=modelObject.getEvaporativeCondenserEffectiveness(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserEffectiveness,*d); } d=modelObject.getEvaporativeCondenserAirFlowRate(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate,*d); } d=modelObject.getEvaporativeCondenserPumpRatedPowerConsumption(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption,*d); } d=modelObject.getCrankcaseHeaterCapacity(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::CrankcaseHeaterCapacity,*d); } d=modelObject.getMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation,*d); } //TODO //getSupplyWaterStorageTankName //getCondensateCollectionWaterStorageTankName d=modelObject.getBasinHeaterCapacity(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::BasinHeaterCapacity,*d); } d=modelObject.getBasinHeaterSetpointTemperature(); if(d) { idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::BasinHeaterSetpointTemperature,*d); } OptionalSchedule os = modelObject.getBasinHeaterOperatingSchedule(); if( os ) { translateAndMapModelObject(*os); idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::BasinHeaterOperatingScheduleName, os->name().get() ); } m_idfObjects.push_back(idfObject); return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateHeatExchangerAirToAirSensibleAndLatent( HeatExchangerAirToAirSensibleAndLatent & modelObject ) { OptionalString s; OptionalDouble d; OptionalModelObject temp; IdfObject idfObject(IddObjectType::HeatExchanger_AirToAir_SensibleAndLatent); m_idfObjects.push_back(idfObject); // Name s = modelObject.name(); if(s) { idfObject.setName(*s); } // AvailabilityScheduleName Schedule sched = modelObject.availabilitySchedule(); translateAndMapModelObject(sched); idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::AvailabilityScheduleName,sched.name().get()); // NominalSupplyAirFlowRate if( modelObject.isNominalSupplyAirFlowRateAutosized() ) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::NominalSupplyAirFlowRate,"Autosize"); } else { d = modelObject.nominalSupplyAirFlowRate(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::NominalSupplyAirFlowRate,d.get()); } } // SensibleEffectivenessat100_HeatingAirFlow d = modelObject.sensibleEffectivenessat100HeatingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::SensibleEffectivenessat100_HeatingAirFlow,d.get()); } // LatentEffectivenessat100_HeatingAirFlow d = modelObject.latentEffectivenessat100HeatingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::LatentEffectivenessat100_HeatingAirFlow,d.get()); } // SensibleEffectivenessat75_HeatingAirFlow d = modelObject.sensibleEffectivenessat75HeatingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::SensibleEffectivenessat75_HeatingAirFlow,d.get()); } // LatentEffectivenessat75_HeatingAirFlow d = modelObject.latentEffectivenessat75HeatingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::LatentEffectivenessat75_HeatingAirFlow,d.get()); } // SensibleEffectivenessat100_CoolingAirFlow d = modelObject.sensibleEffectivenessat100CoolingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::SensibleEffectivenessat100_CoolingAirFlow,d.get()); } // LatentEffectivenessat100_CoolingAirFlow d = modelObject.latentEffectivenessat100CoolingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::LatentEffectivenessat100_CoolingAirFlow,d.get()); } // SensibleEffectivenessat75_CoolingAirFlow d = modelObject.sensibleEffectivenessat75CoolingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::SensibleEffectivenessat75_CoolingAirFlow,d.get()); } // LatentEffectivenessat75_CoolingAirFlow d = modelObject.latentEffectivenessat75CoolingAirFlow(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::LatentEffectivenessat75_CoolingAirFlow,d.get()); } // SupplyAirInletNodeName temp = modelObject.primaryAirInletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirInletNodeName,*s); } } // SupplyAirOutletNodeName temp = modelObject.primaryAirOutletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirOutletNodeName,*s); } } // ExhaustAirInletNodeName temp = modelObject.secondaryAirInletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::ExhaustAirInletNodeName,*s); } } // ExhaustAirOutletNodeName temp = modelObject.secondaryAirOutletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::ExhaustAirOutletNodeName,*s); } } // NominalElectricPower d = modelObject.nominalElectricPower(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::NominalElectricPower,*d); } // SupplyAirOutletTemperatureControl if( modelObject.supplyAirOutletTemperatureControl() ) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirOutletTemperatureControl,"Yes"); } else { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirOutletTemperatureControl,"No"); } // HeatExchangerType s = modelObject.heatExchangerType(); if( s ) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::HeatExchangerType,*s); } // FrostControlType s = modelObject.frostControlType(); if( s ) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::FrostControlType,*s); } // ThresholdTemperature d = modelObject.thresholdTemperature(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::ThresholdTemperature,*d); } // InitialDefrostTimeFraction d = modelObject.initialDefrostTimeFraction(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::InitialDefrostTimeFraction,*d); } // RateofDefrostTimeFractionIncrease d = modelObject.rateofDefrostTimeFractionIncrease(); if( d ) { idfObject.setDouble(HeatExchanger_AirToAir_SensibleAndLatentFields::RateofDefrostTimeFractionIncrease,*d); } // EconomizerLockout if( modelObject.economizerLockout() ) { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::EconomizerLockout,"Yes"); } else { idfObject.setString(HeatExchanger_AirToAir_SensibleAndLatentFields::EconomizerLockout,"No"); } return 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::translateEvaporativeCoolerDirectResearchSpecial( EvaporativeCoolerDirectResearchSpecial & modelObject ) { OptionalString s; OptionalDouble d; OptionalModelObject temp; double value; IdfObject idfObject(IddObjectType::EvaporativeCooler_Direct_ResearchSpecial); m_idfObjects.push_back(idfObject); // Name s = modelObject.name(); if(s) { idfObject.setName(*s); } // AvailabilityScheduleName Schedule sched = modelObject.availableSchedule(); translateAndMapModelObject(sched); idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::AvailabilityScheduleName,sched.name().get()); // CoolerEffectiveness value = modelObject.coolerEffectiveness(); idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::CoolerEffectiveness,value); // RecirculatingWaterPumpPowerConsumption value = modelObject.recirculatingWaterPumpPowerConsumption(); idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::RecirculatingWaterPumpPowerConsumption,value); // AirInletNodeName temp = modelObject.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::AirInletNodeName,*s); } } // AirOutletNodeName temp = modelObject.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::AirOutletNodeName,*s); } } // SensorNodeName temp = modelObject.sensorNode(); if(temp) { s = temp->name(); if(s) { idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::SensorNodeName,*s); } } // DriftLossFraction value = modelObject.driftLossFraction(); idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::DriftLossFraction,value); // BlowdownConcentrationRatio value = modelObject.blowdownConcentrationRatio(); if( value < 2 ) { idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::BlowdownConcentrationRatio,2.0); } else { idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::BlowdownConcentrationRatio,value); } 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; }
boost::optional<IdfObject> ForwardTranslator::translateHeatExchangerFluidToFluid( HeatExchangerFluidToFluid & modelObject ) { OptionalString s; OptionalDouble d; OptionalModelObject mo; boost::optional<IdfObject> idfo; IdfObject idfObject(IddObjectType::HeatExchanger_FluidToFluid); m_idfObjects.push_back(idfObject); // Name s = modelObject.name(); if(s) { idfObject.setName(*s); } // AvailabilityScheduleName boost::optional<Schedule> sched = modelObject.availabilitySchedule(); if( (idfo = translateAndMapModelObject(sched.get())) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::AvailabilityScheduleName,idfo->name().get()); } // LoopDemandSideInletNode mo = modelObject.demandInletModelObject(); if( mo ) { idfObject.setString(HeatExchanger_FluidToFluidFields::LoopDemandSideInletNodeName,mo->name().get()); } // LoopDemandSideOutletNode mo = modelObject.demandOutletModelObject(); if( mo ) { idfObject.setString(HeatExchanger_FluidToFluidFields::LoopDemandSideOutletNodeName,mo->name().get()); } // LoopDemandSideDesignFlowRate if( modelObject.isLoopDemandSideDesignFlowRateAutosized() ) { idfObject.setString(HeatExchanger_FluidToFluidFields::LoopDemandSideDesignFlowRate,"Autosize"); } else { if( (d = modelObject.loopDemandSideDesignFlowRate()) ) { idfObject.setDouble(HeatExchanger_FluidToFluidFields::LoopDemandSideDesignFlowRate,d.get()); } } // LoopSupplySideInletNode mo = modelObject.supplyInletModelObject(); if( mo ) { idfObject.setString(HeatExchanger_FluidToFluidFields::LoopSupplySideInletNodeName,mo->name().get()); } // LoopSupplySideOutletNode mo = modelObject.supplyOutletModelObject(); if( mo ) { idfObject.setString(HeatExchanger_FluidToFluidFields::LoopSupplySideOutletNodeName,mo->name().get()); } // LoopSupplySideDesignFlowRate if( modelObject.isLoopSupplySideDesignFlowRateAutosized() ) { idfObject.setString(HeatExchanger_FluidToFluidFields::LoopSupplySideDesignFlowRate,"Autosize"); } else { if( (d = modelObject.loopSupplySideDesignFlowRate()) ) { idfObject.setDouble(HeatExchanger_FluidToFluidFields::LoopSupplySideDesignFlowRate,d.get()); } } // HeatExchangeModelType if( (s = modelObject.heatExchangeModelType()) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::HeatExchangeModelType,s.get()); } // HeatExchangerUFactorTimesAreaValue if( modelObject.isHeatExchangerUFactorTimesAreaValueAutosized() ) { idfObject.setString(HeatExchanger_FluidToFluidFields::HeatExchangerUFactorTimesAreaValue,"Autosize"); } else { if( (d = modelObject.heatExchangerUFactorTimesAreaValue()) ) { idfObject.setDouble(HeatExchanger_FluidToFluidFields::HeatExchangerUFactorTimesAreaValue,d.get()); } } // ControlType if( (s = modelObject.controlType()) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::ControlType,s.get()); } // HeatExchangerSetpointNodeName if( (mo = modelObject.supplyOutletModelObject()) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::HeatExchangerSetpointNodeName,mo->name().get()); } // MinimumTemperatureDifferencetoActivateHeatExchanger if( (d = modelObject.minimumTemperatureDifferencetoActivateHeatExchanger()) ) { idfObject.setDouble(HeatExchanger_FluidToFluidFields::MinimumTemperatureDifferencetoActivateHeatExchanger,d.get()); } // HeatTransferMeteringEndUseType if( (s = modelObject.heatTransferMeteringEndUseType()) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::HeatTransferMeteringEndUseType,s.get()); } // ComponentOverrideLoopSupplySideInletNode if( (mo = modelObject.componentOverrideLoopSupplySideInletNode()) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::ComponentOverrideLoopSupplySideInletNodeName,mo->name().get()); } // ComponentOverrideLoopDemandSideInletNode if( (mo = modelObject.componentOverrideLoopDemandSideInletNode()) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::ComponentOverrideLoopDemandSideInletNodeName,mo->name().get()); } // ComponentOverrideCoolingControlTemperatureMode if( (s = modelObject.componentOverrideCoolingControlTemperatureMode()) ) { idfObject.setString(HeatExchanger_FluidToFluidFields::ComponentOverrideCoolingControlTemperatureMode,s.get()); } // SizingFactor if( (d = modelObject.sizingFactor()) ) { idfObject.setDouble(HeatExchanger_FluidToFluidFields::SizingFactor,d.get()); } // OperationMinimumTemperatureLimit if( (d = modelObject.operationMinimumTemperatureLimit()) ) { idfObject.setDouble(HeatExchanger_FluidToFluidFields::OperationMinimumTemperatureLimit,d.get()); } // OperationMaximumTemperatureLimit if( (d = modelObject.operationMaximumTemperatureLimit()) ) { idfObject.setDouble(HeatExchanger_FluidToFluidFields::OperationMaximumTemperatureLimit,d.get()); } return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateFanOnOff( FanOnOff & modelObject ) { //setup boost optionals to use to store get method returns boost::optional<std::string> s; boost::optional<double> value; boost::optional<Node> node; OptionalModelObject mo; // Make sure the modelObject gets ut into the map, and the new idfObject gets put into the final file. // Also sets the idfObjects name IdfObject idfObject = createRegisterAndNameIdfObject(IddObjectType::Fan_OnOff,modelObject); // Model Name std::string baseName = modelObject.name().get(); // A3 ,Field Availability Schedule Name Schedule availabilitySchedule = modelObject.availabilitySchedule(); translateAndMapModelObject(availabilitySchedule); s = availabilitySchedule.name(); if(s) { idfObject.setString(Fan_OnOffFields::AvailabilityScheduleName,*s); } // N1 ,Field Fan Efficiency value = modelObject.fanEfficiency(); if( value ) { idfObject.setDouble(Fan_OnOffFields::FanEfficiency,*value); } // N2 Pressure Rise value = modelObject.pressureRise(); if( value ) { idfObject.setDouble(Fan_OnOffFields::PressureRise,*value); } // N3, Field Maximum Flow Rate value = modelObject.maximumFlowRate(); if( value ) { idfObject.setDouble(Fan_OnOffFields::MaximumFlowRate,*value); } else { idfObject.setString(Fan_OnOffFields::MaximumFlowRate,"Autosize"); } // N4, Field Motor Efficiency value = modelObject.motorEfficiency(); if( value ) { idfObject.setDouble(Fan_OnOffFields::MotorEfficiency,*value); } // N5, Field Motor In Airstream Fraction value = modelObject.motorInAirstreamFraction(); if( value ) { idfObject.setDouble(Fan_OnOffFields::MotorInAirstreamFraction,*value); } // A4 Air Inlet Node Name mo = modelObject.inletModelObject(); if(mo) { s = mo->name(); if(s) { idfObject.setString(openstudio::Fan_OnOffFields::AirInletNodeName,*s); } } // A5 , Field Air Outlet Node Name mo = modelObject.outletModelObject(); if(mo) { s = mo->name(); if(s) { idfObject.setString(openstudio::Fan_OnOffFields::AirOutletNodeName,*s); } } // A6 , Field Fan Power Ratio Function of Speed Ratio Curve Name Curve cb1 = modelObject.fanPowerRatioFunctionofSpeedRatioCurve(); translateAndMapModelObject(cb1); idfObject.setString(Fan_OnOffFields::FanPowerRatioFunctionofSpeedRatioCurveName,cb1.name().get()); // A7 , Field Fan Efficiency Ratio Function of Speed Ratio Curve Name Curve cb2 = modelObject.fanEfficiencyRatioFunctionofSpeedRatioCurve(); translateAndMapModelObject(cb2); idfObject.setString(Fan_OnOffFields::FanEfficiencyRatioFunctionofSpeedRatioCurveName,cb2.name().get()); // A8 , Field End-Use Subcategory idfObject.setString(Fan_OnOffFields::EndUseSubcategory,modelObject.endUseSubcategory()); return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateFanConstantVolume( FanConstantVolume& modelObject ) { OptionalString s; OptionalDouble d; OptionalModelObject temp; // Create a new IddObjectType::Fan_ConstantVolume IdfObject idfObject(IddObjectType::Fan_ConstantVolume); /////////////////////////////////////////////////////////////////////////// // Field: Name //////////////////////////////////////////////////////////// s = modelObject.name(); if(s) { idfObject.setName(*s); } /////////////////////////////////////////////////////////////////////////// // hook up required objects try { if( boost::optional<model::AirLoopHVAC> airLoopHVAC = modelObject.airLoopHVAC() ) { Schedule sched = airLoopHVAC->availabilitySchedule(); boost::optional<IdfObject> schedIdf = translateAndMapModelObject(sched); if( schedIdf ) { idfObject.setString(Fan_ConstantVolumeFields::AvailabilityScheduleName,schedIdf->name().get()); } } else { Schedule sched = modelObject.availabilitySchedule(); translateAndMapModelObject(sched); idfObject.setString(Fan_ConstantVolumeFields::AvailabilityScheduleName,sched.name().get()); } } catch (std::exception& e) { LOG(Error,"Could not translate " << modelObject.briefDescription() << ", because " << e.what() << "."); return boost::none; } /////////////////////////////////////////////////////////////////////////// // Fan Efficiency ///////////////////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_ConstantVolumeFields::FanTotalEfficiency,modelObject.fanEfficiency()); /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Pressure Rise ////////////////////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_ConstantVolumeFields::PressureRise,modelObject.pressureRise()); /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Maximum Flow Rate ////////////////////////////////////////////////////// d = modelObject.maximumFlowRate(); if(d) { idfObject.setDouble(openstudio::Fan_ConstantVolumeFields::MaximumFlowRate,*d); } else { idfObject.setString(openstudio::Fan_ConstantVolumeFields::MaximumFlowRate,"AutoSize"); } /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Motor Efficiency /////////////////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_ConstantVolumeFields::MotorEfficiency,modelObject.motorEfficiency()); /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Motor In Airstream Fraction //////////////////////////////////////////// idfObject.setDouble(openstudio::Fan_ConstantVolumeFields::MotorInAirstreamFraction,modelObject.motorInAirstreamFraction()); /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Air Inlet Node Name //////////////////////////////////////////////////// temp = modelObject.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::Fan_ConstantVolumeFields::AirInletNodeName,*s); } } /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// // Air Outlet Node Name /////////////////////////////////////////////////// temp = modelObject.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::Fan_ConstantVolumeFields::AirOutletNodeName,*s); } } /// //////////////////////////////////////////////////////////////////////// m_idfObjects.push_back(idfObject); return boost::optional<IdfObject>(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::translateEvaporativeCoolerDirectResearchSpecial( EvaporativeCoolerDirectResearchSpecial & modelObject ) { OptionalString s; OptionalDouble d; OptionalModelObject temp; double value; IdfObject idfObject(IddObjectType::EvaporativeCooler_Direct_ResearchSpecial); m_idfObjects.push_back(idfObject); // Name s = modelObject.name(); if(s) { idfObject.setName(*s); } // AvailabilityScheduleName Schedule sched = modelObject.availableSchedule(); translateAndMapModelObject(sched); idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::AvailabilityScheduleName,sched.name().get()); // CoolerEffectiveness value = modelObject.coolerEffectiveness(); idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::CoolerDesignEffectiveness,value); // RecirculatingWaterPumpPowerConsumption if ( modelObject.isRecirculatingWaterPumpPowerConsumptionAutosized() ) { idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::RecirculatingWaterPumpDesignPower,"autosize"); } else if( (d = modelObject.recirculatingWaterPumpPowerConsumption()) ) { idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::RecirculatingWaterPumpDesignPower,d.get()); } // AirInletNodeName temp = modelObject.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::AirInletNodeName,*s); } } // AirOutletNodeName temp = modelObject.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::AirOutletNodeName,*s); } } // SensorNodeName temp = modelObject.sensorNode(); if(temp) { s = temp->name(); if(s) { idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::SensorNodeName,*s); } } // DriftLossFraction value = modelObject.driftLossFraction(); idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::DriftLossFraction,value); // BlowdownConcentrationRatio value = modelObject.blowdownConcentrationRatio(); if( value < 2 ) { idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::BlowdownConcentrationRatio,2.0); } else { idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::BlowdownConcentrationRatio,value); } // EffectivenessFlowRatioModifierCurveName if( auto curve = modelObject.effectivenessFlowRatioModifierCurve() ) { auto _curve = translateAndMapModelObject(curve.get()); OS_ASSERT(_curve); idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::EffectivenessFlowRatioModifierCurveName,_curve->name().get()); } // WaterPumpPowerSizingFactor value = modelObject.waterPumpPowerSizingFactor(); idfObject.setDouble(EvaporativeCooler_Direct_ResearchSpecialFields::WaterPumpPowerSizingFactor,value); // WaterPumpPowerModifierCurveName if( auto curve = modelObject.waterPumpPowerModifierCurve() ) { auto _curve = translateAndMapModelObject(curve.get()); OS_ASSERT(_curve); idfObject.setString(EvaporativeCooler_Direct_ResearchSpecialFields::WaterPumpPowerModifierCurveName,_curve->name().get()); } return boost::optional<IdfObject>(idfObject); }