• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

C++ createRegisterAndNameIdfObject函数代码示例

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

本文整理汇总了C++中createRegisterAndNameIdfObject函数的典型用法代码示例。如果您正苦于以下问题：C++ createRegisterAndNameIdfObject函数的具体用法？C++ createRegisterAndNameIdfObject怎么用？C++ createRegisterAndNameIdfObject使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。



在下文中一共展示了createRegisterAndNameIdfObject函数的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的C++代码示例。

示例1: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateRefrigerationSubcoolerMechanical( RefrigerationSubcoolerMechanical & modelObject )
{
  OptionalModelObject temp;
  OptionalString optS;
  boost::optional<std::string> s;
  boost::optional<double> d;

  // Name
  IdfObject subcoolerMechanical = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_Subcooler, modelObject);

  subcoolerMechanical.setString(Refrigeration_SubcoolerFields::SubcoolerType, "Mechanical");
  
  // Capacity-Providing System
  boost::optional<RefrigerationSystem> capacityProvidingSystem = modelObject.capacityProvidingSystem();

  if( capacityProvidingSystem )
  {
    boost::optional<IdfObject> _capacityProvidingSystem = translateAndMapModelObject(capacityProvidingSystem.get());

    if( _capacityProvidingSystem && _capacityProvidingSystem->name() )
    {
      subcoolerMechanical.setString(Refrigeration_SubcoolerFields::CapacityProvidingSystem,_capacityProvidingSystem->name().get());
    }
  }
   
  // Outlet Control Temperature
  d = modelObject.outletControlTemperature();
  if (d) {
    subcoolerMechanical.setDouble(Refrigeration_SubcoolerFields::OutletControlTemperature,d.get());
  }
  
  return subcoolerMechanical;
}
开发者ID:Anto-F，项目名称:OpenStudio，代码行数:33，代码来源:ForwardTranslateRefrigerationSubcoolerMechanical.cpp


示例2: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateRefrigerationSubcoolerLiquidSuction( RefrigerationSubcoolerLiquidSuction & modelObject )
{
  OptionalModelObject temp;
  OptionalString optS;
  boost::optional<std::string> s;
  boost::optional<double> d;

  // Name
  IdfObject subcoolerLiquidSuction = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_Subcooler, modelObject);

  // Subcooler Type
  subcoolerLiquidSuction.setString(Refrigeration_SubcoolerFields::SubcoolerType, "LiquidSuction");

  // Liquid Suction Design Subcooling Temperature Difference
  d = modelObject.liquidSuctionDesignSubcoolingTemperatureDifference();
  if (d) {
    subcoolerLiquidSuction.setDouble(Refrigeration_SubcoolerFields::LiquidSuctionDesignSubcoolingTemperatureDifference,d.get());
  }

  // Design Liquid Inlet Temperature
  d = modelObject.designLiquidInletTemperature();
  if (d) {
    subcoolerLiquidSuction.setDouble(Refrigeration_SubcoolerFields::DesignLiquidInletTemperature,d.get());
  }

  // Design Vapor Inlet Temperature
  d = modelObject.designVaporInletTemperature();
  if (d) {
    subcoolerLiquidSuction.setDouble(Refrigeration_SubcoolerFields::DesignVaporInletTemperature,d.get());
  }

  return subcoolerLiquidSuction;
}
开发者ID:NREL，项目名称:OpenStudio，代码行数:33，代码来源:ForwardTranslateRefrigerationSubcoolerLiquidSuction.cpp


示例3: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateElectricLoadCenterInverterSimple(model::ElectricLoadCenterInverterSimple & modelObject)
{
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ElectricLoadCenter_Inverter_Simple, modelObject);

  if (modelObject.name()) {
    idfObject.setString(ElectricLoadCenter_Inverter_SimpleFields::Name, modelObject.name().get());
  }

  if (modelObject.availabilitySchedule() && modelObject.availabilitySchedule().get().name()) {
    idfObject.setString(ElectricLoadCenter_Inverter_SimpleFields::AvailabilityScheduleName, modelObject.availabilitySchedule().get().name().get());
  }

  if (modelObject.thermalZone() && modelObject.thermalZone().get().name()) {
    idfObject.setString(ElectricLoadCenter_Inverter_SimpleFields::ZoneName, modelObject.thermalZone().get().name().get());
  }

  if (modelObject.radiativeFraction()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_SimpleFields::RadiativeFraction, modelObject.radiativeFraction().get());
  }

  if (modelObject.inverterEfficiency()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_SimpleFields::InverterEfficiency, modelObject.inverterEfficiency().get());
  }

  return idfObject;
}
开发者ID:jtanaa，项目名称:OpenStudio，代码行数:26，代码来源:ForwardTranslateElectricLoadCenterInverterSimple.cpp


