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

TEST_F(EnergyPlusFixture,ReverseTranslatorTest_TranslateScheduleCompact) {
  openstudio::Workspace workspace(openstudio::StrictnessLevel::None,openstudio::IddFileType::EnergyPlus);

  openstudio::IdfObject idfObject( openstudio::IddObjectType::Schedule_Compact );
  idfObject.setString(1,"Fraction");
  idfObject.setString(2,"Through: 12/31");
  idfObject.setString(3,"For: Weekdays SummerDesignDay");
  idfObject.setString(4,"Until: 08:00");
  idfObject.setString(5,"0.0");
  idfObject.setString(6,"Until: 18:00");
  idfObject.setString(7,"1.0");
  idfObject.setString(8,"Until: 24:00");
  idfObject.setString(9,"0.0");
  idfObject.setString(10,"For: Weekends WinterDesignDay");
  idfObject.setString(11,"Until: 10:00");
  idfObject.setString(12,"0.0");
  idfObject.setString(13,"Until: 16:00");
  idfObject.setString(14,"1.0");
  idfObject.setString(15,"Until: 24:00");
  idfObject.setString(16,"0.0");
  idfObject.setString(17,"For: Holidays AllOtherDays");
  idfObject.setString(18,"Until: 24:00");
  idfObject.setString(19,"0.0");

  WorkspaceObject epScheduleCompact = workspace.addObject(idfObject).get();

  ReverseTranslator trans;
  ASSERT_NO_THROW(trans.translateWorkspace(workspace));
  Model model = trans.translateWorkspace(workspace);

  ASSERT_EQ(static_cast<unsigned>(1), model.getModelObjects<openstudio::model::ScheduleCompact>().size());
  openstudio::model::ScheduleCompact scheduleCompact = model.getModelObjects<openstudio::model::ScheduleCompact>()[0];

  EXPECT_EQ(unsigned(20),epScheduleCompact.numFields());
  EXPECT_EQ(unsigned(21),scheduleCompact.numFields()); // has handle field

  ASSERT_EQ(epScheduleCompact.numFields() + 1u,scheduleCompact.numFields());

  ASSERT_TRUE(epScheduleCompact.name());
  ASSERT_TRUE(scheduleCompact.name());
  EXPECT_EQ(epScheduleCompact.name().get(),scheduleCompact.name().get());

  for( unsigned i = 1; i < epScheduleCompact.numFields(); i++ )
  {
    boost::optional<std::string> s1 = epScheduleCompact.getString(i);
    boost::optional<std::string> s2 = scheduleCompact.getString(i+1);

    ASSERT_TRUE(s1);
    ASSERT_TRUE(s2);

    EXPECT_EQ(s1.get(),s2.get());
  }
}

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

  // create the definition
  openstudio::model::InternalMassDefinition definition(m_model);
  
  OptionalString s = workspaceObject.name();
  if(s){
    definition.setName(*s + " Definition");
  }

  OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::InternalMassFields::ConstructionName);
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (modelObject->optionalCast<ConstructionBase>()){
        definition.setConstruction(modelObject->cast<ConstructionBase>());
      }
    }
  }

  OptionalDouble d = workspaceObject.getDouble(openstudio::InternalMassFields::SurfaceArea);
  if(d){
    definition.setSurfaceArea(*d);
  }

  // create the instance
  InternalMass internalMass(definition);

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

  target = workspaceObject.getTarget(openstudio::InternalMassFields::ZoneName);
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (modelObject->optionalCast<Space>()){
        internalMass.setSpace(modelObject->cast<Space>());
      }else if (modelObject->optionalCast<SpaceType>()){
        internalMass.setSpaceType(modelObject->cast<SpaceType>());
      }
    }
  }

  return internalMass;
}

