C++ WorkspaceObject::getInt方法代码示例

boost::optional<model::ModelObject> ReverseTranslator::translateShadowCalculation(
    const WorkspaceObject& workspaceObject)
{
  OS_ASSERT(workspaceObject.iddObject().type() == IddObjectType::ShadowCalculation);

  ShadowCalculation shadowCalculation = m_model.getUniqueModelObject<ShadowCalculation>();

  OptionalInt i = workspaceObject.getInt(ShadowCalculationFields::CalculationFrequency);
  if (i) {
    shadowCalculation.setCalculationFrequency(*i);
  }

  i = workspaceObject.getInt(ShadowCalculationFields::MaximumFiguresinShadowOverlapCalculations);
  if (i) {
    shadowCalculation.setMaximumFiguresInShadowOverlapCalculations(*i);
  }

  OptionalString s = workspaceObject.getString(ShadowCalculationFields::PolygonClippingAlgorithm);
  if (s && !s->empty()) {
    shadowCalculation.setPolygonClippingAlgorithm(*s);
  }

  s = workspaceObject.getString(ShadowCalculationFields::SkyDiffuseModelingAlgorithm);
  if (s && !s->empty()) {
    shadowCalculation.setSkyDiffuseModelingAlgorithm(*s);
  }

  return shadowCalculation.cast<ModelObject>();
}

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

  SizingParameters mo = m_model.getUniqueModelObject<SizingParameters>();

  boost::optional<double> value = workspaceObject.getDouble(Sizing_ParametersFields::HeatingSizingFactor);
  if( value )
  {
    mo.setHeatingSizingFactor(value.get());
  }

  value = workspaceObject.getDouble(Sizing_ParametersFields::CoolingSizingFactor);
  if( value )
  {
    mo.setCoolingSizingFactor(value.get());
  }

  boost::optional<int> i = workspaceObject.getInt(Sizing_ParametersFields::TimestepsinAveragingWindow);
  if( i )
  {
    mo.setTimestepsinAveragingWindow(i.get());
  }

  return mo;
}