示例4: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateSetpointManagerSingleZoneHumidityMinimum( SetpointManagerSingleZoneHumidityMinimum & modelObject )
{
  boost::optional<double> d;

  // Name
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_SingleZone_Humidity_Minimum, modelObject);

  // ControlVariable \deprecated
  // ScheduleName \deprecated

  // ControlZoneAirNodeName
  if( boost::optional<ThermalZone> thermalZone = modelObject.controlZone() )
  {
    auto node = thermalZone->zoneAirNode();
    idfObject.setString(SetpointManager_SingleZone_Humidity_MinimumFields::ControlZoneAirNodeName,node.name().get());
  }

  // Setpoint Node or NodeList Name
  if( boost::optional<Node> node = modelObject.setpointNode() )
  {
    idfObject.setString(SetpointManager_SingleZone_Humidity_MinimumFields::SetpointNodeorNodeListName,node->name().get());
  }

  return idfObject;
}
开发者ID:ChengXinDL，项目名称:OpenStudio，代码行数:25，代码来源:ForwardTranslateSetpointManagerSingleZoneHumidityMinimum.cpp


示例5: createRegisterAndNameIdfObject

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;
}
开发者ID:NREL，项目名称:OpenStudio，代码行数:31，代码来源:ForwardTranslateGeneratorPVWatts.cpp


示例6: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateZoneControlHumidistat( ZoneControlHumidistat& modelObject )
{
  // Name
  IdfObject object = createRegisterAndNameIdfObject(openstudio::IddObjectType::ZoneControl_Humidistat, modelObject);

  // Zone Name
  // set by ThermalZone

  // Humidifying Relative Humidity Setpoint Schedule Name
  if( OptionalSchedule humidifyingSchedule = modelObject.humidifyingRelativeHumiditySetpointSchedule() )
  {
    boost::optional<IdfObject> _humidifyingSchedule = translateAndMapModelObject(humidifyingSchedule.get());

    if( _humidifyingSchedule && _humidifyingSchedule->name() )
    {
      object.setString(ZoneControl_HumidistatFields::HumidifyingRelativeHumiditySetpointScheduleName,_humidifyingSchedule->name().get());
    }
  }

  // Dehumidifying Relative Humidity Setpoint Schedule Name
  if( OptionalSchedule dehumidifyingSchedule = modelObject.dehumidifyingRelativeHumiditySetpointSchedule() )
  {
    boost::optional<IdfObject> _dehumidifyingSchedule = translateAndMapModelObject(dehumidifyingSchedule.get());

    if( _dehumidifyingSchedule && _dehumidifyingSchedule->name() )
    {
      object.setString(ZoneControl_HumidistatFields::DehumidifyingRelativeHumiditySetpointScheduleName,_dehumidifyingSchedule->name().get());
    }
  }

  return object;
}
开发者ID:ChengXinDL，项目名称:OpenStudio，代码行数:32，代码来源:ForwardTranslateZoneControlHumidistat.cpp


示例7: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateSetpointManagerSingleZoneOneStageCooling( SetpointManagerSingleZoneOneStageCooling & modelObject )
{
  std::string s;
  double n;
  boost::optional<Node> node;

  // Name
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_SingleZone_OneStageCooling, modelObject);

  // CoolingStageOnSupplyAirSetpointTemperature
  n = modelObject.coolingStageOnSupplyAirSetpointTemperature();
  idfObject.setDouble(SetpointManager_SingleZone_OneStageCoolingFields::CoolingStageOnSupplyAirSetpointTemperature,n);

  // CoolingStageOffSupplyAirSetpointTemperature
  n = modelObject.coolingStageOffSupplyAirSetpointTemperature();
  idfObject.setDouble(SetpointManager_SingleZone_OneStageCoolingFields::CoolingStageOffSupplyAirSetpointTemperature,n);

  // ControlZoneName
  boost::optional<ThermalZone> thermalZone = modelObject.controlZone();
  if( thermalZone )
  {
    idfObject.setString(SetpointManager_SingleZone_OneStageCoolingFields::ControlZoneName,thermalZone->name().get());
  }

  // SetpointNodeorNodeListName
  node = modelObject.setpointNode();
  if( node )
  {
    idfObject.setString(SetpointManager_SingleZone_OneStageCoolingFields::SetpointNodeorNodeListName,node->name().get());
  }
  
  return idfObject;
}
开发者ID:jtanaa，项目名称:OpenStudio，代码行数:33，代码来源:ForwardTranslateSetpointManagerSingleZoneOneStageCooling.cpp