bool WorkspaceObjectNameGreater::operator()(const WorkspaceObject& a, const WorkspaceObject& b) const
{
  std::string aname;
  boost::optional<std::string> oaname = a.name();
  if (oaname){
    aname = *oaname;
  }
  std::string bname;
  boost::optional<std::string> obname = b.name();
  if (obname){
    bname = *obname;
  }
  return istringLess(bname, aname);
}

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

    Site site = m_model.getUniqueModelObject<Site>();
    OptionalString optS = workspaceObject.name();
    if(optS) {
        site.setName(*optS);
    }

    OptionalDouble od = workspaceObject.getDouble(Site_LocationFields::Latitude);
    if(od) {
        site.setLatitude(*od);
    }

    od = workspaceObject.getDouble(Site_LocationFields::Longitude);
    if(od) {
        site.setLongitude(*od);
    }

    od = workspaceObject.getDouble(Site_LocationFields::TimeZone);
    if(od) {
        site.setTimeZone(*od);
    }

    od = workspaceObject.getDouble(Site_LocationFields::Elevation);
    if(od) {
        site.setElevation(*od);
    }

    return site;
}

boost::optional<ModelObject> ReverseTranslator::translateCurveQuadraticLinear(
    const WorkspaceObject& workspaceObject)
{
    CurveQuadraticLinear curve(m_model);

    OptionalString s;
    OptionalDouble d;

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

    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient1Constant))) {
        curve.setCoefficient1Constant(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient2x))) {
        curve.setCoefficient2x(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient3x_POW_2))) {
        curve.setCoefficient3xPOW2(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient4y))) {
        curve.setCoefficient4y(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient5x_TIMES_y))) {
        curve.setCoefficient5xTIMESY(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient6x_POW_2_TIMES_y))) {
        curve.setCoefficient6xPOW2TIMESY(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumValueofx))) {
        curve.setMinimumValueofx(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumValueofx))) {
        curve.setMaximumValueofx(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumValueofy))) {
        curve.setMinimumValueofy(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumValueofy))) {
        curve.setMaximumValueofy(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumCurveOutput))) {
        curve.setMinimumCurveOutput(*d);
    }
    if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumCurveOutput))) {
        curve.setMaximumCurveOutput(*d);
    }
    if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::InputUnitTypeforX,false,true))) {
        curve.setInputUnitTypeforX(*s);
    }
    if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::InputUnitTypeforY,false,true))) {
        curve.setInputUnitTypeforY(*s);
    }
    if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::OutputUnitType,false,true))) {
        curve.setOutputUnitType(*s);
    }

    return curve;
}

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;
}

boost::optional<ModelObject> ReverseTranslator::translateCurveFunctionalPressureDrop( 
    const WorkspaceObject& workspaceObject )
{
  CurveFunctionalPressureDrop curve(m_model);

  OptionalString s;
  OptionalDouble d;
  
  if ((s = workspaceObject.name())) {
    curve.setName(*s);
  }

  if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Diameter))) {
    curve.setDiameter(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::MinorLossCoefficient))) {
    curve.setMinorLossCoefficient(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Length))) {
    curve.setLength(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Roughness))) {
    curve.setRoughness(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::FixedFrictionFactor))) {
    curve.setFixedFrictionFactor(*d);
  }

  return curve;
}