TEST_F(EnergyPlusFixture,ForwardTranslator_Building3)
{
  Model model;

  Building building = model.getUniqueModelObject<Building>();
  building.setName("Building");
  building.setNorthAxis(20);
  building.setNominalFloortoFloorHeight(5);

  Site site = model.getUniqueModelObject<Site>();
  site.setTerrain("Ocean");

  SimulationControl simulationControl = model.getUniqueModelObject<SimulationControl>();
  simulationControl.setLoadsConvergenceToleranceValue(0.2);
  simulationControl.setTemperatureConvergenceToleranceValue(0.2);
  simulationControl.setSolarDistribution("FullInteriorAndExteriorWithReflections");
  simulationControl.setMaximumNumberofWarmupDays(2);

  ForwardTranslator forwardTranslator;
  Workspace workspace = forwardTranslator.translateModel(model);

  ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Building).size());
  ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::Site_Location).size());
  ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::SimulationControl).size());

  WorkspaceObject object = workspace.getObjectsByType(IddObjectType::Building)[0];
  ASSERT_TRUE(object.getString(BuildingFields::Name));
  EXPECT_EQ("Building", object.getString(BuildingFields::Name).get());
  ASSERT_TRUE(object.getDouble(BuildingFields::NorthAxis));
  EXPECT_EQ(20, object.getDouble(BuildingFields::NorthAxis).get());
  ASSERT_TRUE(object.getString(BuildingFields::Terrain));
  EXPECT_EQ("Ocean", object.getString(BuildingFields::Terrain).get());
  ASSERT_TRUE(object.getDouble(BuildingFields::LoadsConvergenceToleranceValue));
  EXPECT_EQ(0.2, object.getDouble(BuildingFields::LoadsConvergenceToleranceValue).get());
  ASSERT_TRUE(object.getDouble(BuildingFields::TemperatureConvergenceToleranceValue));
  EXPECT_EQ(0.2, object.getDouble(BuildingFields::TemperatureConvergenceToleranceValue).get());
  ASSERT_TRUE(object.getString(BuildingFields::SolarDistribution));
  EXPECT_EQ("FullInteriorAndExteriorWithReflections", object.getString(BuildingFields::SolarDistribution).get());
  ASSERT_TRUE(object.getInt(BuildingFields::MaximumNumberofWarmupDays));
  EXPECT_EQ(2, object.getInt(BuildingFields::MaximumNumberofWarmupDays).get());
}

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

  Timestep mo = m_model.getUniqueModelObject<Timestep>();

  boost::optional<int> i = workspaceObject.getInt(TimestepFields::NumberofTimestepsperHour);
  if( i )
  {
    mo.setInt(OS_TimestepFields::NumberofTimestepsperHour,i.get());
  } 

  return mo;
}

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

  boost::optional<std::string> s = workspaceObject.getString(RunPeriodControl_SpecialDaysFields::StartDate);
  if( !s )
  {
    LOG(Error, "No start date specified for RunPeriodControl:SpecialDays");
    return boost::none;
  }

  boost::optional<RunPeriodControlSpecialDays> mo;
  try{
    mo = RunPeriodControlSpecialDays(*s, m_model);
  }catch(...){
    LOG(Error, "'" << *s << "'  is not a correct date specification");
    return boost::none;
  }

  s = workspaceObject.getString(RunPeriodControl_SpecialDaysFields::Name);
  if( s )
  {
    mo->setName(s.get());
  }

  boost::optional<int> i = workspaceObject.getInt(RunPeriodControl_SpecialDaysFields::Duration);
  if( i )
  {
    mo->setDuration(i.get());
  }

  s = workspaceObject.getString(RunPeriodControl_SpecialDaysFields::SpecialDayType);
  if( s )
  {
    mo->setString(OS_RunPeriodControl_SpecialDaysFields::SpecialDayType,s.get());
  }

  return *mo;
}

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

  DesignDay designDay(m_model);

  // Name
  boost::optional<std::string> s = workspaceObject.getString(SizingPeriod_DesignDayFields::Name);
  if( s ){
    designDay.setName(s.get());
  }else{
    LOG(Error, "SizingPeriod:DesignDay missing required field Name");
  }

  // Month
  boost::optional<int> i = workspaceObject.getInt(SizingPeriod_DesignDayFields::Month);
  if( i ){
    designDay.setMonth( i.get() );
  }else{
    LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Month");
  }

  // Day of Month
  i = workspaceObject.getInt(SizingPeriod_DesignDayFields::DayofMonth);
  if( i ){
    designDay.setDayOfMonth(i.get());
  }else{
    LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Day of Month");
  }

  // Day Type
  s = workspaceObject.getString(SizingPeriod_DesignDayFields::DayType);
  if( s ){
    designDay.setDayType(s.get());
  }else{
    LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Day Type");
  }

  // Maximum Dry-Bulb Temperature
  boost::optional<double> value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::MaximumDryBulbTemperature);
  if( value ){
    designDay.setMaximumDryBulbTemperature(value.get());
  }else{
    LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Maximum Dry Bulb Temperature");
  }

  // Dry-Bulb Temperature Range Modifier Type
  s = workspaceObject.getString(SizingPeriod_DesignDayFields::DryBulbTemperatureRangeModifierType);
  if( s ){
    designDay.setDryBulbTemperatureRangeModifierType(s.get());
  }
  std::string dryBulbTemperatureRangeModifierType = designDay.dryBulbTemperatureRangeModifierType();

  // Daily Dry-Bulb Temperature Range
  if (!istringEqual(dryBulbTemperatureRangeModifierType, "DifferenceSchedule")){
    value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::DailyDryBulbTemperatureRange);
    if( value ){
      designDay.setDailyDryBulbTemperatureRange(value.get()); 
    }
  }

  // Dry-Bulb Temperature Range Modifier Schedule Name
  if (istringEqual(dryBulbTemperatureRangeModifierType, "MultiplierSchedule") || istringEqual(dryBulbTemperatureRangeModifierType, "DifferenceSchedule")){
    boost::optional<WorkspaceObject> wo = workspaceObject.getTarget(SizingPeriod_DesignDayFields::DryBulbTemperatureRangeModifierDayScheduleName);
    if( wo ){
      boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(wo.get());
      if( mo ){
        if(boost::optional<ScheduleDay> schedule = mo->optionalCast<ScheduleDay>()){
          designDay.setDryBulbTemperatureRangeModifierSchedule(*schedule);
        }
      }
    }

    if (!designDay.dryBulbTemperatureRangeModifierSchedule()){
      LOG(Error, "SizingPeriod:DesignDay " << designDay.name().get() << " missing required field Maximum Dry Bulb Temperature");
    }
  }

  // Humidity Condition Type
  s = workspaceObject.getString(SizingPeriod_DesignDayFields::HumidityConditionType);
  if( s ){
    if (istringEqual(*s, "RelativeHumiditySchedule")){
      s = "Schedule";
    }
    designDay.setHumidityIndicatingType(s.get());
  }
  std::string humidityIndicatingType = designDay.humidityIndicatingType();

  // Wetbulb or DewPoint at Maximum Dry-Bulb
  if (istringEqual(humidityIndicatingType, "Wetbulb") ||
      istringEqual(humidityIndicatingType, "Dewpoint") ||
      istringEqual(humidityIndicatingType, "WetBulbProfileMultiplierSchedule") ||
      istringEqual(humidityIndicatingType, "WetBulbProfileDifferenceSchedule") ||
      istringEqual(humidityIndicatingType, "WetBulbProfileDefaultMultipliers")){
    value = workspaceObject.getDouble(SizingPeriod_DesignDayFields::WetbulborDewPointatMaximumDryBulb);
    if( value ){
//.........这里部分代码省略.........

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

  // this function creates a space and a thermal zone, it returns the space.  If you want the 
  // thermal zone you can reliably dereference the result of space.thermalZone().

  openstudio::model::ThermalZone thermalZone( m_model );

  openstudio::model::Space space( m_model );
  space.setThermalZone(thermalZone);

  boost::optional<std::string> idfZoneName;

  OptionalString s = workspaceObject.name();
  if(s){
    space.setName(*s);
    thermalZone.setName(*s + " Thermal Zone");
    idfZoneName = *s;
  }

  OptionalDouble d = workspaceObject.getDouble(ZoneFields::DirectionofRelativeNorth);
  if(d){
    space.setDirectionofRelativeNorth(*d);
  }

  d=workspaceObject.getDouble(ZoneFields::XOrigin);
  if(d){
    space.setXOrigin(*d);
  }

  d=workspaceObject.getDouble(ZoneFields::YOrigin);
  if(d){
    space.setYOrigin(*d);
  }

  d=workspaceObject.getDouble(ZoneFields::ZOrigin);
  if(d){
    space.setZOrigin(*d);
  }

  OptionalInt i = workspaceObject.getInt(ZoneFields::Type);
  if(i){
    // no-op
  }

  i = workspaceObject.getInt(ZoneFields::Multiplier);
  if(i){
    thermalZone.setMultiplier(*i);
  }

  d = workspaceObject.getDouble(ZoneFields::CeilingHeight);
  if(d){
    thermalZone.setCeilingHeight(*d);
  }

  d=workspaceObject.getDouble(ZoneFields::Volume);
  if(d){
    thermalZone.setVolume(*d);
  }

  s = workspaceObject.getString(ZoneFields::ZoneInsideConvectionAlgorithm);
  if(s){
    thermalZone.setZoneInsideConvectionAlgorithm(*s);
  }

  s = workspaceObject.getString(ZoneFields::ZoneOutsideConvectionAlgorithm);
  if(s){
    thermalZone.setZoneOutsideConvectionAlgorithm(*s);
  }

  s = workspaceObject.getString(ZoneFields::PartofTotalFloorArea);
  if(s){
    if(istringEqual("Yes",*s))
    {
      space.setPartofTotalFloorArea(true);
    }
    else
    {
      space.setPartofTotalFloorArea(false);
    }
  }

  // Thermostat

  // If the zone in the idf file does not have a name, there is no use in even trying to find a thermostat
  if( idfZoneName )
  {
    Workspace workspace = workspaceObject.workspace();
    
    std::vector<WorkspaceObject> _zoneControlThermostats;
    _zoneControlThermostats = workspace.getObjectsByType(IddObjectType::ZoneControl_Thermostat);

    for( const auto & _zoneControlThermostat : _zoneControlThermostats )
    {
      if( boost::optional<std::string> zoneName = _zoneControlThermostat.getString( ZoneControl_ThermostatFields::ZoneorZoneListName ) )
      {
//.........这里部分代码省略.........

OptionalModelObject ReverseTranslator::translateOutputIlluminanceMap( const WorkspaceObject & workspaceObject )
{
  if( workspaceObject.iddObject().type() != IddObjectType::Output_IlluminanceMap ){
    LOG(Error, "WorkspaceObject is not IddObjectType: Output:IlluminanceMap");
    return boost::none;
  }

  IlluminanceMap illuminanceMap( m_model );

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

  OptionalWorkspaceObject target = workspaceObject.getTarget(Output_IlluminanceMapFields::ZoneName);
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (modelObject->optionalCast<Space>()){
        illuminanceMap.setSpace(modelObject->cast<Space>());
      }
    }
  }

  OptionalDouble d = workspaceObject.getDouble(Output_IlluminanceMapFields::Zheight);
  if (d){
    illuminanceMap.setOriginZCoordinate(*d);
  }

  d = workspaceObject.getDouble(Output_IlluminanceMapFields::XMinimumCoordinate);
  if (d){
    illuminanceMap.setOriginXCoordinate(*d);

    OptionalDouble maxX = workspaceObject.getDouble(Output_IlluminanceMapFields::XMaximumCoordinate);
    if (maxX){
      illuminanceMap.setXLength(*maxX - *d);
    }
  }

  OptionalInt i = workspaceObject.getInt(Output_IlluminanceMapFields::NumberofXGridPoints);
  if (i){
    illuminanceMap.setNumberofXGridPoints(*i);
  }

  d = workspaceObject.getDouble(Output_IlluminanceMapFields::YMinimumCoordinate);
  if (d){
    illuminanceMap.setOriginYCoordinate(*d);

    OptionalDouble maxY = workspaceObject.getDouble(Output_IlluminanceMapFields::YMaximumCoordinate);
    if (maxY){
      illuminanceMap.setYLength(*maxY - *d);
    }
  }

  i = workspaceObject.getInt(Output_IlluminanceMapFields::NumberofYGridPoints);
  if (i){
    illuminanceMap.setNumberofYGridPoints(*i);
  }

  return illuminanceMap;
}

//.........这里部分代码省略.........
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (modelObject->optionalCast<Surface>()){
        subSurface->setSurface(modelObject->cast<Surface>());
      }
    }
  }

  // needs to be after .setSurface.
  s = workspaceObject.getString(FenestrationSurface_DetailedFields::SurfaceType);
  if (s) {
    if (istringEqual("Window", *s)){
      s = "FixedWindow";

      boost::optional<Surface> surface = subSurface->surface();
      if (surface){
        if ((surface->surfaceType() == "RoofCeiling") &&
            (surface->outsideBoundaryCondition() == "Outdoors")){
              s = "Skylight";
        }
      }
    }
    subSurface->setSubSurfaceType(*s);
  }

  target = workspaceObject.getTarget(openstudio::FenestrationSurface_DetailedFields::OutsideBoundaryConditionObject);
  if (target){
    if (target->iddObject().type() == IddObjectType::Zone){
      // Zone boundary condition

      OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
      if(modelObject->optionalCast<Space>()){
        Space adjacentSpace = modelObject->cast<Space>();

        OptionalSurface surface = subSurface->surface();
        if (surface && surface->space()){
          Space space = surface->space().get();

          if (surface->adjacentSurface()){
            Surface adjacentSurface = surface->adjacentSurface().get();

            if (adjacentSurface.space() && adjacentSpace.handle() == adjacentSurface.space()->handle()){
              Transformation transformation = adjacentSpace.transformation().inverse()*surface->space()->transformation();

              // duplicate subsurface in other space
              SubSurface adjacentSubSurface = subSurface->clone(m_model).cast<SubSurface>();
              adjacentSubSurface.setName(subSurface->name().get() + " Reversed");
              std::reverse(vertices.begin(), vertices.end());
              adjacentSubSurface.setVertices(transformation*vertices);
              adjacentSubSurface.setSurface(adjacentSurface);
              subSurface->setAdjacentSubSurface(adjacentSubSurface);

              return subSurface.get();
            }
          }
        }
      }

    }else if (target->iddObject().type() == IddObjectType::FenestrationSurface_Detailed){
      // SubSurface boundary condition

      // see if we have already mapped other sub surface, don't do it here because that is circular
      auto it = m_workspaceToModelMap.find(target->handle());
      if( it !=  m_workspaceToModelMap.end()){
        if (it->second.optionalCast<SubSurface>()){
          // this will set other side boundary object on both surfaces
          SubSurface adjacentSubSurface = it->second.cast<SubSurface>();
          subSurface->setAdjacentSubSurface(adjacentSubSurface);
          return subSurface.get();
        }
      }
    }else{  
      LOG(Error, "OutsideBoundaryConditionObject not yet mapped for object of type " << target->iddObject().name());
    }
  }

  // DLM: should these be before control paths that return above?
  OptionalDouble d = workspaceObject.getDouble(FenestrationSurface_DetailedFields::ViewFactortoGround);
  if (d) {
    subSurface->setViewFactortoGround(*d);
  }

  target = workspaceObject.getTarget(openstudio::FenestrationSurface_DetailedFields::ShadingControlName);
  if (target){
    LOG(Warn, "Shading Control Name not yet mapped for FenestrationSurface:Detailed");
  }

  target = workspaceObject.getTarget(openstudio::FenestrationSurface_DetailedFields::FrameandDividerName);
  if (target){
    LOG(Warn, "Frame and Divider Name not yet mapped for FenestrationSurface:Detailed");
  }

  OptionalInt i = workspaceObject.getInt(FenestrationSurface_DetailedFields::Multiplier);
  if (i) {
    subSurface->setMultiplier(*i);
  }

  return subSurface.get();
}

