自学教程：C++ translateAndMapModelObject函数代码示例

boost::optional<IdfObject> ForwardTranslator::translateGeneratorPVWatts(model::GeneratorPVWatts & modelObject){  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::Generator_PVWatts, modelObject);  idfObject.setString(Generator_PVWattsFields::PVWattsVersion, modelObject.pvWattsVersion());  idfObject.setDouble(Generator_PVWattsFields::DCSystemCapacity, modelObject.dcSystemCapacity());  idfObject.setString(Generator_PVWattsFields::ModuleType, modelObject.moduleType());  idfObject.setString(Generator_PVWattsFields::ArrayType, modelObject.arrayType());  idfObject.setDouble(Generator_PVWattsFields::SystemLosses, modelObject.systemLosses());  boost::optional<PlanarSurface> surface = modelObject.surface();  if (surface){    boost::optional<IdfObject> surfaceIdf = translateAndMapModelObject(*surface);    if (surfaceIdf){      idfObject.setString(Generator_PVWattsFields::ArrayGeometryType, "Surface");      idfObject.setString(Generator_PVWattsFields::SurfaceName, surfaceIdf->name().get());    }  } else {    idfObject.setString(Generator_PVWattsFields::ArrayGeometryType, "TiltAzimuth");    idfObject.setDouble(Generator_PVWattsFields::TiltAngle, modelObject.tiltAngle());    idfObject.setDouble(Generator_PVWattsFields::AzimuthAngle, modelObject.azimuthAngle());  }  idfObject.setDouble(Generator_PVWattsFields::GroundCoverageRatio, modelObject.groundCoverageRatio());  return idfObject;}

boost::optional<IdfObject> ForwardTranslator::translateFFactorGroundFloorConstruction( FFactorGroundFloorConstruction & modelObject ){  IdfObject idfObject( openstudio::IddObjectType::Construction_FfactorGroundFloor);  m_idfObjects.push_back(idfObject);  for (LifeCycleCost lifeCycleCost : modelObject.lifeCycleCosts()){    translateAndMapModelObject(lifeCycleCost);  }  idfObject.setString(Construction_FfactorGroundFloorFields::Name, modelObject.name().get());  OptionalDouble d = modelObject.getDouble(OS_Construction_FfactorGroundFloorFields::FFactor, false);  if (d){    idfObject.setDouble(Construction_FfactorGroundFloorFields::FFactor, *d);  }else{    LOG(Error, "Missing required input 'F-Factor' for Construction:FfactorGroundFloor named '" << modelObject.name().get() << "'");  }  d = modelObject.getDouble(OS_Construction_FfactorGroundFloorFields::Area, false);  if (d){    idfObject.setDouble(Construction_FfactorGroundFloorFields::Area, *d);  }else{    LOG(Error, "Missing required input 'Area' for Construction:FfactorGroundFloor named '" << modelObject.name().get() << "'");  }  d = modelObject.getDouble(OS_Construction_FfactorGroundFloorFields::PerimeterExposed, false);  if (d){    idfObject.setDouble(Construction_FfactorGroundFloorFields::PerimeterExposed, *d);  }else{    LOG(Error, "Missing required input 'PerimeterExposed' for Construction:FfactorGroundFloor named '" << modelObject.name().get() << "'");  }  return boost::optional<IdfObject>(idfObject);}

boost::optional<IdfObject> ForwardTranslator::translateExteriorLights(    model::ExteriorLights& modelObject){  IdfObject idfObject(IddObjectType::Exterior_Lights);  m_idfObjects.push_back(idfObject);  idfObject.setString(Exterior_LightsFields::Name, modelObject.name().get());  OptionalIdfObject relatedIdfObject;  model::Schedule schedule = modelObject.schedule();  relatedIdfObject = translateAndMapModelObject(schedule);  BOOST_ASSERT(relatedIdfObject);  idfObject.setString(Exterior_LightsFields::ScheduleName,relatedIdfObject->name().get());  model::ExteriorLightsDefinition definition = modelObject.exteriorLightsDefinition();  double designLevel = definition.designLevel()*modelObject.multiplier();  idfObject.setDouble(Exterior_LightsFields::DesignLevel,designLevel);  if (!modelObject.isControlOptionDefaulted()) {    idfObject.setString(Exterior_LightsFields::ControlOption,modelObject.controlOption());  }  if (!modelObject.isEndUseSubcategoryDefaulted()) {    idfObject.setString(Exterior_LightsFields::EndUseSubcategory,modelObject.endUseSubcategory());  }  return idfObject;}

boost::optional<IdfObject> ForwardTranslator::createAirLoopHVACSupplyPath( AirLoopHVAC & airLoopHVAC ){  std::string s;  IdfObject supplyPathIdf(openstudio::IddObjectType::AirLoopHVAC_SupplyPath);  m_idfObjects.push_back(supplyPathIdf);  supplyPathIdf.createName();  s = airLoopHVAC.demandInletNodes().front().name().get();  supplyPathIdf.setString(openstudio::AirLoopHVAC_SupplyPathFields::SupplyAirPathInletNodeName,s);  ModelObjectVector modelObjects;  modelObjects = airLoopHVAC.demandComponents( airLoopHVAC.demandInletNodes().front(),                                               airLoopHVAC.demandOutletNode(),                                               openstudio::IddObjectType::OS_AirLoopHVAC_ZoneSplitter );  if( modelObjects.size() == 1 )  {    ModelObject modelObject = modelObjects.front();    OptionalAirLoopHVACZoneSplitter zoneSplitter = modelObject.optionalCast<AirLoopHVACZoneSplitter>();    translateAndMapModelObject(*zoneSplitter);    s = stripOS2(zoneSplitter->iddObject().name());    supplyPathIdf.setString(2,s);    s = zoneSplitter->name().get();    supplyPathIdf.setString(3,s);  }  return boost::optional<IdfObject>(supplyPathIdf);}

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::translateNode( Node & modelObject ){  std::vector<SetpointManager> _setpointManagers = modelObject.setpointManagers();  for(auto _setpointManager : _setpointManagers )  {    translateAndMapModelObject( _setpointManager );  }  return boost::optional<IdfObject>();}

boost::optional<IdfObject> ForwardTranslator::translateInteriorPartitionSurfaceGroup( model::InteriorPartitionSurfaceGroup & modelObject ){  InteriorPartitionSurfaceVector interiorPartitionSurfaces = modelObject.interiorPartitionSurfaces();  std::sort(interiorPartitionSurfaces.begin(), interiorPartitionSurfaces.end(), WorkspaceObjectNameLess());  for (InteriorPartitionSurface& interiorPartitionSurface : interiorPartitionSurfaces){    translateAndMapModelObject(interiorPartitionSurface);  }  return boost::none;}