示例8: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateSetpointManagerMultiZoneMinimumHumidityAverage( SetpointManagerMultiZoneMinimumHumidityAverage & modelObject )
{
    boost::optional<double> d;

    // Name
    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_MultiZone_MinimumHumidity_Average, modelObject);

    // HVACAirLoopName
    if( boost::optional<AirLoopHVAC> airloop = modelObject.airLoopHVAC() )
    {
        idfObject.setString(SetpointManager_MultiZone_MinimumHumidity_AverageFields::HVACAirLoopName,airloop->name().get());
    }

    // Minimum Setpoint Humidity Ratio
    d = modelObject.minimumSetpointHumidityRatio();
    if( d )
    {
        idfObject.setDouble(SetpointManager_MultiZone_MinimumHumidity_AverageFields::MinimumSetpointHumidityRatio,d.get());
    }

    // Maximum Setpoint Humidity Ratio
    d = modelObject.maximumSetpointHumidityRatio();
    if( d )
    {
        idfObject.setDouble(SetpointManager_MultiZone_MinimumHumidity_AverageFields::MaximumSetpointHumidityRatio,d.get());
    }

    // Setpoint Node or NodeList Name
    if( boost::optional<Node> node = modelObject.setpointNode() )
    {
        idfObject.setString(SetpointManager_MultiZone_MinimumHumidity_AverageFields::SetpointNodeorNodeListName,node->name().get());
    }

    return idfObject;
}
开发者ID:mattXGS，项目名称:OpenStudio，代码行数:35，代码来源:ForwardTranslateSetpointManagerMultiZoneMinimumHumidityAverage.cpp


示例9: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateElectricLoadCenterInverterLookUpTable(model::ElectricLoadCenterInverterLookUpTable & modelObject)
{
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ElectricLoadCenter_Inverter_LookUpTable, modelObject);

  if (modelObject.name()) {
    idfObject.setString(ElectricLoadCenter_Inverter_LookUpTableFields::Name, modelObject.name().get());
  }

  if (modelObject.availabilitySchedule() && modelObject.availabilitySchedule().get().name()) {
    idfObject.setString(ElectricLoadCenter_Inverter_LookUpTableFields::AvailabilityScheduleName, modelObject.availabilitySchedule().get().name().get());
  }

  if (modelObject.thermalZone() && modelObject.thermalZone().get().name()) {
    idfObject.setString(ElectricLoadCenter_Inverter_LookUpTableFields::ZoneName, modelObject.thermalZone().get().name().get());
  }

  if (modelObject.radiativeFraction()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::RadiativeFraction, modelObject.radiativeFraction().get());
  }

  if (modelObject.ratedMaximumContinuousOutputPower()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::RatedMaximumContinuousOutputPower, modelObject.ratedMaximumContinuousOutputPower().get());
  }

  if (modelObject.nightTareLossPower()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::NightTareLossPower, modelObject.nightTareLossPower().get());
  }

  if (modelObject.nominalVoltageInput()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::NominalVoltageInput, modelObject.nominalVoltageInput().get());
  }

  if (modelObject.efficiencyAt10PowerAndNominalVoltage()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::Efficiencyat10_PowerandNominalVoltage, modelObject.efficiencyAt10PowerAndNominalVoltage().get());
  }

  if (modelObject.efficiencyAt20PowerAndNominalVoltage()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::Efficiencyat20_PowerandNominalVoltage, modelObject.efficiencyAt20PowerAndNominalVoltage().get());
  }

  if (modelObject.efficiencyAt30PowerAndNominalVoltage()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::Efficiencyat30_PowerandNominalVoltage, modelObject.efficiencyAt30PowerAndNominalVoltage().get());
  }

  if (modelObject.efficiencyAt50PowerAndNominalVoltage()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::Efficiencyat50_PowerandNominalVoltage, modelObject.efficiencyAt50PowerAndNominalVoltage().get());
  }

  if (modelObject.efficiencyAt75PowerAndNominalVoltage()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::Efficiencyat75_PowerandNominalVoltage, modelObject.efficiencyAt75PowerAndNominalVoltage().get());
  }

  if (modelObject.efficiencyAt100PowerAndNominalVoltage()) {
    idfObject.setDouble(ElectricLoadCenter_Inverter_LookUpTableFields::Efficiencyat100_PowerandNominalVoltage, modelObject.efficiencyAt100PowerAndNominalVoltage().get());
  }

  return idfObject;
}
开发者ID:MatthewSteen，项目名称:OpenStudio，代码行数:58，代码来源:ForwardTranslateElectricLoadCenterInverterLookUpTable.cpp