OptionalModelObject ReverseTranslator::translateDaylightingControls( const WorkspaceObject & workspaceObject )
{
  if( workspaceObject.iddObject().type() != IddObjectType::Daylighting_Controls ){
    LOG(Error, "WorkspaceObject is not IddObjectType: Daylighting:Controls");
    return boost::none;
  }

  DaylightingControl daylightingControl(m_model);

  OptionalThermalZone thermalZone;
  OptionalSpace space;
  OptionalWorkspaceObject target = workspaceObject.getTarget(Daylighting_ControlsFields::ZoneName);
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (modelObject->optionalCast<Space>()){
        space = modelObject->cast<Space>();
        thermalZone = space->thermalZone();
      }
    }
  }

  if (space){
    daylightingControl.setSpace(*space);
  }

  if (thermalZone){
    thermalZone->setPrimaryDaylightingControl(daylightingControl);
  }

  OptionalDouble d = workspaceObject.getDouble(Daylighting_ControlsFields::XCoordinateofFirstReferencePoint);
  if (d){
    daylightingControl.setPositionXCoordinate(*d);
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::YCoordinateofFirstReferencePoint);
  if (d){
    daylightingControl.setPositionYCoordinate(*d);
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::ZCoordinateofFirstReferencePoint);
  if (d){
    daylightingControl.setPositionZCoordinate(*d);
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::FractionofZoneControlledbyFirstReferencePoint);
  if (d && thermalZone){
    thermalZone->setFractionofZoneControlledbyPrimaryDaylightingControl(*d);
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::IlluminanceSetpointatFirstReferencePoint);
  if (d){
    daylightingControl.setIlluminanceSetpoint(*d);
  }

  OptionalInt i = workspaceObject.getInt(Daylighting_ControlsFields::LightingControlType);
  if (i){
    switch (*i){
      case 1:
        daylightingControl.setLightingControlType("Continuous");
        break;
      case 2:
        daylightingControl.setLightingControlType("Stepped");
        break;
      case 3:
        daylightingControl.setLightingControlType("Continuous/Off");
        break;
      default:
        ;
    }
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::GlareCalculationAzimuthAngleofViewDirectionClockwisefromZoneyAxis);
  if (d){
    daylightingControl.setThetaRotationAroundYAxis( -degToRad(*d) );
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::MaximumAllowableDiscomfortGlareIndex);
  if (d){
    daylightingControl.setMaximumAllowableDiscomfortGlareIndex(*d);
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::MinimumInputPowerFractionforContinuousDimmingControl);
  if (d){
    daylightingControl.setMinimumInputPowerFractionforContinuousDimmingControl(*d);
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::MinimumLightOutputFractionforContinuousDimmingControl);
  if (d){
    daylightingControl.setMinimumLightOutputFractionforContinuousDimmingControl(*d);
  }

  i = workspaceObject.getInt(Daylighting_ControlsFields::NumberofSteppedControlSteps);
  if (i){
    daylightingControl.setNumberofSteppedControlSteps(*i);
  }

  d = workspaceObject.getDouble(Daylighting_ControlsFields::ProbabilityLightingwillbeResetWhenNeededinManualSteppedControl);
  if (d){
    daylightingControl.setProbabilityLightingwillbeResetWhenNeededinManualSteppedControl(*d);
//.........这里部分代码省略.........

TEST_F(EnergyPlusFixture,ForwardTranslator_TableMultiVariableLookup)
{
  {
    Model m;
    TableMultiVariableLookup table(m,1);

    ASSERT_TRUE(table.addPoint(70,0.1));
    ASSERT_TRUE(table.addPoint(72,0.3));
    ASSERT_TRUE(table.addPoint(74,0.5));
    ASSERT_TRUE(table.addPoint(76,0.7));
    ASSERT_TRUE(table.addPoint(78,0.9));

    ForwardTranslator ft;
    Workspace workspace = ft.translateModel(m);

    std::vector<WorkspaceObject> tableObjects = workspace.getObjectsByType(IddObjectType::Table_MultiVariableLookup);
    ASSERT_EQ(1u, tableObjects.size());

    WorkspaceObject idfTable = tableObjects.front();

    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InterpolationMethod).get(),"LagrangeInterpolationLinearExtrapolation");
    ASSERT_EQ(idfTable.getInt(Table_MultiVariableLookupFields::NumberofInterpolationPoints).get(),3);
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::TableDataFormat).get(),"SingleLineIndependentVariableWithMatrix");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::X1SortOrder).get(),"Ascending");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::X2SortOrder).get(),"Ascending");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX1).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX2).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX3).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX4).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX5).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::OutputUnitType).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getInt(Table_MultiVariableLookupFields::NumberofIndependentVariables).get(),1);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(0).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),5);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(1).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),70);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(2).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),72);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(3).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),74);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(4).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),76);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(5).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),78);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(6).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),0.1);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(7).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),0.3);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(8).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),0.5);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(9).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),0.7);
    ASSERT_DOUBLE_EQ(idfTable.getExtensibleGroup(10).getDouble(Table_MultiVariableLookupExtensibleFields::Data).get(),0.9);
  }

  {
    Model m;
    TableMultiVariableLookup table(m,2);

    ASSERT_TRUE(table.addPoint(70,32,0.1));
    ASSERT_TRUE(table.addPoint(72,32,0.3));
    ASSERT_TRUE(table.addPoint(74,32,0.5));
    ASSERT_TRUE(table.addPoint(76,32,0.7));
    ASSERT_TRUE(table.addPoint(78,32,0.9));

    ASSERT_TRUE(table.addPoint(70,45,0.2));
    ASSERT_TRUE(table.addPoint(72,45,0.4));
    ASSERT_TRUE(table.addPoint(74,45,0.6));
    ASSERT_TRUE(table.addPoint(76,45,0.8));
    ASSERT_TRUE(table.addPoint(78,45,1.0));

    ASSERT_TRUE(table.addPoint(70,68,0.3));
    ASSERT_TRUE(table.addPoint(72,68,0.5));
    ASSERT_TRUE(table.addPoint(74,68,0.7));
    ASSERT_TRUE(table.addPoint(76,68,0.9));
    ASSERT_TRUE(table.addPoint(78,68,1.1));

    ASSERT_TRUE(table.addPoint(70,81,0.4));
    ASSERT_TRUE(table.addPoint(72,81,0.6));
    ASSERT_TRUE(table.addPoint(74,81,0.8));
    ASSERT_TRUE(table.addPoint(76,81,1.0));
    ASSERT_TRUE(table.addPoint(78,81,1.2));

    ASSERT_TRUE(table.addPoint(70,94,0.5));
    ASSERT_TRUE(table.addPoint(72,94,0.7));
    ASSERT_TRUE(table.addPoint(74,94,0.9));
    ASSERT_TRUE(table.addPoint(76,94,1.1));
    ASSERT_TRUE(table.addPoint(78,94,1.3));

    ASSERT_TRUE(table.addPoint(70,107,0.6));
    ASSERT_TRUE(table.addPoint(72,107,0.8));
    ASSERT_TRUE(table.addPoint(74,107,1.0));
    ASSERT_TRUE(table.addPoint(76,107,1.2));
    ASSERT_TRUE(table.addPoint(78,107,1.4));

    ForwardTranslator ft;
    Workspace workspace = ft.translateModel(m);

    std::vector<WorkspaceObject> tableObjects = workspace.getObjectsByType(IddObjectType::Table_MultiVariableLookup);
    ASSERT_EQ(1u, tableObjects.size());

    WorkspaceObject idfTable = tableObjects.front();
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InterpolationMethod).get(),"LagrangeInterpolationLinearExtrapolation");
    ASSERT_EQ(idfTable.getInt(Table_MultiVariableLookupFields::NumberofInterpolationPoints).get(),3);
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::TableDataFormat).get(),"SingleLineIndependentVariableWithMatrix");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::X1SortOrder).get(),"Ascending");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::X2SortOrder).get(),"Ascending");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX1).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX2).get(),"Dimensionless");
    ASSERT_EQ(idfTable.getString(Table_MultiVariableLookupFields::InputUnitTypeforX3).get(),"Dimensionless");