OptionalModelObject ReverseTranslator::translateWindowMaterialSimpleGlazingSystem( const WorkspaceObject & workspaceObject )
{
  OptionalModelObject result;
  SimpleGlazing simpleGlazing( m_model );
  OptionalString optS = workspaceObject.name();
  if(optS)
  {
    simpleGlazing.setName(*optS);
  }

  OptionalDouble d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::UFactor);
  if(d) {
    simpleGlazing.setUFactor(*d);
  }

  d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::SolarHeatGainCoefficient);
  if(d) {
    simpleGlazing.setSolarHeatGainCoefficient(*d);
  }

  d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::VisibleTransmittance);
  if(d) {
    simpleGlazing.setVisibleTransmittance(*d);
  }

  result = simpleGlazing;
  return result;
}

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::translateZoneInfiltrationEffectiveLeakageArea( const WorkspaceObject & workspaceObject )
{
  if( workspaceObject.iddObject().type() != IddObjectType::ZoneInfiltration_EffectiveLeakageArea ){
    LOG(Error, "WorkspaceObject " << workspaceObject.briefDescription()
        << " is not IddObjectType: SpaceInfiltration_EffectiveLeakageArea");
    return boost::none;
  }

  // create the instance
  SpaceInfiltrationEffectiveLeakageArea spaceInfiltrationEffectiveLeakageArea(m_model);

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

  OptionalWorkspaceObject target = workspaceObject.getTarget(ZoneInfiltration_EffectiveLeakageAreaFields::ZoneName);
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (modelObject->optionalCast<Space>()){
        spaceInfiltrationEffectiveLeakageArea.setSpace(modelObject->cast<Space>());
      }else if (modelObject->optionalCast<SpaceType>()){
        spaceInfiltrationEffectiveLeakageArea.setSpaceType(modelObject->cast<SpaceType>());
      }
    }
  }

  target = workspaceObject.getTarget(ZoneInfiltration_EffectiveLeakageAreaFields::ScheduleName);
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
        Schedule schedule(*intermediate);
        spaceInfiltrationEffectiveLeakageArea.setSchedule(schedule);
      }
    }
  }

  boost::optional<double> value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::EffectiveAirLeakageArea);
  if( value )
  {
    spaceInfiltrationEffectiveLeakageArea.setEffectiveAirLeakageArea(value.get());
  }

  value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::StackCoefficient);
  if( value )
  {
    spaceInfiltrationEffectiveLeakageArea.setStackCoefficient(value.get());
  }

  value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::WindCoefficient);
  if( value )
  {
    spaceInfiltrationEffectiveLeakageArea.setWindCoefficient(value.get());
  }
  
  return spaceInfiltrationEffectiveLeakageArea;
}

OptionalModelObject ReverseTranslator::translateMaterial( const WorkspaceObject & workspaceObject )
{
  OptionalModelObject result;
  if( workspaceObject.iddObject().type() != IddObjectType::Material )
  {
    LOG(Error, "WorkspaceObject is not IddObjectType: Material");
    return result;
  }

  openstudio::model::StandardOpaqueMaterial mat( m_model );
  OptionalString optS = workspaceObject.name();
  if(optS) {
    mat.setName(*optS);
  }

  optS = workspaceObject.getString(MaterialFields::Roughness);
  if(optS) {
    mat.setRoughness(*optS);
  }

  OptionalDouble od = workspaceObject.getDouble( MaterialFields::Thickness );
  if(od) {
    mat.setThickness(*od);
  }

  od = workspaceObject.getDouble( MaterialFields::Conductivity );
  if(od) {
    mat.setThermalConductivity(*od);
  }

  od = workspaceObject.getDouble( MaterialFields::Density );
  if(od) {
    mat.setDensity(*od);
  }

  od = workspaceObject.getDouble( MaterialFields::SpecificHeat );
  if(od) {
    mat.setSpecificHeat(*od);
  }

  od = workspaceObject.getDouble( MaterialFields::ThermalAbsorptance );
  if(od) {
    mat.setThermalAbsorptance(od);
  }

  od = workspaceObject.getDouble( MaterialFields::SolarAbsorptance );
  if(od) {
    mat.setSolarAbsorptance(od);
  }

  od = workspaceObject.getDouble( MaterialFields::VisibleAbsorptance );
  if(od) {
    mat.setVisibleAbsorptance(od);
  }

  result = mat;
  return result;
}

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

  openstudio::Point3dVector vertices = getVertices(Shading_Building_DetailedFields::NumberofVertices + 1, workspaceObject);
 
  boost::optional<ShadingSurface> shadingSurface;
  try{
    shadingSurface = ShadingSurface(vertices, m_model);
  }catch(const std::exception&){
    LOG(Error, "Cannot create ShadingSurface for object: " << workspaceObject);
    return boost::none;
  }

  OptionalString s = workspaceObject.name();
  if(s) {
    shadingSurface->setName(*s);
  }

  // look for first site level shading surface group
  OptionalShadingSurfaceGroup shadingSurfaceGroup;
  for (const ShadingSurfaceGroup& group : m_model.getConcreteModelObjects<ShadingSurfaceGroup>()){
    if (istringEqual("Building", group.shadingSurfaceType())){
      shadingSurfaceGroup = group;
      break;
    }
  }

  // if not found make one
  if (!shadingSurfaceGroup){
    shadingSurfaceGroup = ShadingSurfaceGroup(m_model);
    shadingSurfaceGroup->setShadingSurfaceType("Building");
  }

  shadingSurface->setShadingSurfaceGroup(*shadingSurfaceGroup);

  OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::Shading_Building_DetailedFields::TransmittanceScheduleName);
  if (target){
    OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
    if (modelObject){
      if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
        Schedule schedule(*intermediate);
        shadingSurface->setTransmittanceSchedule(schedule);
      }
    }
  }

  return shadingSurface.get();
}