示例10: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateSurfacePropertyOtherSideConditionsModel(model::SurfacePropertyOtherSideConditionsModel & modelObject)
{
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SurfaceProperty_OtherSideConditionsModel,
                                                       modelObject);

  idfObject.setString(SurfaceProperty_OtherSideConditionsModelFields::TypeofModeling, modelObject.typeOfModeling());
  
  return idfObject;
}
开发者ID:Anto-F，项目名称:OpenStudio，代码行数:9，代码来源:ForwardTranslateSurfacePropertyOtherSideConditionsModel.cpp


示例11: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateRefrigerationCondenserCascade( RefrigerationCondenserCascade & modelObject )
{
  OptionalModelObject temp;
  OptionalString optS;
  boost::optional<std::string> s;
  boost::optional<double> d;

  // Name
  IdfObject cascade = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_Condenser_Cascade, modelObject);

  // Rated Condensing Temperature
  d = modelObject.ratedCondensingTemperature();
  if (d) {
    cascade.setDouble(Refrigeration_Condenser_CascadeFields::RatedCondensingTemperature,d.get());
  }

  // Rated Approach Temperature Difference
  d = modelObject.ratedApproachTemperatureDifference();
  if (d) {
    cascade.setDouble(Refrigeration_Condenser_CascadeFields::RatedApproachTemperatureDifference,d.get());
  }

  // Rated Effective Total Heat Rejection Rate
  d = modelObject.ratedEffectiveTotalHeatRejectionRate();
  if (d) {
    cascade.setDouble(Refrigeration_Condenser_CascadeFields::RatedEffectiveTotalHeatRejectionRate,d.get());
  }

  // Condensing Temperature Control Type
  s = modelObject.condensingTemperatureControlType();
  if (s) {
    cascade.setString(Refrigeration_Condenser_CascadeFields::CondensingTemperatureControlType,s.get());
  }

  // Condenser Refrigerant Operating Charge Inventory
  d = modelObject.condenserRefrigerantOperatingChargeInventory();
  if (d) {
    cascade.setDouble(Refrigeration_Condenser_CascadeFields::CondenserRefrigerantOperatingChargeInventory,d.get());
  }

  // Condensate Receiver Refrigerant Inventory
  d = modelObject.condensateReceiverRefrigerantInventory();
  if (d) {
    cascade.setDouble(Refrigeration_Condenser_CascadeFields::CondensateReceiverRefrigerantInventory,d.get());
  }

  // Condensate Piping Refrigerant Inventory
  d = modelObject.condensatePipingRefrigerantInventory();
  if (d) {
    cascade.setDouble(Refrigeration_Condenser_CascadeFields::CondensatePipingRefrigerantInventory,d.get());
  }
  
  return cascade;

}
开发者ID:ChengXinDL，项目名称:OpenStudio，代码行数:55，代码来源:ForwardTranslateRefrigerationCondenserCascade.cpp


示例12: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateAvailabilityManagerScheduledOff(
    AvailabilityManagerScheduledOff & modelObject)
{
  IdfObject idfObject = createRegisterAndNameIdfObject(IddObjectType::AvailabilityManager_ScheduledOff, modelObject);

  // Schedule
  {
    Schedule sch = modelObject.schedule();
    idfObject.setString(AvailabilityManager_ScheduledOffFields::ScheduleName, sch.name().get());
  }
  return idfObject;
}
开发者ID:NREL，项目名称:OpenStudio，代码行数:12，代码来源:ForwardTranslateAvailabilityManagerScheduledOff.cpp


示例13: createRegisterAndNameIdfObject

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;
}
开发者ID:ORNL-BTRIC，项目名称:OpenStudio，代码行数:52，代码来源:ForwardTranslateScheduleDay.cpp


