C++ OptionalModelObject::handle方法代码示例

OptionalModelObject ReverseTranslator::translateScheduleCompact( const WorkspaceObject & workspaceObject )
{
  if( workspaceObject.iddObject().type() != IddObjectType::Schedule_Compact )
  {
    LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Compact");
    return boost::none;
  }

  ScheduleCompact scheduleCompact(m_model);

  OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_CompactFields::ScheduleTypeLimitsName);
  if (target){
    OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
    if (scheduleTypeLimits){
      scheduleCompact.setPointer(OS_Schedule_CompactFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
    }
  }

  if (OptionalString os = workspaceObject.name()) {
    scheduleCompact.setName(*os);
  }

  for (const IdfExtensibleGroup& eg : workspaceObject.extensibleGroups()) {
    scheduleCompact.pushExtensibleGroup(eg.fields());
  }

  return scheduleCompact;
}

OptionalModelObject ReverseTranslator::translateScheduleDayHourly(const WorkspaceObject & workspaceObject){
  if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Day_Hourly){
    LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Day:Hourly");
    return boost::none;
  }

  // create the schedule
  ScheduleDay scheduleDay(m_model);

  OptionalString s = workspaceObject.name();
  if (s){
    scheduleDay.setName(*s);
  }

  OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Day_HourlyFields::ScheduleTypeLimitsName);
  if (target){
    OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
    if (scheduleTypeLimits){
      scheduleDay.setPointer(OS_Schedule_DayFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
    }
  }

  for(unsigned i = 0; i < 24; ++i){
    OptionalDouble d = workspaceObject.getDouble(Schedule_Day_HourlyFields::Hour1 + i, true);
    if (d){
      scheduleDay.addValue(openstudio::Time(0,i+1,0,0), *d);
    }
  }

  return scheduleDay;
}

OptionalModelObject ReverseTranslator::translateScheduleConstant( const WorkspaceObject & workspaceObject )
{
  if( workspaceObject.iddObject().type() != IddObjectType::Schedule_Constant )
  {
    LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Constant");
    return boost::none;
  }

  ScheduleConstant scheduleConstant(m_model);

  boost::optional<WorkspaceObject> target = workspaceObject.getTarget(Schedule_ConstantFields::ScheduleTypeLimitsName);
  if (target){
    OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
    if (scheduleTypeLimits) {
      scheduleConstant.setPointer(OS_Schedule_ConstantFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
    }
  }
  if (OptionalDouble val = workspaceObject.getDouble(Schedule_ConstantFields::HourlyValue)) {
    scheduleConstant.setValue(*val);
  }

  return scheduleConstant;
}

OptionalModelObject ReverseTranslator::translateScheduleDayInterval(const WorkspaceObject & workspaceObject){
  if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Day_Interval){
    LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Day:Interval");
    return boost::none;
  }

  // create the schedule
  ScheduleDay scheduleDay(m_model);

  OptionalString s = workspaceObject.name();
  if (s){
    scheduleDay.setName(*s);
  }

  OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Day_IntervalFields::ScheduleTypeLimitsName);
  if (target){
    OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
    if (scheduleTypeLimits){
      scheduleDay.setPointer(OS_Schedule_DayFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
    }
  }

  s = workspaceObject.getString(2,true);
  if (s){
    if (openstudio::istringEqual(*s,"yes")){
      scheduleDay.setInterpolatetoTimestep(true);
    }
    else if (openstudio::istringEqual(*s,"yes")){
      scheduleDay.setInterpolatetoTimestep(false);
    }
  }

  //get extensible groups
  std::vector<IdfExtensibleGroup> extensibleGroups = workspaceObject.extensibleGroups();
  //loop over extensible groups
  boost::regex timeRegex("(\\d?\\d:\\d\\d)");
  boost::smatch m;
  unsigned n = extensibleGroups.size();
  for (unsigned i = 0; i < n; ++i){
    //read in extensible groups
    boost::optional<std::string> timeString = extensibleGroups[i].getString(Schedule_Day_IntervalExtensibleFields::Time);
    boost::optional<double> valueUntilTime = extensibleGroups[i].getDouble(Schedule_Day_IntervalExtensibleFields::ValueUntilTime);
    if (timeString && valueUntilTime) {
      // Time string may be prefixed with "Until: ". Extract time in HH:MM format.
      if (boost::regex_search(*timeString,m,timeRegex)) {
        timeString = std::string(m[1].first,m[1].second);
      }
      try {
        openstudio::Time time(*timeString);
        scheduleDay.addValue(time,*valueUntilTime);
      }
      catch (std::exception& e) {
        LOG(Warn,"Could not add value (" << *timeString << ", " << *valueUntilTime
            << ") to ScheduleDay being created from " << workspaceObject.briefDescription()
            << ", because " << e.what() << ".");
      }
    }
    else {
      LOG(Warn,"Encountered extensible group with incomplete or improperly formatted data in "
          << workspaceObject.briefDescription() << ". Therefore, a corresponding value is not "
          << "being added to the ScheduleDay object under construction.");
    }
  }

  return scheduleDay;
}