//.........这里部分代码省略.........

OptionalModelObject ReverseTranslator::translateRunPeriod( const WorkspaceObject & workspaceObject )
{
  OptionalModelObject result;
  openstudio::model::RunPeriod runPeriod = m_model.getUniqueModelObject<openstudio::model::RunPeriod>();
  OptionalString optS = workspaceObject.name();
  if(optS)
  {
    runPeriod.setName(*optS);
  }
  OptionalInt i;

  i = workspaceObject.getInt(openstudio::RunPeriodFields::BeginMonth);
  if( i )
  {
    runPeriod.setBeginMonth( *i );
  }

  i = workspaceObject.getInt(openstudio::RunPeriodFields::BeginDayofMonth);
  if( i )
  {
    runPeriod.setBeginDayOfMonth( *i );
  }

  i = workspaceObject.getInt(openstudio::RunPeriodFields::EndMonth);
  if( i )
  {
    runPeriod.setEndMonth( *i );
  }

  i = workspaceObject.getInt(openstudio::RunPeriodFields::EndDayofMonth);
  if( i )
  {
    runPeriod.setEndDayOfMonth( *i );
  }

  optS = workspaceObject.getString(RunPeriodFields::DayofWeekforStartDay);
  if(optS)
  {
    boost::optional<model::YearDescription> yd = runPeriod.model().getOptionalUniqueModelObject<model::YearDescription>();
    if (yd){
      if (!istringEqual(*optS, yd->dayofWeekforStartDay())){
        LOG(Warn, "Multiple values detected for dayofWeekforStartDay, using " << yd->dayofWeekforStartDay());
      }
    }else{
      // create a year description
      yd = runPeriod.model().getUniqueModelObject<model::YearDescription>();
      yd->setDayofWeekforStartDay(*optS);
    }

  }//if(optS)

  optS = workspaceObject.getString(RunPeriodFields::UseWeatherFileHolidaysandSpecialDays);
  if(optS)
  {
    std::string temp=*optS;
    boost::to_lower(temp);
    if( temp == "no")
    {
      runPeriod.setUseWeatherFileHolidays(false);
    }
    else
    {runPeriod.setUseWeatherFileHolidays(true);
    }
  }
  optS = workspaceObject.getString(RunPeriodFields::UseWeatherFileDaylightSavingPeriod);
  if(optS)
  {
    std::string temp=*optS;
    boost::to_lower(temp);
    if( temp == "no")
    {
      runPeriod.setUseWeatherFileDaylightSavings(false);
    }
    else
    {
      runPeriod.setUseWeatherFileDaylightSavings(true);
    }
  }
  optS = workspaceObject.getString(RunPeriodFields::ApplyWeekendHolidayRule);
  if(optS)
  {
    std::string temp=*optS;
    boost::to_lower(temp);
    if( temp == "no")
    {
      runPeriod.setApplyWeekendHolidayRule(false);
    }
    else
    {
      runPeriod.setApplyWeekendHolidayRule(true);
    }
  }
  optS = workspaceObject.getString(RunPeriodFields::UseWeatherFileRainIndicators);
  if(optS)
  {
    std::string temp=*optS;
    boost::to_lower(temp);
    if( temp == "no")
    {
      runPeriod.setUseWeatherFileRainInd(false);
//.........这里部分代码省略.........

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

  // ensure that site and simulation control have been mapped
  for (const WorkspaceObject& siteObject : m_workspace.getObjectsByType(IddObjectType::Site_Location)){
    translateAndMapWorkspaceObject(siteObject);
  }

  for (const WorkspaceObject& simControlObject : m_workspace.getObjectsByType(IddObjectType::SimulationControl)){
    translateAndMapWorkspaceObject(simControlObject);
  }

  // create the building
  openstudio::model::Building building = m_model.getUniqueModelObject<Building>();
  
  OptionalString s = workspaceObject.name();
  if(s){
    building.setName(*s);
  }

  OptionalDouble d = workspaceObject.getDouble(openstudio::BuildingFields::NorthAxis);
  if( d ){
    building.setNorthAxis(*d);
  }

  // fields that go to site
  s = workspaceObject.getString(openstudio::BuildingFields::Terrain);
  if (s){
    boost::optional<Site> site = m_model.getOptionalUniqueModelObject<Site>();
    if (site){
      site->setTerrain(*s);
    }
  }

  // fields that go to simulation control
  d = workspaceObject.getDouble(openstudio::BuildingFields::LoadsConvergenceToleranceValue);
  if(d){
    boost::optional<SimulationControl> simulationControl = m_model.getUniqueModelObject<SimulationControl>();
    if (simulationControl){
      simulationControl->setLoadsConvergenceToleranceValue(*d);
    }
  }

  d = workspaceObject.getDouble(openstudio::BuildingFields::TemperatureConvergenceToleranceValue);
  if(d){
    boost::optional<SimulationControl> simulationControl = m_model.getUniqueModelObject<SimulationControl>();
    if (simulationControl){
      simulationControl->setTemperatureConvergenceToleranceValue(*d);
    }
  }

  s = workspaceObject.getString(openstudio::BuildingFields::SolarDistribution);
  if(s){
    boost::optional<SimulationControl> simulationControl = m_model.getUniqueModelObject<SimulationControl>();
    if (simulationControl){
      simulationControl->setSolarDistribution(*s);
    }
  }

  OptionalInt i = workspaceObject.getInt(openstudio::BuildingFields::MaximumNumberofWarmupDays);
  if(i){
    boost::optional<SimulationControl> simulationControl = m_model.getUniqueModelObject<SimulationControl>();
    if (simulationControl){
      simulationControl->setMaximumNumberofWarmupDays(*i);
    }
  }

  i = workspaceObject.getInt(openstudio::BuildingFields::MinimumNumberofWarmupDays);
  if (i) {
    boost::optional<SimulationControl> simulationControl = m_model.getUniqueModelObject<SimulationControl>();
    if (simulationControl){
      simulationControl->setMinimumNumberofWarmupDays(*i);
    }
  }

  return building;
}