示例14: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateSetpointManagerFollowGroundTemperature( 
                              SetpointManagerFollowGroundTemperature & modelObject )
{
  boost::optional<Node> node;
  boost::optional<std::string> s;
  boost::optional<double> d;

  // Name
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_FollowGroundTemperature, modelObject);

  // ControlVariable
  s = modelObject.controlVariable();
  if( s )
  {
    idfObject.setString(SetpointManager_FollowGroundTemperatureFields::ControlVariable,s.get());
  }

  // ReferenceGroundTemperatureObjectType
  idfObject.setString(SetpointManager_FollowGroundTemperatureFields::ReferenceGroundTemperatureObjectType,"Site:GroundTemperature:BuildingSurface");

  // OffsetTemperatureDifference
  d = modelObject.offsetTemperatureDifference();
  if( d )
  {
    idfObject.setDouble(SetpointManager_FollowGroundTemperatureFields::OffsetTemperatureDifference,d.get());
  }

  // MaximumSetpointTemperature
  d = modelObject.maximumSetpointTemperature();
  if( d )
  {
    idfObject.setDouble(SetpointManager_FollowGroundTemperatureFields::MaximumSetpointTemperature,d.get());
  }
  
  // MinimumSetpointTemperature
  d = modelObject.minimumSetpointTemperature();
  if( d )
  {
    idfObject.setDouble(SetpointManager_FollowGroundTemperatureFields::MinimumSetpointTemperature,d.get());
  }

  // SetpointNodeorNodeListName
  node = modelObject.setpointNode();
  if( node )
  {
    idfObject.setString(SetpointManager_FollowGroundTemperatureFields::SetpointNodeorNodeListName,node->name().get());
  }

  return idfObject;
}
开发者ID:jtanaa，项目名称:OpenStudio，代码行数:50，代码来源:ForwardTranslateSetpointManagerFollowGroundTemperature.cpp


示例15: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translatePhotovoltaicPerformanceEquivalentOneDiode(model::PhotovoltaicPerformanceEquivalentOneDiode & modelObject)
{
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::PhotovoltaicPerformance_EquivalentOneDiode, modelObject);

  if (modelObject.name()) {
    idfObject.setString(PhotovoltaicPerformance_EquivalentOneDiodeFields::Name, modelObject.name().get());
  }

  idfObject.setString(PhotovoltaicPerformance_EquivalentOneDiodeFields::Celltype, modelObject.celltype());

  idfObject.setInt(PhotovoltaicPerformance_EquivalentOneDiodeFields::NumberofCellsinSeries, modelObject.numberOfCellsInSeries());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ActiveArea, modelObject.activeArea());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::TransmittanceAbsorptanceProduct, modelObject.transmittanceAbsorptanceProduct());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::SemiconductorBandgap, modelObject.semiconductorBandgap());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ShuntResistance, modelObject.shuntResistance());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ShortCircuitCurrent, modelObject.shortCircuitCurrent());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::OpenCircuitVoltage, modelObject.openCircuitVoltage());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ReferenceTemperature, modelObject.referenceTemperature());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ReferenceInsolation, modelObject.referenceInsolation());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ModuleCurrentatMaximumPower, modelObject.moduleCurrentatMaximumPower());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ModuleVoltageatMaximumPower, modelObject.moduleVoltageatMaximumPower());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::TemperatureCoefficientofShortCircuitCurrent, modelObject.temperatureCoefficientofShortCircuitCurrent());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::TemperatureCoefficientofOpenCircuitVoltage, modelObject.temperatureCoefficientofOpenCircuitVoltage());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::NominalOperatingCellTemperatureTestAmbientTemperature, modelObject.nominalOperatingCellTemperatureTestAmbientTemperature());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::NominalOperatingCellTemperatureTestCellTemperature, modelObject.nominalOperatingCellTemperatureTestCellTemperature());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::NominalOperatingCellTemperatureTestInsolation, modelObject.nominalOperatingCellTemperatureTestInsolation());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::ModuleHeatLossCoefficient, modelObject.moduleHeatLossCoefficient());

  idfObject.setDouble(PhotovoltaicPerformance_EquivalentOneDiodeFields::TotalHeatCapacity, modelObject.totalHeatCapacity());

  return idfObject;
}
开发者ID:jtanaa，项目名称:OpenStudio，代码行数:48，代码来源:ForwardTranslatePhotovoltaicPerformanceEquivalentOneDiode.cpp


示例16: createRegisterAndNameIdfObject

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;
}
开发者ID:MatthewSteen，项目名称:OpenStudio，代码行数:47，代码来源:ForwardTranslateScheduleYear.cpp


