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; }
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; }
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; }
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; }