boost::optional<IdfObject> ForwardTranslator::translateDistrictCooling( DistrictCooling& modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
boost::optional<double> value;
IdfObject idfObject(IddObjectType::DistrictCooling);
m_idfObjects.push_back(idfObject);
///////////////////////////////////////////////////////////////////////////
// Field: Name ////////////////////////////////////////////////////////////
s = modelObject.name();
if(s)
{
idfObject.setName(*s);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Inlet Node Name ////////////////////////////////////////////////////
temp = modelObject.inletModelObject();
if(temp)
{
s = temp->name();
if(s)
{
idfObject.setString(openstudio::DistrictCoolingFields::ChilledWaterInletNodeName,*s);
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Outlet Node Name ///////////////////////////////////////////////////
temp = modelObject.outletModelObject();
if(temp)
{
s = temp->name();
if(s)
{
idfObject.setString(openstudio::DistrictCoolingFields::ChilledWaterOutletNodeName,*s);
}
}
///
////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//Nominal Capacity ///////////////////////////////////////////////////
if( (value = modelObject.nominalCapacity()) )
{
idfObject.setDouble(DistrictCoolingFields::NominalCapacity,value.get());
}
//
////////////////////////////////////////////////////////////////////////
return boost::optional<IdfObject>(idfObject);
}
OptionalModelObject ReverseTranslator::translateScheduleCompact( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Schedule_Compact )
{
LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Compact");
return boost::none;
}
ScheduleCompact scheduleCompact(m_model);
OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_CompactFields::ScheduleTypeLimitsName);
if (target){
OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
if (scheduleTypeLimits){
scheduleCompact.setPointer(OS_Schedule_CompactFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
}
}
if (OptionalString os = workspaceObject.name()) {
scheduleCompact.setName(*os);
}
for (const IdfExtensibleGroup& eg : workspaceObject.extensibleGroups()) {
scheduleCompact.pushExtensibleGroup(eg.fields());
}
return scheduleCompact;
}
OptionalModelObject ReverseTranslator::translateScheduleDayHourly(const WorkspaceObject & workspaceObject){
if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Day_Hourly){
LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Day:Hourly");
return boost::none;
}
// create the schedule
ScheduleDay scheduleDay(m_model);
OptionalString s = workspaceObject.name();
if (s){
scheduleDay.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Day_HourlyFields::ScheduleTypeLimitsName);
if (target){
OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
if (scheduleTypeLimits){
scheduleDay.setPointer(OS_Schedule_DayFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
}
}
for(unsigned i = 0; i < 24; ++i){
OptionalDouble d = workspaceObject.getDouble(Schedule_Day_HourlyFields::Hour1 + i, true);
if (d){
scheduleDay.addValue(openstudio::Time(0,i+1,0,0), *d);
}
}
return scheduleDay;
}
boost::optional<IdfObject> ForwardTranslator::translateCoilCoolingDXTwoStageWithHumidityControlMode( model::CoilCoolingDXTwoStageWithHumidityControlMode & modelObject )
{
IdfObject coilSystemCoolingDXIdf(IddObjectType::CoilSystem_Cooling_DX);
m_idfObjects.push_back(coilSystemCoolingDXIdf);
boost::optional<IdfObject> oIdfObject = translateCoilCoolingDXTwoStageWithHumidityControlModeWithoutUnitary(modelObject);
if( ! oIdfObject ) { return boost::none; }
IdfObject idfObject = oIdfObject.get();
OptionalString s;
s = modelObject.name();
if( s )
{
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::CoolingCoilObjectType,idfObject.iddObject().name());
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::CoolingCoilName,*s);
coilSystemCoolingDXIdf.setName(*s + " CoilSystem");
}
if( auto sched = modelObject.availabilitySchedule() ) {
if( auto _sched = translateAndMapModelObject(sched.get()) ) {
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::AvailabilityScheduleName,_sched->name().get());
}
}
OptionalModelObject omo = modelObject.inletModelObject();
if( omo )
{
translateAndMapModelObject(*omo);
s = omo->name();
if(s)
{
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemInletNodeName,*s);
}
}
omo= modelObject.outletModelObject();
if( omo )
{
translateAndMapModelObject(*omo);
s = omo->name();
if(s)
{
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemOutletNodeName,*s);
coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemSensorNodeName,*s);
}
}
return coilSystemCoolingDXIdf;
}
boost::optional<IdfObject> ForwardTranslator::translateAirLoopHVACZoneSplitter( AirLoopHVACZoneSplitter & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
std::string s;
IdfObject idfObject(openstudio::IddObjectType::AirLoopHVAC_ZoneSplitter);
m_idfObjects.push_back(idfObject);
///////////////////////////////////////////////////////////////////////////
// Field: Name ////////////////////////////////////////////////////////////
s = modelObject.name().get();
idfObject.setName(s);
///////////////////////////////////////////////////////////////////////////
// Field: Inlet Node Name /////////////////////////////////////////////////
temp = modelObject.inletModelObject();
if(temp)
{
optS = temp->name();
if(optS)
{
idfObject.setString(openstudio::AirLoopHVAC_ZoneSplitterFields::InletNodeName,*optS);
}
}
///////////////////////////////////////////////////////////////////////////
// Field: Outlet 1-N Node Name //////////////////////////////////////////////
std::vector<ModelObject> outletModelObjects = modelObject.outletModelObjects();
int i = 2;
for( const auto & outletModelObject : outletModelObjects )
{
if( OptionalAirTerminalSingleDuctUncontrolled airTerminal =
outletModelObject.optionalCast<AirTerminalSingleDuctUncontrolled>() )
{
temp = airTerminal->outletModelObject();
if(temp)
{
optS = temp->name().get();
if(optS)
idfObject.setString(i,*optS);
}
}
else
{
s = outletModelObject.name().get();
idfObject.setString(i,s);
}
i++;
}
return boost::optional<IdfObject>(idfObject);
}
boost::optional<IdfObject> ForwardTranslator::translatePipeAdiabatic( PipeAdiabatic& modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
IdfObject idfObject(IddObjectType::Pipe_Adiabatic);
m_idfObjects.push_back(idfObject);
///////////////////////////////////////////////////////////////////////////
// Field: Name ////////////////////////////////////////////////////////////
s = modelObject.name();
if(s)
{
idfObject.setName(*s);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Inlet Node Name ////////////////////////////////////////////////////
temp = modelObject.inletModelObject();
if(temp)
{
s = temp->name();
if(s)
{
idfObject.setString(openstudio::Pipe_AdiabaticFields::InletNodeName,*s);
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Outlet Node Name ///////////////////////////////////////////////////
temp = modelObject.outletModelObject();
if(temp)
{
s = temp->name();
if(s)
{
idfObject.setString(openstudio::Pipe_AdiabaticFields::OutletNodeName,*s);
}
}
///
////////////////////////////////////////////////////////////////////////
return boost::optional<IdfObject>(idfObject);
}
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);
}
OptionalModelObject ReverseTranslator::translateScheduleConstant( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Schedule_Constant )
{
LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Constant");
return boost::none;
}
ScheduleConstant scheduleConstant(m_model);
boost::optional<WorkspaceObject> target = workspaceObject.getTarget(Schedule_ConstantFields::ScheduleTypeLimitsName);
if (target){
OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
if (scheduleTypeLimits) {
scheduleConstant.setPointer(OS_Schedule_ConstantFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
}
}
if (OptionalDouble val = workspaceObject.getDouble(Schedule_ConstantFields::HourlyValue)) {
scheduleConstant.setValue(*val);
}
return scheduleConstant;
}
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::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::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::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::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;
}
OptionalModelObject ReverseTranslator::translateZoneHVACIdealLoadsAirSystem( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::ZoneHVAC_IdealLoadsAirSystem ) {
LOG(Error, "WorkspaceObject is not IddObjectType: ZoneHVAC:IdealLoadsAirSystem");
return boost::none;
}
ZoneHVACIdealLoadsAirSystem zoneHVACIdealLoadsAirSystem(m_model);
// name
boost::optional<std::string> s = workspaceObject.name();
if(s){
zoneHVACIdealLoadsAirSystem.setName(*s);
}
// availability schedule
OptionalWorkspaceObject target = workspaceObject.getTarget(ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName);
if (target){
OptionalModelObject availabilitySchedule = translateAndMapWorkspaceObject(*target);
if (availabilitySchedule){
zoneHVACIdealLoadsAirSystem.setPointer(OS_ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName, availabilitySchedule->handle());
}
}
// skip inlet and outlet node names - that should be done by the zone HVAC object translator
// maximum heating supply air temperature
OptionalDouble d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirTemperature);
if (d){
zoneHVACIdealLoadsAirSystem.setMaximumHeatingSupplyAirTemperature(*d);
}
// minimum cooling supply air temperature
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirTemperature);
if (d){
zoneHVACIdealLoadsAirSystem.setMinimumCoolingSupplyAirTemperature(*d);
}
// maximum heating supply air humidity ratio
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirHumidityRatio);
if (d){
zoneHVACIdealLoadsAirSystem.setMaximumHeatingSupplyAirHumidityRatio(*d);
}
// minimum cooling supply air humidity ratio
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirHumidityRatio);
if (d){
zoneHVACIdealLoadsAirSystem.setMinimumCoolingSupplyAirHumidityRatio(*d);
}
// heating limit
s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit);
if (s){
zoneHVACIdealLoadsAirSystem.setHeatingLimit(*s);
}
// maximum heating air flow rate
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate);
if (d){
zoneHVACIdealLoadsAirSystem.setMaximumHeatingAirFlowRate(*d);
}
// maximum sensible heating capacity
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity);
if (d){
zoneHVACIdealLoadsAirSystem.setMaximumSensibleHeatingCapacity(*d);
}
// cooling limit
s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit);
if (s){
zoneHVACIdealLoadsAirSystem.setCoolingLimit(*s);
}
// maximum cooling airflow rate
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate);
if (d){
zoneHVACIdealLoadsAirSystem.setMaximumCoolingAirFlowRate(*d);
}
// maximum total cooling capacity
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity);
if (d){
zoneHVACIdealLoadsAirSystem.setMaximumTotalCoolingCapacity(*d);
}
// heating availability schedule
target = workspaceObject.getTarget(ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName);
if (target){
OptionalModelObject heatingAvailabilitySchedule = translateAndMapWorkspaceObject(*target);
if (heatingAvailabilitySchedule){
zoneHVACIdealLoadsAirSystem.setPointer(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName, heatingAvailabilitySchedule->handle());
}
}
// cooling availability schedule
target = workspaceObject.getTarget(ZoneHVAC_IdealLoadsAirSystemFields::CoolingAvailabilityScheduleName);
if (target){
OptionalModelObject coolingAvailabilitySchedule = translateAndMapWorkspaceObject(*target);
if (coolingAvailabilitySchedule){
zoneHVACIdealLoadsAirSystem.setPointer(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingAvailabilityScheduleName, coolingAvailabilitySchedule->handle());
}
}
// dehumidification control type
s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::DehumidificationControlType);
if (s){
zoneHVACIdealLoadsAirSystem.setDehumidificationControlType(*s);
}
// cooling sensible heat ratio
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::CoolingSensibleHeatRatio);
if (d){
zoneHVACIdealLoadsAirSystem.setCoolingSensibleHeatRatio(*d);
}
// humidification control type
s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::HumidificationControlType);
if (s){
zoneHVACIdealLoadsAirSystem.setHumidificationControlType(*s);
}
// design specification outdoor air object name
target = workspaceObject.getTarget(ZoneHVAC_IdealLoadsAirSystemFields::DesignSpecificationOutdoorAirObjectName);
if (target){
OptionalModelObject designSpecificationOutdoorAir = translateAndMapWorkspaceObject(*target);
if (designSpecificationOutdoorAir){
zoneHVACIdealLoadsAirSystem.setPointer(OS_ZoneHVAC_IdealLoadsAirSystemFields::DesignSpecificationOutdoorAirObjectName, designSpecificationOutdoorAir->handle());
}
}
// demand controlled ventilation type
s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::DemandControlledVentilationType);
if (s){
zoneHVACIdealLoadsAirSystem.setDemandControlledVentilationType(*s);
}
// outdoor air economizer type
s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::OutdoorAirEconomizerType);
if (s){
zoneHVACIdealLoadsAirSystem.setOutdoorAirEconomizerType(*s);
}
// heat recovery type
s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::HeatRecoveryType);
if (s){
zoneHVACIdealLoadsAirSystem.setHeatRecoveryType(*s);
}
// sensible heat recovery effectiveness
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::SensibleHeatRecoveryEffectiveness);
if (d){
zoneHVACIdealLoadsAirSystem.setSensibleHeatRecoveryEffectiveness(*d);
}
// latent heat recovery effectiveness
d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::LatentHeatRecoveryEffectiveness);
if (d){
zoneHVACIdealLoadsAirSystem.setLatentHeatRecoveryEffectiveness(*d);
}
return zoneHVACIdealLoadsAirSystem;
}
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);
}
OptionalModelObject ReverseTranslator::translateScheduleDayInterval(const WorkspaceObject & workspaceObject){
if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Day_Interval){
LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Day:Interval");
return boost::none;
}
// create the schedule
ScheduleDay scheduleDay(m_model);
OptionalString s = workspaceObject.name();
if (s){
scheduleDay.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Day_IntervalFields::ScheduleTypeLimitsName);
if (target){
OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
if (scheduleTypeLimits){
scheduleDay.setPointer(OS_Schedule_DayFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
}
}
s = workspaceObject.getString(2,true);
if (s){
if (openstudio::istringEqual(*s,"yes")){
scheduleDay.setInterpolatetoTimestep(true);
}
else if (openstudio::istringEqual(*s,"yes")){
scheduleDay.setInterpolatetoTimestep(false);
}
}
//get extensible groups
std::vector<IdfExtensibleGroup> extensibleGroups = workspaceObject.extensibleGroups();
//loop over extensible groups
boost::regex timeRegex("(\\d?\\d:\\d\\d)");
boost::smatch m;
unsigned n = extensibleGroups.size();
for (unsigned i = 0; i < n; ++i){
//read in extensible groups
boost::optional<std::string> timeString = extensibleGroups[i].getString(Schedule_Day_IntervalExtensibleFields::Time);
boost::optional<double> valueUntilTime = extensibleGroups[i].getDouble(Schedule_Day_IntervalExtensibleFields::ValueUntilTime);
if (timeString && valueUntilTime) {
// Time string may be prefixed with "Until: ". Extract time in HH:MM format.
if (boost::regex_search(*timeString,m,timeRegex)) {
timeString = std::string(m[1].first,m[1].second);
}
try {
openstudio::Time time(*timeString);
scheduleDay.addValue(time,*valueUntilTime);
}
catch (std::exception& e) {
LOG(Warn,"Could not add value (" << *timeString << ", " << *valueUntilTime
<< ") to ScheduleDay being created from " << workspaceObject.briefDescription()
<< ", because " << e.what() << ".");
}
}
else {
LOG(Warn,"Encountered extensible group with incomplete or improperly formatted data in "
<< workspaceObject.briefDescription() << ". Therefore, a corresponding value is not "
<< "being added to the ScheduleDay object under construction.");
}
}
return scheduleDay;
}
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::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::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::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::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::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::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::translateAirTerminalSingleDuctConstantVolumeFourPipeInduction( AirTerminalSingleDuctConstantVolumeFourPipeInduction & modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName(modelObject.name().get() + " Air Distribution Unit");
m_idfObjects.push_back(_airDistributionUnit);
// Name
IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_ConstantVolume_FourPipeInduction, modelObject);
// Availability Schedule Name
if( (temp = modelObject.availabilitySchedule()) )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(temp.get()) )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// Maximum Total Air Flow Rate
if( (d = modelObject.maximumTotalAirFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate,d.get());
}
else if( modelObject.isMaximumTotalAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate,"Autosize");
}
// Induction Ratio
if( (d = modelObject.inductionRatio()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InductionRatio,d.get());
}
// Supply Air Inlet Node Name
if( auto node = modelObject.inletModelObject() ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::SupplyAirInletNodeName,node->name().get());
}
// Induced Air Inlet Node Name
if( auto node = modelObject.inducedAirInletNode() ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InducedAirInletNodeName,node->name().get());
}
// Air Outlet Node Name
if( auto node = modelObject.outletModelObject() ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AirOutletNodeName,node->name().get());
}
// Hot Water Inlet Node Name
// deprecated
// Cold Water Inlet Node Name
//deprecated
// Heating Coil Object Type
// Heating Coil Name
boost::optional<IdfObject> _heatingCoil;
{
auto heatingCoil = modelObject.heatingCoil();
if( (_heatingCoil = translateAndMapModelObject(heatingCoil)) ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingCoilObjectType,_heatingCoil->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingCoilName,_heatingCoil->name().get());
}
}
// Maximum Hot Water Flow Rate
if( (d = modelObject.maximumHotWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate,d.get());
}
else if( modelObject.isMaximumHotWaterFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate,"Autosize");
}
// Minimum Hot Water Flow Rate
if( (d = modelObject.minimumHotWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumHotWaterFlowRate,d.get());
}
// Heating Convergence Tolerance
if( (d = modelObject.heatingConvergenceTolerance()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingConvergenceTolerance,d.get());
}
// Cooling Coil Object Type
// Cooling Coil Name
boost::optional<IdfObject> _coolingCoil;
if( auto coolingCoil = modelObject.coolingCoil() ) {
if( (_coolingCoil = translateAndMapModelObject(coolingCoil.get())) ) {
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingCoilObjectType,_coolingCoil->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingCoilName,_coolingCoil->name().get());
}
}
// Maximum Cold Water Flow Rate
if( (d = modelObject.maximumColdWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate,d.get());
}
else if( modelObject.isMaximumColdWaterFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate,"Autosize");
}
// Minimum Cold Water Flow Rate
if( (d = modelObject.minimumColdWaterFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumColdWaterFlowRate,d.get());
}
// Cooling Convergence Tolerance
if( (d = modelObject.coolingConvergenceTolerance()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingConvergenceTolerance,d.get());
}
// Zone Mixer Name
IdfObject _mixer(IddObjectType::AirLoopHVAC_ZoneMixer);
_mixer.setName(modelObject.name().get() + " Mixer");
m_idfObjects.push_back(_mixer);
_mixer.clearExtensibleGroups();
idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::ZoneMixerName,_mixer.name().get());
std::string baseName = modelObject.name().get();
std::string heatingCoilInlet;
std::string heatingCoilOutlet;
std::string coolingCoilInlet;
std::string coolingCoilOutlet;
std::string mixerAirSystemInlet;
std::string mixerInducedInlet;
std::string mixerOutlet;
if( auto inducedAirInletNode = modelObject.inducedAirInletNode() ) {
heatingCoilInlet = inducedAirInletNode->name().get();
}
heatingCoilOutlet = baseName + " Heating Coil Outlet";
if( _coolingCoil ) {
coolingCoilInlet = heatingCoilOutlet;
coolingCoilOutlet = baseName + " Cooling Coil Outlet";
mixerInducedInlet = coolingCoilOutlet;
} else {
mixerInducedInlet = heatingCoilOutlet;
}
if( auto node = modelObject.inletModelObject() ) {
mixerAirSystemInlet = node->name().get();
}
if( auto node = modelObject.outletModelObject() ) {
mixerOutlet = node->name().get();
}
if( _heatingCoil && (_heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Water) ) {
_heatingCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,heatingCoilInlet);
_heatingCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,heatingCoilOutlet);
}
if( _coolingCoil && (_coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_Water) ) {
_coolingCoil->setString(Coil_Cooling_WaterFields::AirInletNodeName,coolingCoilInlet);
_coolingCoil->setString(Coil_Cooling_WaterFields::AirOutletNodeName,coolingCoilOutlet);
}
_mixer.setString(AirLoopHVAC_ZoneMixerFields::OutletNodeName,mixerOutlet);
IdfExtensibleGroup eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,mixerAirSystemInlet);
eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,mixerInducedInlet);
if( auto node = modelObject.outletModelObject() ) {
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,node->name().get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
return _airDistributionUnit;
}
boost::optional<IdfObject> ForwardTranslator::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);
}