示例17: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateSetpointManagerColdest( SetpointManagerColdest & modelObject )
{
  boost::optional<Node> node;
  boost::optional<double> value;
  std::string s;

  // Name
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::SetpointManager_Coldest, modelObject);

  // ControlVariable
  s = modelObject.controlVariable();
  idfObject.setString(SetpointManager_ColdestFields::ControlVariable,s);

  // MinimumSetpointTemperature
  value = modelObject.minimumSetpointTemperature();
  if( value )
  {
    idfObject.setDouble(SetpointManager_ColdestFields::MinimumSetpointTemperature,value.get());
  }

  // MaximumSetpointTemperature
  value = modelObject.maximumSetpointTemperature();
  if( value )
  {
    idfObject.setDouble(SetpointManager_ColdestFields::MaximumSetpointTemperature,value.get());
  }

  // Strategy
  s = modelObject.strategy();
  idfObject.setString(SetpointManager_ColdestFields::Strategy,s);

  // SetpointNodeorNodeListName
  node = modelObject.setpointNode();
  if( node )
  {
    idfObject.setString(SetpointManager_ColdestFields::SetpointNodeorNodeListName,node->name().get());

    // HVACAirLoopName
    if( boost::optional<model::AirLoopHVAC> airLoop = node->airLoopHVAC() )
    {
      idfObject.setString(SetpointManager_ColdestFields::HVACAirLoopName,airLoop->name().get());
    }
  }

  return idfObject;
}
开发者ID:NREL，项目名称:OpenStudio，代码行数:46，代码来源:ForwardTranslateSetpointManagerColdest.cpp


示例18: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translateZoneAirMassFlowConservation(
    ZoneAirMassFlowConservation & 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::ZoneAirMassFlowConservation, modelObject);

  if (modelObject.adjustZoneMixingForZoneAirMassFlowBalance()){
    idfObject.setString(ZoneAirMassFlowConservationFields::AdjustZoneMixingForZoneAirMassFlowBalance, "Yes");
  }else{
    idfObject.setString(ZoneAirMassFlowConservationFields::AdjustZoneMixingForZoneAirMassFlowBalance, "No");
  }

  idfObject.setString(ZoneAirMassFlowConservationFields::SourceZoneInfiltrationTreatment, modelObject.sourceZoneInfiltrationTreatment());
  
  return idfObject;
}
开发者ID:urbanengr，项目名称:OpenStudio，代码行数:17，代码来源:ForwardTranslateZoneAirMassFlowConservation.cpp


示例19: createRegisterAndNameIdfObject

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;
}
开发者ID:CheyenneBerlin，项目名称:OpenStudio，代码行数:41，代码来源:ForwardTranslateSetpointManagerScheduledDualSetpoint.cpp


示例20: createRegisterAndNameIdfObject

boost::optional<IdfObject> ForwardTranslator::translatePhotovoltaicPerformanceSimple(model::PhotovoltaicPerformanceSimple & modelObject)
{
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::PhotovoltaicPerformance_Simple, modelObject);

  if (modelObject.name()) {
    idfObject.setString(PhotovoltaicPerformance_SimpleFields::Name, modelObject.name().get());
  }

  idfObject.setString(PhotovoltaicPerformance_SimpleFields::ConversionEfficiencyInputMode, modelObject.conversionEfficiencyInputMode());

  idfObject.setDouble(PhotovoltaicPerformance_SimpleFields::FractionofSurfaceAreawithActiveSolarCells, modelObject.fractionOfSurfaceAreaWithActiveSolarCells());
  
  if (modelObject.fixedEfficiency()) {
    idfObject.setDouble(PhotovoltaicPerformance_SimpleFields::ValueforCellEfficiencyifFixed, modelObject.fixedEfficiency().get());
  }

  if (modelObject.efficiencySchedule() && modelObject.efficiencySchedule().get().name()) {
    idfObject.setString(PhotovoltaicPerformance_SimpleFields::EfficiencyScheduleName, modelObject.efficiencySchedule().get().name().get());
  }

  return idfObject;
}
开发者ID:jtanaa，项目名称:OpenStudio，代码行数:22，代码来源:ForwardTranslatePhotovoltaicPerformanceSimple.cpp



注：本文中的createRegisterAndNameIdfObject函数示例由纯净天空整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
C++ createReplyObject函数代码示例发布时间：2022-05-30
下一篇：
C++ createReferenceError函数代码示例发布时间：2022-05-30
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap