boost::optional<IdfObject> ForwardTranslator::translateScheduleDay( ScheduleDay & modelObject ) { IdfObject scheduleDay = createRegisterAndNameIdfObject(openstudio::IddObjectType::Schedule_Day_Interval, modelObject); boost::optional<ScheduleTypeLimits> scheduleTypeLimits = modelObject.scheduleTypeLimits(); if (scheduleTypeLimits){ boost::optional<IdfObject> idfScheduleTypeLimits = translateAndMapModelObject(*scheduleTypeLimits); if (idfScheduleTypeLimits){ scheduleDay.setString(Schedule_Day_IntervalFields::ScheduleTypeLimitsName, idfScheduleTypeLimits->name().get()); } } if (modelObject.interpolatetoTimestep()){ scheduleDay.setString(Schedule_Day_IntervalFields::InterpolatetoTimestep, "Yes"); }else{ scheduleDay.setString(Schedule_Day_IntervalFields::InterpolatetoTimestep, "No"); } std::vector<double> values = modelObject.values(); std::vector<openstudio::Time> times = modelObject.times(); unsigned N = values.size(); OS_ASSERT(N == times.size()); scheduleDay.clearExtensibleGroups(); for (unsigned i = 0; i < N; ++i){ IdfExtensibleGroup group = scheduleDay.pushExtensibleGroup(); std::string hourPrefix; std::string minutePrefix; int hours = times[i].hours() + 24*times[i].days(); if (hours < 10){ hourPrefix = "0"; } int minutes = times[i].minutes() + floor((times[i].seconds()/60.0) + 0.5); if (minutes < 10){ minutePrefix = "0"; } std::stringstream ss; ss << hourPrefix << hours << ":" << minutePrefix << minutes; group.setString(Schedule_Day_IntervalExtensibleFields::Time, ss.str()); group.setDouble(Schedule_Day_IntervalExtensibleFields::ValueUntilTime, values[i]); } return scheduleDay; }
boost::optional<IdfObject> ForwardTranslator::translateScheduleYear( ScheduleYear & modelObject ) { IdfObject scheduleYear = createRegisterAndNameIdfObject(openstudio::IddObjectType::Schedule_Year, modelObject); std::vector<ScheduleWeek> scheduleWeeks = modelObject.scheduleWeeks(); std::vector<openstudio::Date> dates = modelObject.dates(); unsigned N = scheduleWeeks.size(); if( N != dates.size() ) { LOG(Error,"Could not translate " << modelObject.briefDescription() << ", because the number of week schedules does not match the number of dates."); return boost::none; } boost::optional<ScheduleTypeLimits> scheduleTypeLimits = modelObject.scheduleTypeLimits(); if (scheduleTypeLimits){ boost::optional<IdfObject> idfScheduleTypeLimits = translateAndMapModelObject(*scheduleTypeLimits); if (idfScheduleTypeLimits){ scheduleYear.setString(Schedule_YearFields::ScheduleTypeLimitsName, idfScheduleTypeLimits->name().get()); } } openstudio::Date startDate(MonthOfYear::Jan, 1); scheduleYear.clearExtensibleGroups(); for (unsigned i = 0; i < N; ++i){ IdfExtensibleGroup group = scheduleYear.pushExtensibleGroup(); boost::optional<IdfObject> idfScheduleWeek = translateAndMapModelObject(scheduleWeeks[i]); if (idfScheduleWeek){ group.setString(Schedule_YearExtensibleFields::Schedule_WeekName, idfScheduleWeek->name().get()); } group.setInt(Schedule_YearExtensibleFields::StartMonth, startDate.monthOfYear().value()); group.setUnsigned(Schedule_YearExtensibleFields::StartDay, startDate.dayOfMonth()); group.setInt(Schedule_YearExtensibleFields::EndMonth, dates[i].monthOfYear().value()); group.setUnsigned(Schedule_YearExtensibleFields::EndDay, dates[i].dayOfMonth()); startDate = dates[i] + openstudio::Time(1,0,0); } return scheduleYear; }
boost::optional<IdfObject> ForwardTranslator::translateZoneHVACBaseboardRadiantConvectiveElectric(ZoneHVACBaseboardRadiantConvectiveElectric& modelObject) { boost::optional<std::string> s; boost::optional<double> value; boost::optional<ModelObject> temp; // Name IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ZoneHVAC_Baseboard_RadiantConvective_Electric, modelObject); // AvailabilityScheduleName { auto schedule = modelObject.availabilitySchedule(); if( auto _schedule = translateAndMapModelObject(schedule) ) { idfObject.setString(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::AvailabilityScheduleName,_schedule->name().get()); } } // HeatingDesignCapacityMethod if( (s = modelObject.heatingDesignCapacityMethod()) ) { idfObject.setString(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::HeatingDesignCapacityMethod,s.get()); } // HeatingDesignCapacity if( modelObject.isHeatingDesignCapacityAutosized() ) { idfObject.setString(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::HeatingDesignCapacity,"AutoSize"); } else if( (value = modelObject.heatingDesignCapacity()) ) { idfObject.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::HeatingDesignCapacity,value.get()); } // HeatingDesignCapacityPerFloorArea if( (value = modelObject.heatingDesignCapacityPerFloorArea()) ) { idfObject.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::HeatingDesignCapacityPerFloorArea,value.get()); } // FractionofAutosizedHeatingDesignCapacity if( (value = modelObject.fractionofAutosizedHeatingDesignCapacity()) ) { idfObject.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::FractionofAutosizedHeatingDesignCapacity,value.get()); } // Efficiency if( (value = modelObject.efficiency()) ) { idfObject.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::Efficiency,value.get()); } // FractionRadiant if( (value = modelObject.fractionRadiant()) ) { idfObject.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::FractionRadiant,value.get()); } // FractionofRadiantEnergyIncidentonPeople double fractionofRadiantEnergyIncidentonPeople = modelObject.fractionofRadiantEnergyIncidentonPeople(); { idfObject.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricFields::FractionofRadiantEnergyIncidentonPeople,fractionofRadiantEnergyIncidentonPeople); } //get rid of any existing surface (just to be safe) idfObject.clearExtensibleGroups(); //aggregator for total area; will be used to create weighted area double totalAreaOfWallSurfaces = 0; double totalAreaOfCeilingSurfaces = 0; double totalAreaOfFloorSurfaces = 0; //loop through all surfaces, adding up their area auto const& surfaces = modelObject.getImpl<model::detail::ZoneHVACBaseboardRadiantConvectiveElectric_Impl>()->surfaces(); for ( auto const& surface : surfaces ) { if( istringEqual(surface.surfaceType(),"Floor") ) { totalAreaOfFloorSurfaces += surface.grossArea(); } else if( istringEqual(surface.surfaceType(),"RoofCeiling") ) { totalAreaOfCeilingSurfaces += surface.grossArea(); } else { totalAreaOfWallSurfaces += surface.grossArea(); } } // Assume that 5% of what is not on people is on the floor double fractionOnFloor = (1.0 - fractionofRadiantEnergyIncidentonPeople) * 0.05; // Assume that 55% of what is not on people is on the walls double fractionOnWall = (1.0 - fractionofRadiantEnergyIncidentonPeople) * 0.55; // Assume that 40% of what is not on people is on the ceiling double fractionOnCeiling = (1.0 - fractionofRadiantEnergyIncidentonPeople) * 0.40; //loop through all the surfaces, adding them and their flow fractions (weighted per-area) for ( auto const& surface : surfaces ) { IdfExtensibleGroup group = idfObject.pushExtensibleGroup(); group.setString(ZoneHVAC_Baseboard_RadiantConvective_ElectricExtensibleFields::SurfaceName, surface.name().get()); if( istringEqual(surface.surfaceType(),"Floor") ) { group.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricExtensibleFields::FractionofRadiantEnergytoSurface, (surface.grossArea()/totalAreaOfFloorSurfaces * fractionOnFloor) ); } else if( istringEqual(surface.surfaceType(),"RoofCeiling") ) { group.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricExtensibleFields::FractionofRadiantEnergytoSurface, (surface.grossArea()/totalAreaOfCeilingSurfaces * fractionOnCeiling) ); } else { group.setDouble(ZoneHVAC_Baseboard_RadiantConvective_ElectricExtensibleFields::FractionofRadiantEnergytoSurface, (surface.grossArea()/totalAreaOfWallSurfaces * fractionOnWall) ); } } return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateSpaceType( SpaceType & modelObject ) { std::vector<Space> spaces = modelObject.spaces(); // check if this is a dummy space type meant to prevent inheriting building space type std::vector<ModelObject> children = modelObject.children(); if (children.empty()){ LOG(Info, "SpaceType " << modelObject.name().get() << " has no children, it will not be translated"); return boost::none; } IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ZoneList, modelObject); std::set<std::string> zoneNames; for (const Space& space : spaces){ boost::optional<ThermalZone> thermalZone = space.thermalZone(); if (thermalZone){ zoneNames.insert(thermalZone->name().get()); } } idfObject.clearExtensibleGroups(); for (const std::string& zoneName : zoneNames){ idfObject.pushExtensibleGroup(std::vector<std::string>(1, zoneName)); } // translate internal mass InternalMassVector internalMasses = modelObject.internalMass(); std::sort(internalMasses.begin(), internalMasses.end(), WorkspaceObjectNameLess()); for (InternalMass& internalMass : internalMasses){ translateAndMapModelObject(internalMass); } // translate lights LightsVector lights = modelObject.lights(); std::sort(lights.begin(), lights.end(), WorkspaceObjectNameLess()); for (Lights& light : lights){ translateAndMapModelObject(light); } // translate luminaires LuminaireVector luminaires = modelObject.luminaires(); std::sort(luminaires.begin(), luminaires.end(), WorkspaceObjectNameLess()); for (Luminaire& luminaire : luminaires){ translateAndMapModelObject(luminaire); } // translate people PeopleVector people = modelObject.people(); std::sort(people.begin(), people.end(), WorkspaceObjectNameLess()); for (People& person : people){ translateAndMapModelObject(person); } // translate electric equipment ElectricEquipmentVector electricEquipment = modelObject.electricEquipment(); std::sort(electricEquipment.begin(), electricEquipment.end(), WorkspaceObjectNameLess()); for (ElectricEquipment& equipment : electricEquipment){ translateAndMapModelObject(equipment); } // translate gas equipment GasEquipmentVector gasEquipment = modelObject.gasEquipment(); std::sort(gasEquipment.begin(), gasEquipment.end(), WorkspaceObjectNameLess()); for (GasEquipment& equipment : gasEquipment){ translateAndMapModelObject(equipment); } // translate hot water equipment HotWaterEquipmentVector hotWaterEquipment = modelObject.hotWaterEquipment(); std::sort(hotWaterEquipment.begin(), hotWaterEquipment.end(), WorkspaceObjectNameLess()); for (HotWaterEquipment& equipment : hotWaterEquipment){ translateAndMapModelObject(equipment); } // translate steam equipment SteamEquipmentVector steamEquipment = modelObject.steamEquipment(); std::sort(steamEquipment.begin(), steamEquipment.end(), WorkspaceObjectNameLess()); for (SteamEquipment& equipment : steamEquipment){ translateAndMapModelObject(equipment); } // translate other equipment OtherEquipmentVector otherEquipment = modelObject.otherEquipment(); std::sort(otherEquipment.begin(), otherEquipment.end(), WorkspaceObjectNameLess()); for (OtherEquipment& equipment : otherEquipment){ translateAndMapModelObject(equipment); } // translate SpaceInfiltration_DesignFlowRate SpaceInfiltrationDesignFlowRateVector spaceInfiltrationDesignFlowRates = modelObject.spaceInfiltrationDesignFlowRates(); std::sort(spaceInfiltrationDesignFlowRates.begin(), spaceInfiltrationDesignFlowRates.end(), WorkspaceObjectNameLess()); for (SpaceInfiltrationDesignFlowRate& spaceInfiltrationDesignFlowRate : spaceInfiltrationDesignFlowRates){ translateAndMapModelObject(spaceInfiltrationDesignFlowRate); } // translate SpaceInfiltration_EffectiveLeakageArea SpaceInfiltrationEffectiveLeakageAreaVector spaceInfiltrationEffectiveLeakageAreas = modelObject.spaceInfiltrationEffectiveLeakageAreas(); std::sort(spaceInfiltrationEffectiveLeakageAreas.begin(), spaceInfiltrationEffectiveLeakageAreas.end(), WorkspaceObjectNameLess()); for (SpaceInfiltrationEffectiveLeakageArea& spaceInfiltrationEffectiveLeakageArea : spaceInfiltrationEffectiveLeakageAreas){ translateAndMapModelObject(spaceInfiltrationEffectiveLeakageArea); } return idfObject; }