boost::optional<ModelObject> ReverseTranslator::translateCurveSigmoid( 
    const WorkspaceObject& workspaceObject )
{
  CurveSigmoid curve(m_model);

  OptionalString s;
  OptionalDouble d;
  
  if ((s = workspaceObject.name())) {
    curve.setName(*s);
  }

  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient1C1))) {
    curve.setCoefficient1C1(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient2C2))) {
    curve.setCoefficient2C2(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient3C3))) {
    curve.setCoefficient3C3(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient4C4))) {
    curve.setCoefficient4C4(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient5C5))) {
    curve.setCoefficient5C5(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MinimumValueofx))) {
    curve.setMinimumValueofx(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MaximumValueofx))) {
    curve.setMaximumValueofx(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MinimumCurveOutput))) {
    curve.setMinimumCurveOutput(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MaximumCurveOutput))) {
    curve.setMaximumCurveOutput(*d);
  }
  if ((s = workspaceObject.getString(Curve_SigmoidFields::InputUnitTypeforx,false,true))) {
    curve.setInputUnitTypeforx(*s);
  }
  if ((s = workspaceObject.getString(Curve_SigmoidFields::OutputUnitType,false,true))) {
    curve.setOutputUnitType(*s);
  }

  return curve;
}

boost::optional<ModelObject> ReverseTranslator::translateCurveCubic( 
    const WorkspaceObject& workspaceObject )
{
  CurveCubic curve(m_model);

  OptionalString s;
  OptionalDouble d;
  
  if ((s = workspaceObject.name())) {
    curve.setName(*s);
  }

  if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient1Constant))) {
    curve.setCoefficient1Constant(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient2x))) {
    curve.setCoefficient2x(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient3x_POW_2))) {
    curve.setCoefficient3xPOW2(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient4x_POW_3))) {
    curve.setCoefficient4xPOW3(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_CubicFields::MinimumValueofx))) {
    curve.setMinimumValueofx(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_CubicFields::MaximumValueofx))) {
    curve.setMaximumValueofx(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_CubicFields::MinimumCurveOutput))) {
    curve.setMinimumCurveOutput(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_CubicFields::MaximumCurveOutput))) {
    curve.setMaximumCurveOutput(*d);
  }
  if ((s = workspaceObject.getString(Curve_CubicFields::InputUnitTypeforX,false,true))) {
    curve.setInputUnitTypeforX(*s);
  }
  if ((s = workspaceObject.getString(Curve_CubicFields::OutputUnitType,false,true))) {
    curve.setOutputUnitType(*s);
  }

  return curve;
}

boost::optional<ModelObject> ReverseTranslator::translateCurveFanPressureRise( 
    const WorkspaceObject& workspaceObject )
{
  CurveFanPressureRise curve(m_model);

  OptionalString s;
  OptionalDouble d;
  
  if ((s = workspaceObject.name())) {
    curve.setName(*s);
  }

  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient1C1))) {
    curve.setCoefficient1C1(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient2C2))) {
    curve.setCoefficient2C2(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient3C3))) {
    curve.setCoefficient3C3(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient4C4))) {
    curve.setCoefficient4C4(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumValueofQfan))) {
    curve.setMinimumValueofQfan(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumValueofQfan))) {
    curve.setMaximumValueofQfan(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumValueofPsm))) {
    curve.setMinimumValueofPsm(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumValueofPsm))) {
    curve.setMaximumValueofPsm(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumCurveOutput))) {
    curve.setMinimumCurveOutput(*d);
  }
  if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumCurveOutput))) {
    curve.setMaximumCurveOutput(*d);
  }

  return curve;
}