OptionalModelObject ReverseTranslator::translateZoneHVACIdealLoadsAirSystem( const WorkspaceObject & workspaceObject )
{
  if( workspaceObject.iddObject().type() != IddObjectType::ZoneHVAC_IdealLoadsAirSystem ) {
    LOG(Error, "WorkspaceObject is not IddObjectType: ZoneHVAC:IdealLoadsAirSystem");
     return boost::none;
  }

  ZoneHVACIdealLoadsAirSystem zoneHVACIdealLoadsAirSystem(m_model);
  
  // name
  boost::optional<std::string> s = workspaceObject.name();
  if(s){
    zoneHVACIdealLoadsAirSystem.setName(*s);
  }
  
  // availability schedule
  OptionalWorkspaceObject target = workspaceObject.getTarget(ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName);
  if (target){
    OptionalModelObject availabilitySchedule = translateAndMapWorkspaceObject(*target);
    if (availabilitySchedule){
      zoneHVACIdealLoadsAirSystem.setPointer(OS_ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName, availabilitySchedule->handle());
    }
  }

  // skip inlet and outlet node names - that should be done by the zone HVAC object translator

  // maximum heating supply air temperature
  OptionalDouble d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirTemperature);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMaximumHeatingSupplyAirTemperature(*d);
  }

  // minimum cooling supply air temperature
  d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirTemperature);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMinimumCoolingSupplyAirTemperature(*d);
  }

  // maximum heating supply air humidity ratio
  d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirHumidityRatio);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMaximumHeatingSupplyAirHumidityRatio(*d);
  }

  // minimum cooling supply air humidity ratio
  d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirHumidityRatio);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMinimumCoolingSupplyAirHumidityRatio(*d);
  }

  // heating limit
  s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit);
  if (s){
    zoneHVACIdealLoadsAirSystem.setHeatingLimit(*s);
  }

  // maximum heating air flow rate
  d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMaximumHeatingAirFlowRate(*d);
  }

  // maximum sensible heating capacity
  d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMaximumSensibleHeatingCapacity(*d);
  }

  // cooling limit
  s = workspaceObject.getString(ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit);
  if (s){
    zoneHVACIdealLoadsAirSystem.setCoolingLimit(*s);
  }

  // maximum cooling airflow rate
  d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMaximumCoolingAirFlowRate(*d);
  }

  // maximum total cooling capacity
  d = workspaceObject.getDouble(ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity);
  if (d){
    zoneHVACIdealLoadsAirSystem.setMaximumTotalCoolingCapacity(*d);
  }

  // heating availability schedule
  target = workspaceObject.getTarget(ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName);
  if (target){
    OptionalModelObject heatingAvailabilitySchedule = translateAndMapWorkspaceObject(*target);
    if (heatingAvailabilitySchedule){
      zoneHVACIdealLoadsAirSystem.setPointer(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName, heatingAvailabilitySchedule->handle());
    }
  }

  // cooling availability schedule
  target = workspaceObject.getTarget(ZoneHVAC_IdealLoadsAirSystemFields::CoolingAvailabilityScheduleName);
  if (target){
    OptionalModelObject coolingAvailabilitySchedule = translateAndMapWorkspaceObject(*target);
    if (coolingAvailabilitySchedule){
//.........这里部分代码省略.........