boost::optional<IdfObject> ForwardTranslator::translateShadingSurfaceGroup( model::ShadingSurfaceGroup & modelObject ){    ShadingSurfaceVector shadingSurfaces = modelObject.shadingSurfaces();  std::sort(shadingSurfaces.begin(), shadingSurfaces.end(), WorkspaceObjectNameLess());  for (ShadingSurface& shadingSurface : shadingSurfaces){    translateAndMapModelObject(shadingSurface);  }  return boost::none;}

boost::optional<IdfObject> ForwardTranslator::translateSetpointManagerScheduledDualSetpoint( SetpointManagerScheduledDualSetpoint & modelObject ){  // Name  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_Scheduled_DualSetpoint, modelObject);  // ControlVariable  std::string s = modelObject.controlVariable();  idfObject.setString(SetpointManager_Scheduled_DualSetpointFields::ControlVariable,s);  // High Setpoint Schedule Name  if( boost::optional<Schedule> highSetpointSchedule = modelObject.highSetpointSchedule() )  {    boost::optional<IdfObject> _highSetpointSchedule = translateAndMapModelObject(highSetpointSchedule.get());    if( _highSetpointSchedule && _highSetpointSchedule->name() )    {      idfObject.setString(SetpointManager_Scheduled_DualSetpointFields::HighSetpointScheduleName,_highSetpointSchedule->name().get());    }  } else {    LOG(Error, "SetpointManager:Scheduled:DualSetpoint '" << modelObject.name().get() << "' is missing required high setpoint schedule");  }  // Low Setpoint Schedule Name  if( boost::optional<Schedule> lowSetpointSchedule = modelObject.lowSetpointSchedule() )  {    boost::optional<IdfObject> _lowSetpointSchedule = translateAndMapModelObject(lowSetpointSchedule.get());    if( _lowSetpointSchedule && _lowSetpointSchedule->name() )    {      idfObject.setString(SetpointManager_Scheduled_DualSetpointFields::LowSetpointScheduleName,_lowSetpointSchedule->name().get());    }  } else {    LOG(Error, "SetpointManager:Scheduled:DualSetpoint '" << modelObject.name().get() << "' is missing required low setpoint schedule");  }  // SetpointNodeorNodeListName  if( boost::optional<Node> node = modelObject.setpointNode() )  {    idfObject.setString(SetpointManager_Scheduled_DualSetpointFields::SetpointNodeorNodeListName,node->name().get());  }  return idfObject;}

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::translateConstruction( Construction & modelObject ){  IdfObject construction( openstudio::IddObjectType::Construction );  m_idfObjects.push_back(construction);  for (LifeCycleCost lifeCycleCost : modelObject.lifeCycleCosts()){    translateAndMapModelObject(lifeCycleCost);  }  construction.setName(modelObject.name().get());  MaterialVector layers = modelObject.layers();  unsigned fieldIndex = 1;  for(unsigned layerIndex = 0; layerIndex < layers.size(); ++layerIndex ) {    Material material = layers[layerIndex];    translateAndMapModelObject(material);    construction.setString(fieldIndex++, material.name().get());  }  return boost::optional<IdfObject>(construction);}

boost::optional<IdfObject> ForwardTranslator::translateZoneHVACEquipmentList( ZoneHVACEquipmentList & modelObject ){  OptionalString s;  OptionalDouble d;  OptionalModelObject temp;  std::vector<ModelObject> objects = modelObject.equipment();  if (objects.empty()){    // do not write out this object    return boost::none;  }  IdfObject idfObject(IddObjectType::ZoneHVAC_EquipmentList);  // Name  s = modelObject.name();  if(s)  {    idfObject.setName(*s);  }  for( std::vector<ModelObject>::iterator it = objects.begin();       it != objects.end();       it++ )  {    unsigned coolingPriority = modelObject.coolingPriority(*it);    unsigned heatingPriority = modelObject.heatingPriority(*it);    boost::optional<IdfObject> _equipment = translateAndMapModelObject(*it);    if( _equipment )    {      IdfExtensibleGroup eg = idfObject.pushExtensibleGroup();      eg.setString(ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentObjectType,_equipment->iddObject().name());       eg.setString(ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentName,_equipment->name().get());       eg.setUnsigned(ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentCoolingSequence,coolingPriority);       eg.setUnsigned(ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentHeatingorNoLoadSequence,heatingPriority);     }  }  m_idfObjects.push_back(idfObject);  return idfObject;}

boost::optional<IdfObject> ForwardTranslator::translatePlantEquipmentOperationOutdoorWetBulbDifference( PlantEquipmentOperationOutdoorWetBulbDifference & modelObject ){    IdfObject idfObject(IddObjectType::PlantEquipmentOperation_OutdoorWetBulbDifference);    m_idfObjects.push_back(idfObject);    // Name    auto name = modelObject.name().get();    idfObject.setName(name);    // ReferenceTemperatureNodeName    if( const auto & node = modelObject.referenceTemperatureNode() ) {        idfObject.setString(PlantEquipmentOperation_OutdoorWetBulbDifferenceFields::ReferenceTemperatureNodeName,node->name().get());    }    double lowerLimit = modelObject.minimumLowerLimit();    int i = 1;    for( auto upperLimit : modelObject.loadRangeUpperLimits() ) {        auto equipment = modelObject.equipment(upperLimit);        if( ! equipment.empty() ) {            auto eg = idfObject.pushExtensibleGroup();            eg.setDouble(PlantEquipmentOperation_OutdoorWetBulbDifferenceExtensibleFields::WetBulbTemperatureDifferenceRangeLowerLimit,lowerLimit);            eg.setDouble(PlantEquipmentOperation_OutdoorWetBulbDifferenceExtensibleFields::WetBulbTemperatureDifferenceRangeUpperLimit,upperLimit);            IdfObject equipmentList(IddObjectType::PlantEquipmentList);            m_idfObjects.push_back(equipmentList);            auto equipmentListName = name + " equipment list " + std::to_string(i);            equipmentList.setName(equipmentListName);            eg.setString(PlantEquipmentOperation_OutdoorWetBulbDifferenceExtensibleFields::RangeEquipmentListName,equipmentListName);            for( auto component : equipment ) {                auto eg2 = equipmentList.pushExtensibleGroup();                auto idf_component = translateAndMapModelObject(component);                OS_ASSERT(idf_component);                eg2.setString(PlantEquipmentListExtensibleFields::EquipmentObjectType,idf_component->iddObject().name());                eg2.setString(PlantEquipmentListExtensibleFields::EquipmentName,idf_component->name().get());            }        }        lowerLimit = upperLimit;        ++i;    }    return idfObject;}

boost::optional<IdfObject> ForwardTranslator::translateSite( Site & modelObject ){  IdfObject site = createAndRegisterIdfObject(openstudio::IddObjectType::Site_Location,                                              modelObject);  OptionalString optS = modelObject.name();  if(optS) {    site.setName(*optS);  }  OptionalDouble od = modelObject.latitude();  if(od) {    site.setDouble(Site_LocationFields::Latitude, *od);  }  od = modelObject.longitude();  if(od) {    site.setDouble(Site_LocationFields::Longitude, *od);  }  od = modelObject.timeZone();  if(od) {    site.setDouble(Site_LocationFields::TimeZone, *od);  }  od = modelObject.elevation();  if(od) {    site.setDouble(Site_LocationFields::Elevation, *od);  }  // translate shading groups  ShadingSurfaceGroupVector shadingSurfaceGroups = modelObject.shadingSurfaceGroups();  std::sort(shadingSurfaceGroups.begin(), shadingSurfaceGroups.end(), WorkspaceObjectNameLess());  for (ShadingSurfaceGroup& shadingSurfaceGroup : shadingSurfaceGroups){    translateAndMapModelObject(shadingSurfaceGroup);  }  return boost::optional<IdfObject>(site);}

boost::optional<IdfObject> ForwardTranslator::translateCoilHeatingDXSingleSpeed( CoilHeatingDXSingleSpeed & modelObject ){  IdfObject _coilSystemHeatingDX(IddObjectType::CoilSystem_Heating_DX);      m_idfObjects.push_back(_coilSystemHeatingDX);  boost::optional<IdfObject> _coilHeatingDXSingleSpeed = translateCoilHeatingDXSingleSpeedWithoutUnitary(modelObject);  OS_ASSERT(_coilHeatingDXSingleSpeed);  OptionalString s;  s = modelObject.name();  // Type and Name  if( s )  {    _coilSystemHeatingDX.setString(CoilSystem_Heating_DXFields::HeatingCoilObjectType,_coilHeatingDXSingleSpeed->iddObject().name());    _coilSystemHeatingDX.setString(CoilSystem_Heating_DXFields::HeatingCoilName,*s);    _coilSystemHeatingDX.setName(*s + " CoilSystem");  }  // Availability Schedule  Schedule schedule = modelObject.availabilitySchedule();  boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule);  if( _schedule )  {    _coilSystemHeatingDX.setString(CoilSystem_Heating_DXFields::AvailabilityScheduleName,_schedule->name().get());  }  return _coilSystemHeatingDX;}

boost::optional<IdfObject> ForwardTranslator::translateZoneHVACBaseboardConvectiveElectric(    ZoneHVACBaseboardConvectiveElectric & modelObject ){  // Makes sure the modelObject gets put in the map, and that the new idfObject gets put in   // the final file. Also set's the idfObject's name.  IdfObject idfObject = createRegisterAndNameIdfObject(IddObjectType::ZoneHVAC_Baseboard_Convective_Electric,modelObject);  boost::optional<std::string> s;  boost::optional<double> value;  boost::optional<ModelObject> temp;    // AvailabilityScheduleName  Schedule availabilitySchedule = modelObject.availabilitySchedule();  translateAndMapModelObject(availabilitySchedule);  idfObject.setString(ZoneHVAC_Baseboard_Convective_ElectricFields::AvailabilityScheduleName,                      availabilitySchedule.name().get() );  // NominalCapacity  if( modelObject.isNominalCapacityAutosized() )  {    idfObject.setString(ZoneHVAC_Baseboard_Convective_ElectricFields::NominalCapacity,"Autosize");  }  else if( value = modelObject.nominalCapacity() )  {    idfObject.setDouble(ZoneHVAC_Baseboard_Convective_ElectricFields::NominalCapacity,value.get());  }  // Efficiency  if( value = modelObject.efficiency() )  {    idfObject.setDouble(ZoneHVAC_Baseboard_Convective_ElectricFields::Efficiency,value.get());  }  return idfObject;}

boost::optional<IdfObject> ForwardTranslator::translateSolarCollectorPerformancePhotovoltaicThermalSimple(model::SolarCollectorPerformancePhotovoltaicThermalSimple & modelObject){  IdfObject idfObject(openstudio::IddObjectType::SolarCollectorPerformance_PhotovoltaicThermal_Simple);  m_idfObjects.push_back(idfObject);  boost::optional<double> d;  idfObject.setString(SolarCollectorPerformance_PhotovoltaicThermal_SimpleFields::Name, modelObject.name().get());  idfObject.setDouble(SolarCollectorPerformance_PhotovoltaicThermal_SimpleFields::FractionofSurfaceAreawithActiveThermalCollector, modelObject.fractionOfSurfaceAreaWithActiveThermalCollector());  std::string thermalConversionEfficiencyInputModeType = modelObject.thermalConversionEfficiencyInputModeType();  idfObject.setString(SolarCollectorPerformance_PhotovoltaicThermal_SimpleFields::ThermalConversionEfficiencyInputModeType, thermalConversionEfficiencyInputModeType);  if (istringEqual("Scheduled", thermalConversionEfficiencyInputModeType)){    boost::optional<Schedule> schedule = modelObject.thermalConversionEfficiencySchedule();    if (schedule){      boost::optional<IdfObject> relatedIdfObject = translateAndMapModelObject(*schedule);      OS_ASSERT(relatedIdfObject);      idfObject.setString(SolarCollectorPerformance_PhotovoltaicThermal_SimpleFields::ThermalConversionEfficiencyScheduleName, relatedIdfObject->name().get());    } else{      LOG(Error, "SolarCollectorPerformance:PhotovoltaicThermal:Simple object named '" << modelObject.name().get() << "' has ThermalConversionEfficiencyInputModeType of Scheduled but has no schedule attached.");    }  } else {    d = modelObject.thermalConversionEfficiency();    if (d){      idfObject.setDouble(SolarCollectorPerformance_PhotovoltaicThermal_SimpleFields::ValueforThermalConversionEfficiencyifFixed, *d);    }else{      LOG(Error, "SolarCollectorPerformance:PhotovoltaicThermal:Simple object named '" << modelObject.name().get() << "' has ThermalConversionEfficiencyInputModeType of Fixed but has no value set.");    }  }  idfObject.setDouble(SolarCollectorPerformance_PhotovoltaicThermal_SimpleFields::FrontSurfaceEmittance, modelObject.frontSurfaceEmittance());  return idfObject;}

boost::optional<IdfObject> ForwardTranslator::translateScheduleCompact( ScheduleCompact & modelObject ){  IdfObject scheduleCompact = createAndRegisterIdfObject(openstudio::IddObjectType::Schedule_Compact,                                                         modelObject);  OptionalString os;  if ((os = modelObject.name())) {    scheduleCompact.setName(*os);  }  boost::optional<ScheduleTypeLimits> scheduleTypeLimits = modelObject.scheduleTypeLimits();  if (scheduleTypeLimits){    boost::optional<IdfObject> idfScheduleTypeLimits = translateAndMapModelObject(*scheduleTypeLimits);    if (idfScheduleTypeLimits){      scheduleCompact.setString(Schedule_CompactFields::ScheduleTypeLimitsName, idfScheduleTypeLimits->name().get());    }  }  for (const IdfExtensibleGroup& eg : modelObject.extensibleGroups()) {    scheduleCompact.pushExtensibleGroup(eg.fields());  }  return boost::optional<IdfObject>(scheduleCompact);}

boost::optional<IdfObject> ForwardTranslator::translateCoilHeatingElectric( CoilHeatingElectric & modelObject ){  boost::optional<std::string> s;  boost::optional<double> value;  IdfObject idfObject(IddObjectType::Coil_Heating_Electric);  m_idfObjects.push_back(idfObject);  // Name  s = modelObject.name();  if( s )  {    idfObject.setName(*s);  }  // AvailabilityScheduleName  if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() )  {    if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )    {      idfObject.setString(Coil_Heating_ElectricFields::AvailabilityScheduleName,_schedule->name().get());    }  }  // Efficiency  if( (value = modelObject.efficiency()) )  {    idfObject.setDouble(Coil_Heating_ElectricFields::Efficiency,value.get());  }  // Nominal Capacity     if( modelObject.isNominalCapacityAutosized() )  {    idfObject.setString(Coil_Heating_ElectricFields::NominalCapacity,"Autosize");  }  else if( (value = modelObject.nominalCapacity()) )  {    idfObject.setDouble(Coil_Heating_ElectricFields::NominalCapacity,value.get());  }  // Air Inlet Node Name   if( boost::optional<ModelObject> mo = modelObject.inletModelObject() )  {    if( boost::optional<Node> node = mo->optionalCast<Node>() )    {      idfObject.setString(Coil_Heating_ElectricFields::AirInletNodeName,node->name().get());    }  }  // Air Outlet Node Name   if( boost::optional<ModelObject> mo = modelObject.outletModelObject() )  {    if( boost::optional<Node> node = mo->optionalCast<Node>() )    {      idfObject.setString(Coil_Heating_ElectricFields::AirOutletNodeName,node->name().get());    }  }  // Temperature Setpoint Node Name    if( boost::optional<Node> node = modelObject.temperatureSetpointNode() )  {    idfObject.setString(Coil_Heating_ElectricFields::TemperatureSetpointNodeName,node->name().get());  }  return idfObject;}

boost::optional<IdfObject> ForwardTranslator::translateZoneHVACIdealLoadsAirSystem(ZoneHVACIdealLoadsAirSystem & modelObject){    IdfObject zoneHVACIdealLoadsAirSystem = createRegisterAndNameIdfObject(openstudio::IddObjectType::ZoneHVAC_IdealLoadsAirSystem,modelObject);    // availability schedule name  boost::optional<Schedule> schedule = modelObject.availabilitySchedule();  if(schedule){    boost::optional<IdfObject> idfSchedule = translateAndMapModelObject(*schedule);    if(idfSchedule){      zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName,idfSchedule->name().get());    }  }  // zone supply air node name  boost::optional<std::string> zoneSupplyAirNodeName;  if(boost::optional<Node> node = modelObject.outletNode()){    if(boost::optional<std::string> s = node->name()){      zoneSupplyAirNodeName = s;      zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::ZoneSupplyAirNodeName,s.get());    }  }  // zone exhaust air node name  boost::optional<std::string> zoneExhaustAirNodeName;  if(boost::optional<Node> node = modelObject.inletNode()){    if(boost::optional<std::string> s = node->name()){      zoneExhaustAirNodeName = s;      zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::ZoneExhaustAirNodeName,s.get());    }  }  // maximum heating supply air temperature  if(! modelObject.isMaximumHeatingSupplyAirTemperatureDefaulted()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirTemperature,modelObject.maximumHeatingSupplyAirTemperature());  }  // minimum cooling supply air temperature  if (! modelObject.isMinimumCoolingSupplyAirTemperatureDefaulted()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirTemperature,modelObject.minimumCoolingSupplyAirTemperature());  }  // maximum heating supply air humidity ratio  if (! modelObject.isMaximumHeatingSupplyAirHumidityRatioDefaulted()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirHumidityRatio,modelObject.maximumHeatingSupplyAirHumidityRatio());  }  // minimum cooling supply air humidity ratio  if (! modelObject.isMinimumCoolingSupplyAirHumidityRatioDefaulted()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirHumidityRatio,modelObject.minimumCoolingSupplyAirHumidityRatio());  }  // heating limit  if (! modelObject.isHeatingLimitDefaulted()){    zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit,modelObject.heatingLimit());  }  // maximum heating air flow rate  if(modelObject.isMaximumHeatingAirFlowRateAutosized()){    zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate,"Autosize");  }else if(boost::optional<double> d = modelObject.maximumHeatingAirFlowRate()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate,d.get());  }  // maximum sensible heating capacity  if(modelObject.isMaximumSensibleHeatingCapacityAutosized()){    zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity,"Autosize");  }else if(boost::optional<double> d = modelObject.maximumSensibleHeatingCapacity()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity,d.get());  }  // cooling limit  if (! modelObject.isCoolingLimitDefaulted()){    zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit,modelObject.coolingLimit());  }  // maximum cooling air flow rate  if(modelObject.isMaximumCoolingAirFlowRateAutosized()){    zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate,"Autosize");  }else if(boost::optional<double> d = modelObject.maximumCoolingAirFlowRate()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate,d.get());  }  // maximum total cooling capacity  if(modelObject.isMaximumTotalCoolingCapacityAutosized()){    zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity,"Autosize");  }else if(boost::optional<double> d = modelObject.maximumTotalCoolingCapacity()){    zoneHVACIdealLoadsAirSystem.setDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity,d.get());  }  // heating availability schedule name  if(boost::optional<Schedule> schedule = modelObject.heatingAvailabilitySchedule()){    if(boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get())){      zoneHVACIdealLoadsAirSystem.setString(ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName,_schedule->name().get());    }  } // cooling availability schedule name  if(boost::optional<Schedule> schedule = modelObject.coolingAvailabilitySchedule()){    if(boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get())){//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctVAVReheat( AirTerminalSingleDuctVAVReheat & modelObject ){  OptionalModelObject temp;  OptionalString optS;  boost::optional<std::string> s;  std::string baseName = modelObject.name().get();  IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);  _airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit  IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_VAV_Reheat);  idfObject.setName(baseName);  HVACComponent coil = modelObject.reheatCoil();  m_idfObjects.push_back(_airDistributionUnit);  m_idfObjects.push_back(idfObject);  boost::optional<IdfObject> _reheatCoil = translateAndMapModelObject(coil);  if( _reheatCoil && _reheatCoil->name() )  {    std::string damperOutletNodeName = modelObject.name().get() + " Damper Outlet";    boost::optional<std::string> inletNodeName;    boost::optional<std::string> outletNodeName;    if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )    {      if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )      {        inletNodeName = inletNode->name().get();      }    }    if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )    {      if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )      {        outletNodeName = outletNode->name().get();      }    }    // Reheat Coil Name    idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::ReheatCoilName,_reheatCoil->name().get());    // Reheat Coil Type    idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::ReheatCoilObjectType,_reheatCoil->iddObject().name());    idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::DamperAirOutletNodeName,damperOutletNodeName);    if( outletNodeName && inletNodeName )    {      if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )      {        _reheatCoil->setString(Coil_Heating_GasFields::AirInletNodeName,damperOutletNodeName);        _reheatCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,outletNodeName.get());      }      else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )      {        _reheatCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,damperOutletNodeName);        _reheatCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,outletNodeName.get());      }      else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )      {        _reheatCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,damperOutletNodeName);        _reheatCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,outletNodeName.get());      }      idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::AirOutletNodeName,outletNodeName.get());      idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::AirInletNodeName,inletNodeName.get());    }  }  else  {    LOG(Error,modelObject.briefDescription() << ": Could not translate heating coil");    return boost::none;  }  // AvailabilityScheduleName  Schedule availabilitySchedule = modelObject.availabilitySchedule();  boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule);  if( _availabilitySchedule && _availabilitySchedule->name() )  {    idfObject.setString(AirTerminal_SingleDuct_VAV_ReheatFields::AvailabilityScheduleName,_availabilitySchedule->name().get());  }  // MaximumAirFlowRate  boost::optional<double> value = modelObject.maximumAirFlowRate();  if( value )  {    idfObject.setDouble(AirTerminal_SingleDuct_VAV_ReheatFields::MaximumAirFlowRate,value.get());  }  else if( modelObject.isMaximumAirFlowRateAutosized() )//.........这里部分代码省略.........

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());    }//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translatePlantEquipmentOperationSchemes( PlantLoop & plantLoop ){  IdfObject operationSchemes(IddObjectType::PlantEquipmentOperationSchemes);  m_idfObjects.push_back(operationSchemes);  operationSchemes.setName(plantLoop.name().get() + " Operation Schemes");  // Lambda does what the name suggests, create setpoint operation schemes.  // This is for any component that has a setpoint manager on its outlet node  auto createSetpointOperationScheme = [&](PlantLoop & plantLoop) {    const auto & t_setpointComponents = setpointComponents(plantLoop);    if( ! t_setpointComponents.empty() ) {      Schedule alwaysOn = plantLoop.model().alwaysOnDiscreteSchedule();      IdfObject setpointOperation(IddObjectType::PlantEquipmentOperation_ComponentSetpoint);      setpointOperation.setName(plantLoop.name().get() + " Setpoint Operation Scheme");      m_idfObjects.push_back(setpointOperation);      setpointOperation.clearExtensibleGroups();      IdfExtensibleGroup eg = operationSchemes.pushExtensibleGroup();      eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,setpointOperation.iddObject().name());      eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,setpointOperation.name().get());      eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());      for( auto setpointComponent : t_setpointComponents )      {        boost::optional<IdfObject> _idfObject = translateAndMapModelObject(setpointComponent);        OS_ASSERT(_idfObject);        IdfExtensibleGroup eg = setpointOperation.pushExtensibleGroup();        eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::EquipmentObjectType,_idfObject->iddObject().name());        eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::EquipmentName,_idfObject->name().get());        if( const auto & t_inletNode = inletNode(plantLoop,setpointComponent) ) {          eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::DemandCalculationNodeName,t_inletNode->name().get());        }        if( const auto & t_outletNode = outletNode(plantLoop,setpointComponent) ) {          eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::SetpointNodeName,t_outletNode->name().get());        }        if( auto value = flowrate(setpointComponent) ) {          eg.setDouble(PlantEquipmentOperation_ComponentSetpointExtensibleFields::ComponentFlowRate,value.get());        } else {          eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::ComponentFlowRate,"Autosize");        }        auto t_componentType = componentType(setpointComponent);        switch(t_componentType)        {          case ComponentType::HEATING :            eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::OperationType,"Heating");            break;          case ComponentType::COOLING :            eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::OperationType,"Cooling");            break;          default :            eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::OperationType,"Dual");            break;        }      }    }  };  Schedule alwaysOn = plantLoop.model().alwaysOnDiscreteSchedule();  bool applyDefault = true;  // If any operation schemes are defined in the model then don't apply default operation schemes  if( auto coolingLoadScheme = plantLoop.plantEquipmentOperationCoolingLoad() ) {    auto _scheme = translateAndMapModelObject(coolingLoadScheme.get());    OS_ASSERT(_scheme);    auto eg = operationSchemes.pushExtensibleGroup();    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,_scheme->iddObject().name());    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,_scheme->name().get());    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());    applyDefault = false;  }   if( auto heatingLoadScheme = plantLoop.plantEquipmentOperationHeatingLoad() ) {    auto _scheme = translateAndMapModelObject(heatingLoadScheme.get());    OS_ASSERT(_scheme);    auto eg = operationSchemes.pushExtensibleGroup();    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,_scheme->iddObject().name());    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,_scheme->name().get());    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());    applyDefault = false;  }  if( auto primaryScheme = plantLoop.primaryPlantEquipmentOperationScheme() ) {    auto _scheme = translateAndMapModelObject(primaryScheme.get());    OS_ASSERT(_scheme);    auto eg = operationSchemes.pushExtensibleGroup();    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,_scheme->iddObject().name());    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,_scheme->name().get());    eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());    createSetpointOperationScheme(plantLoop);    applyDefault = false;  }  if( applyDefault ) {//.........这里部分代码省略.........

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);    }//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translateDesignDay( DesignDay & modelObject ){  IdfObject idfObject( openstudio::IddObjectType::SizingPeriod_DesignDay);  // Name  idfObject.setName(modelObject.name().get());  // Month  idfObject.setInt(SizingPeriod_DesignDayFields::Month, modelObject.month());  // Day of Month  idfObject.setInt(SizingPeriod_DesignDayFields::DayofMonth, modelObject.dayOfMonth());  // Day Type  idfObject.setString(SizingPeriod_DesignDayFields::DayType, modelObject.dayType());  // Maximum Dry-Bulb Temperature  idfObject.setDouble(SizingPeriod_DesignDayFields::MaximumDryBulbTemperature, modelObject.maximumDryBulbTemperature());  // Dry-Bulb Temperature Range Modifier Type  std::string dryBulbTemperatureRangeModifierType = modelObject.dryBulbTemperatureRangeModifierType();  idfObject.setString(SizingPeriod_DesignDayFields::DryBulbTemperatureRangeModifierType, dryBulbTemperatureRangeModifierType);  // Daily Dry-Bulb Temperature Range  if (!istringEqual(dryBulbTemperatureRangeModifierType, "DifferenceSchedule")){    idfObject.setDouble(SizingPeriod_DesignDayFields::DailyDryBulbTemperatureRange, modelObject.dailyDryBulbTemperatureRange());  }  // Dry-Bulb Temperature Range Modifier Day Schedule Name  if (istringEqual(dryBulbTemperatureRangeModifierType, "MultiplierSchedule") || istringEqual(dryBulbTemperatureRangeModifierType, "DifferenceSchedule")){    boost::optional<IdfObject> idfSchedule;    if( boost::optional<ScheduleDay> schedule = modelObject.dryBulbTemperatureRangeModifierSchedule() ){      idfSchedule = translateAndMapModelObject(*schedule);    }    if (idfSchedule){      idfObject.setString(SizingPeriod_DesignDayFields::DryBulbTemperatureRangeModifierDayScheduleName, idfSchedule->name().get());    }else{      LOG(Error, "Dry Bulb Temperature Range Modifier Day Schedule Name field is required but not found");    }  }  // Humidity Condition Type  std::string humidityIndicatingType = modelObject.humidityIndicatingType();  if (istringEqual(humidityIndicatingType, "Schedule")){    humidityIndicatingType = "RelativeHumiditySchedule";  }  idfObject.setString(SizingPeriod_DesignDayFields::HumidityConditionType, humidityIndicatingType);  // Wetbulb or DewPoint at Maximum Dry-Bulb  if (istringEqual(humidityIndicatingType, "Wetbulb") ||      istringEqual(humidityIndicatingType, "Dewpoint") ||      istringEqual(humidityIndicatingType, "WetBulbProfileMultiplierSchedule") ||      istringEqual(humidityIndicatingType, "WetBulbProfileDifferenceSchedule") ||      istringEqual(humidityIndicatingType, "WetBulbProfileDefaultMultipliers")){    // units for this field are C    idfObject.setDouble(SizingPeriod_DesignDayFields::WetbulborDewPointatMaximumDryBulb, modelObject.humidityIndicatingConditionsAtMaximumDryBulb());  }  // Humidity Condition Day Schedule Name  if (istringEqual(humidityIndicatingType, "RelativeHumiditySchedule") ||      istringEqual(humidityIndicatingType, "WetBulbProfileMultiplierSchedule") ||      istringEqual(humidityIndicatingType, "WetBulbProfileDifferenceSchedule") ||      istringEqual(humidityIndicatingType, "RelativeHumiditySchedule")){    if( boost::optional<ScheduleDay> schedule = modelObject.humidityIndicatingDaySchedule() ){      idfObject.setString(SizingPeriod_DesignDayFields::HumidityConditionDayScheduleName, schedule->name().get());    }else{      LOG(Error, "Humidity Condition Day Schedule Name field is required but not found");    }  }  // Humidity Ratio at Maximum Dry-Bulb  if (istringEqual(humidityIndicatingType, "HumidityRatio")){    // units for this field are kgWater/kgDryAir    idfObject.setDouble(SizingPeriod_DesignDayFields::HumidityRatioatMaximumDryBulb, modelObject.humidityIndicatingConditionsAtMaximumDryBulb());  }  // Enthalpy at Maximum Dry-Bulb  if (istringEqual(humidityIndicatingType, "Enthalpy")){    // units for this field are J/kg    idfObject.setDouble(SizingPeriod_DesignDayFields::EnthalpyatMaximumDryBulb, modelObject.humidityIndicatingConditionsAtMaximumDryBulb());  }  // Daily Wet-Bulb Temperature Range  if (istringEqual(humidityIndicatingType, "WetbulbProfileMultiplierSchedule") ||      istringEqual(humidityIndicatingType, "WetBulbProfileDefaultMultipliers")){    if ( OptionalDouble d = modelObject.dailyWetBulbTemperatureRange()) {      idfObject.setDouble(SizingPeriod_DesignDayFields::DailyWetBulbTemperatureRange, *d);    }else{      LOG(Error, "Daily Wet Bulb Temperature Range field is required but not found");    }  }  // Barometric Pressure  idfObject.setDouble(SizingPeriod_DesignDayFields::BarometricPressure, modelObject.barometricPressure());  // Site Wind Speed  idfObject.setDouble(SizingPeriod_DesignDayFields::WindSpeed, modelObject.windSpeed());  // Site Wind Direction//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translateSizingZone( SizingZone & modelObject ){  boost::optional<std::string> s;  boost::optional<double> value;  IdfObject idfObject(IddObjectType::Sizing_Zone);  m_idfObjects.push_back(idfObject);  // ZoneorZoneListName  model::ThermalZone thermalZone = modelObject.thermalZone();  boost::optional<IdfObject> _thermalZone = translateAndMapModelObject(thermalZone);  boost::optional<std::string> name;  if( _thermalZone )  {    name = _thermalZone->name();  }  if( name )  {    idfObject.setString(Sizing_ZoneFields::ZoneorZoneListName,name.get());  }  // ZoneCoolingDesignSupplyAirTemperatureInputMethod  idfObject.setString(Sizing_ZoneFields::ZoneCoolingDesignSupplyAirTemperatureInputMethod,"SupplyAirTemperature");  // ZoneCoolingDesignSupplyAirTemperature  value = modelObject.zoneCoolingDesignSupplyAirTemperature();  if( value )  {    idfObject.setDouble(Sizing_ZoneFields::ZoneCoolingDesignSupplyAirTemperature,value.get());  }  // ZoneHeatingDesignSupplyAirTemperatureInputMethod  idfObject.setString(Sizing_ZoneFields::ZoneHeatingDesignSupplyAirTemperatureInputMethod,"SupplyAirTemperature");  // ZoneHeatingDesignSupplyAirTemperature  value = modelObject.zoneHeatingDesignSupplyAirTemperature();  if( value )  {    idfObject.setDouble(Sizing_ZoneFields::ZoneHeatingDesignSupplyAirTemperature,value.get());  }  // ZoneCoolingDesignSupplyAirHumidityRatio    value = modelObject.zoneCoolingDesignSupplyAirHumidityRatio();  if( value )  {    idfObject.setDouble(Sizing_ZoneFields::ZoneCoolingDesignSupplyAirHumidityRatio,value.get());  }  // ZoneHeatingDesignSupplyAirHumidityRatio    value = modelObject.zoneHeatingDesignSupplyAirHumidityRatio();  if( value )  {    idfObject.setDouble(Sizing_ZoneFields::ZoneHeatingDesignSupplyAirHumidityRatio,value.get());  }  //  ((DesignSpecificationOutdoorAirObjectName)(Design Specification Outdoor Air Object Name))    // ZoneHeatingSizingFactor     value = modelObject.zoneHeatingSizingFactor();  if( value )  {    idfObject.setDouble(Sizing_ZoneFields::ZoneHeatingSizingFactor,value.get());  }    // ZoneCoolingSizingFactor     value = modelObject.zoneCoolingSizingFactor();  if( value )  {    idfObject.setDouble(Sizing_ZoneFields::ZoneCoolingSizingFactor,value.get());  }  // CoolingDesignAirFlowMethod    s = modelObject.coolingDesignAirFlowMethod();  if( s )  {    idfObject.setString(Sizing_ZoneFields::CoolingDesignAirFlowMethod,s.get());  }  // CoolingDesignAirFlowRate    value = modelObject.coolingDesignAirFlowRate();  if( value )  {    idfObject.setDouble(Sizing_ZoneFields::CoolingDesignAirFlowRate,value.get());  }//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translateZoneHVACPackagedTerminalAirConditioner(     ZoneHVACPackagedTerminalAirConditioner & modelObject ){  boost::optional<std::string> s;  boost::optional<double> value;  IdfObject idfObject(IddObjectType::ZoneHVAC_PackagedTerminalAirConditioner);  m_idfObjects.push_back(idfObject);  // Name  std::string baseName = modelObject.name().get();  idfObject.setName(baseName);  std::string mixedAirNodeName = baseName + " Mixed Air Node";  std::string coolingCoilOutletNodeName = baseName + " Cooling Coil Outlet Node";  std::string heatingCoilOutletNodeName = baseName + " Heating Coil Outlet Node";  std::string reliefAirNodeName = baseName + " Relief Air Node";  std::string oaNodeName = baseName + " OA Node";  // AvailabilityScheduleName  if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() )  {    if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )    {      idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AvailabilityScheduleName,_schedule->name().get());    }  }  // AirInletNodeName  boost::optional<std::string> airInletNodeName;  if( boost::optional<Node> node = modelObject.inletNode() )  {    if( (s = node->name()) )    {      airInletNodeName = s;      idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AirInletNodeName,s.get());    }  }  // AirOutletNodeName  boost::optional<std::string> airOutletNodeName;  if( boost::optional<Node> node = modelObject.outletNode() )  {    if( (s = node->name()) )    {      airOutletNodeName = s;      idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AirOutletNodeName,s.get());    }  }  // OutdoorAirMixerObjectType  idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirMixerObjectType,                      modelObject.outdoorAirMixerObjectType());  // OutdoorAirMixerName    std::string oaMixerName = modelObject.name().get() + " OA Mixer";    idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirMixerName,oaMixerName);  IdfObject _outdoorAirMixer(IddObjectType::OutdoorAir_Mixer);  _outdoorAirMixer.setName(oaMixerName);  m_idfObjects.push_back(_outdoorAirMixer);  _outdoorAirMixer.setString(OutdoorAir_MixerFields::MixedAirNodeName,mixedAirNodeName);  _outdoorAirMixer.setString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName,oaNodeName);  IdfObject _oaNodeList(openstudio::IddObjectType::OutdoorAir_NodeList);  _oaNodeList.setString(0,oaNodeName);  m_idfObjects.push_back(_oaNodeList);  _outdoorAirMixer.setString(OutdoorAir_MixerFields::ReliefAirStreamNodeName,reliefAirNodeName);  if(airInletNodeName)  {    _outdoorAirMixer.setString(OutdoorAir_MixerFields::ReturnAirStreamNodeName,airInletNodeName.get());  }  // SupplyAirFlowRateDuringCoolingOperation  if( modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized() )  {    idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringCoolingOperation,"Autosize");  }  else if( (value = modelObject.supplyAirFlowRateDuringCoolingOperation()) )//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctConstantVolumeReheat( AirTerminalSingleDuctConstantVolumeReheat& modelObject ){  OptionalModelObject temp;  OptionalString optS;  boost::optional<std::string> s;  std::string baseName = modelObject.name().get();  IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);  _airDistributionUnit.setName("ADU " + baseName ); //ADU: Air Distribution Unit  IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_ConstantVolume_Reheat);  idfObject.setName(baseName);  HVACComponent coil = modelObject.reheatCoil();  m_idfObjects.push_back(_airDistributionUnit);  m_idfObjects.push_back(idfObject);  boost::optional<IdfObject> _reheatCoil = translateAndMapModelObject(coil);  if( _reheatCoil && _reheatCoil->name() )  {    boost::optional<std::string> inletNodeName;    boost::optional<std::string> outletNodeName;    if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )    {      if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )      {        inletNodeName = inletNode->name().get();      }    }    if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )    {      if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )      {        outletNodeName = outletNode->name().get();      }    }    // Reheat Coil Name    idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::ReheatCoilName,_reheatCoil->name().get());    // Reheat Coil Type    idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::ReheatCoilObjectType,_reheatCoil->iddObject().name());    if( outletNodeName && inletNodeName )    {      if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )      {        _reheatCoil->setString(Coil_Heating_GasFields::AirInletNodeName,inletNodeName.get());        _reheatCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,outletNodeName.get());      }      else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )      {        _reheatCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,inletNodeName.get());        _reheatCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,outletNodeName.get());      }      else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )      {        _reheatCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,inletNodeName.get());        _reheatCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,outletNodeName.get());      }      idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::AirOutletNodeName,outletNodeName.get());      idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::AirInletNodeName,inletNodeName.get());    }  }  else  {    LOG(Error,modelObject.briefDescription() << ": Could not translate heating coil");    return boost::none;  }  // AvailabilityScheduleName  Schedule availabilitySchedule = modelObject.availabilitySchedule();  boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule);  if( _availabilitySchedule && _availabilitySchedule->name() )  {    idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::AvailabilityScheduleName,_availabilitySchedule->name().get());  }  // MaximumAirFlowRate  boost::optional<double> value = modelObject.maximumAirFlowRate();  if( value )  {    idfObject.setDouble(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MaximumAirFlowRate,value.get());  }  else if( modelObject.isMaximumAirFlowRateAutosized() )  {    idfObject.setString(AirTerminal_SingleDuct_ConstantVolume_ReheatFields::MaximumAirFlowRate,"Autosize");  }//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translateCoilHeatingWater( CoilHeatingWater & modelObject ){  boost::optional<std::string> s;  boost::optional<double> value;  IdfObject idfObject(IddObjectType::Coil_Heating_Water);  m_idfObjects.push_back(idfObject);  s = modelObject.name();  if( s )  {    idfObject.setName(*s);  }  Schedule sched = modelObject.availableSchedule();  boost::optional<IdfObject> _sched = translateAndMapModelObject(sched);  if( _sched )  {    idfObject.setString(Coil_Heating_WaterFields::AvailabilityScheduleName,                        _sched->name().get() );  }  // UFactorTimesAreaValue  if( modelObject.isUFactorTimesAreaValueAutosized() )  {    idfObject.setString(Coil_Heating_WaterFields::UFactorTimesAreaValue,"Autosize");  }  else if( (value = modelObject.uFactorTimesAreaValue()) )  {    idfObject.setDouble(Coil_Heating_WaterFields::UFactorTimesAreaValue,value.get());  }  // MaximumWaterFlowRate  if( modelObject.isMaximumWaterFlowRateAutosized() )  {    idfObject.setString(Coil_Heating_WaterFields::MaximumWaterFlowRate,"Autosize");  }  else if( (value = modelObject.maximumWaterFlowRate()) )  {    idfObject.setDouble(Coil_Heating_WaterFields::MaximumWaterFlowRate,value.get());  }  // WaterInletNodeName  if( boost::optional<ModelObject> mo = modelObject.waterInletModelObject() )  {    if( boost::optional<Node> node = mo->optionalCast<Node>() )    {      idfObject.setString(Coil_Heating_WaterFields::WaterInletNodeName,node->name().get());    }  }  // WaterOutletNodeName  if( boost::optional<ModelObject> mo = modelObject.waterOutletModelObject() )  {    if( boost::optional<Node> node = mo->optionalCast<Node>() )    {      idfObject.setString(Coil_Heating_WaterFields::WaterOutletNodeName,node->name().get());    }  }  // AirInletNodeName  if( boost::optional<ModelObject> mo = modelObject.airInletModelObject() )  {    if( boost::optional<Node> node = mo->optionalCast<Node>() )    {      idfObject.setString(Coil_Heating_WaterFields::AirInletNodeName,node->name().get());    }  }  // AirOutletNodeName  if( boost::optional<ModelObject> mo = modelObject.airOutletModelObject() )  {    if( boost::optional<Node> node = mo->optionalCast<Node>() )    {      idfObject.setString(Coil_Heating_WaterFields::AirOutletNodeName,node->name().get());    }  }  // PerformanceInputMethod  s = modelObject.performanceInputMethod();  if( s )  {    idfObject.setString(Coil_Heating_WaterFields::PerformanceInputMethod,s.get());  }  // RatedCapacity  if( modelObject.isRatedCapacityAutosized() )  {    idfObject.setString(Coil_Heating_WaterFields::RatedCapacity,"Autosize");  }  else if( (value = modelObject.ratedCapacity()) )//.........这里部分代码省略.........

boost::optional<IdfObject> ForwardTranslator::translateCoilWaterHeatingAirToWaterHeatPump(     CoilWaterHeatingAirToWaterHeatPump & modelObject){  IdfObject idfObject(IddObjectType::Coil_WaterHeating_AirToWaterHeatPump);  m_idfObjects.push_back(idfObject);  // Name  if( auto s = modelObject.name() ) {    idfObject.setName(*s);  }  {    auto value = modelObject.ratedHeatingCapacity();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedHeatingCapacity,value);  }  {    auto value = modelObject.ratedCOP();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedCOP,value);  }  {    auto value = modelObject.ratedSensibleHeatRatio();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedSensibleHeatRatio,value);  }  {    auto value = modelObject.ratedEvaporatorInletAirDryBulbTemperature();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedEvaporatorInletAirDryBulbTemperature,value);  }  {    auto value = modelObject.ratedEvaporatorInletAirWetBulbTemperature();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedEvaporatorInletAirWetBulbTemperature,value);  }  {    auto value = modelObject.ratedCondenserInletWaterTemperature();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedCondenserInletWaterTemperature,value);  }  if( modelObject.isRatedEvaporatorAirFlowRateAutosized() ) {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedEvaporatorAirFlowRate,"Autosize");  } else if( auto value = modelObject.ratedEvaporatorAirFlowRate() ) {    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedEvaporatorAirFlowRate,value.get());  }  if( modelObject.isRatedCondenserWaterFlowRateAutosized() ) {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedCondenserWaterFlowRate,"Autosize");  } else if( auto value = modelObject.ratedCondenserWaterFlowRate() ) {    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::RatedCondenserWaterFlowRate,value.get());  }  if( modelObject.evaporatorFanPowerIncludedinRatedCOP() ) {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::EvaporatorFanPowerIncludedinRatedCOP,"Yes");   } else {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::EvaporatorFanPowerIncludedinRatedCOP,"No");  }  if( modelObject.condenserPumpPowerIncludedinRatedCOP() ) {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::CondenserPumpPowerIncludedinRatedCOP,"Yes");  } else {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::CondenserPumpPowerIncludedinRatedCOP,"No");  }  if( modelObject.condenserPumpHeatIncludedinRatedHeatingCapacityandRatedCOP() ) {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::CondenserPumpHeatIncludedinRatedHeatingCapacityandRatedCOP,"Yes");  } else {    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::CondenserPumpHeatIncludedinRatedHeatingCapacityandRatedCOP,"No");  }  {    auto value = modelObject.condenserWaterPumpPower();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::CondenserWaterPumpPower,value);  }  {    auto value = modelObject.fractionofCondenserPumpHeattoWater();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::FractionofCondenserPumpHeattoWater,value);  }  {    auto value = modelObject.crankcaseHeaterCapacity();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::CrankcaseHeaterCapacity,value);  }  {    auto value = modelObject.maximumAmbientTemperatureforCrankcaseHeaterOperation();    idfObject.setDouble(Coil_WaterHeating_AirToWaterHeatPumpFields::MaximumAmbientTemperatureforCrankcaseHeaterOperation,value);  }  {    auto value = modelObject.evaporatorAirTemperatureTypeforCurveObjects();    idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::EvaporatorAirTemperatureTypeforCurveObjects,value);  }  {    auto curve = modelObject.heatingCapacityFunctionofTemperatureCurve();    if( auto idf = translateAndMapModelObject(curve) ) {      idfObject.setString(Coil_WaterHeating_AirToWaterHeatPumpFields::HeatingCapacityFunctionofTemperatureCurveName,idf->name().get());//.........这里部分代码省略.........