TEST_F(UnitsFixture,QuantityConverter_PowerDensity) {
    Quantity siLpd(10.0,createSIPowerDensity());
    Unit ipPowerDensity = createUnit("W/ft^2").get();
    OptionalQuantity ipLpd = convert(siLpd,ipPowerDensity);
    Quantity siArea(1.0,pow(createSILength(),2));
    OptionalQuantity ipArea = convert(siArea,UnitSystem(UnitSystem::IP));
    ASSERT_TRUE(ipLpd);
    ASSERT_TRUE(ipArea);
    EXPECT_NEAR(10.0/ipArea->value(),ipLpd->value(),tol);
    EXPECT_EQ("W/ft^2",ipLpd->prettyUnitsString());
}
Ejemplo n.º 2
0
OSQuantityVector convert(const OSQuantityVector& original, const Unit& targetUnits) {
  OSQuantityVector result;
  Quantity testQuantity(0.0,original.units());
  OptionalQuantity offset = convert(testQuantity,targetUnits);
  if (!offset) {
    return result;
  }
  testQuantity.setValue(1.0);
  OptionalQuantity factorPlusOffset = convert(testQuantity,targetUnits);
  OS_ASSERT(factorPlusOffset);
  OS_ASSERT(offset->units() == factorPlusOffset->units());
  result = OSQuantityVector(offset->units(),original.values());
  result = result * (factorPlusOffset->value() - offset->value()) + offset.get();
  return result;
}
Ejemplo n.º 3
0
TEST_F(UnitsFixture,IddUnits_DefaultValue) {
  IdfObject idfObject(IddObjectType::OS_Building);
  // IdfObject::getQuantity(unsigned index, bool returnDefault=false, bool returnIP=false) const;

  // this field is empty but has a default value of 3 m
  EXPECT_TRUE(idfObject.getQuantity(OS_BuildingFields::NominalFloortoFloorHeight, false).empty());

  OSOptionalQuantity siQ = idfObject.getQuantity(OS_BuildingFields::NominalFloortoFloorHeight, true, false);
  ASSERT_FALSE(siQ.empty());
  OptionalUnit mUnit = createUnit("m");
  ASSERT_TRUE(mUnit);
  EXPECT_EQ(*mUnit, siQ.get().units());
  EXPECT_EQ(3.0, siQ.get().value());

  OSOptionalQuantity ipQ = idfObject.getQuantity(OS_BuildingFields::NominalFloortoFloorHeight, true, true);
  ASSERT_FALSE(ipQ.empty());
  OptionalUnit ftUnit = createUnit("ft");
  ASSERT_TRUE(ftUnit);
  EXPECT_EQ(*ftUnit, ipQ.get().units());
  EXPECT_NE(3.0, ipQ.get().value());
  
  OptionalQuantity q = QuantityConverter::instance().convert(ipQ.get(), *mUnit);
  ASSERT_TRUE(q);
  EXPECT_DOUBLE_EQ(3.0, q->value());
}
TEST_F(UnitsFixture,QuantityConverter_CFMandSIUsingSystem)
{
    LOG(Debug, "QuantityConverter_CFMandSIUsingSystem");

    SIUnit siu1(openstudio::SIExpnt(1));
    Quantity oneKg(1.0, siu1);
    OptionalQuantity intermediate = QuantityConverter::instance().convert(oneKg, UnitSystem(UnitSystem::CFM));
    ASSERT_TRUE(intermediate);
    OptionalQuantity copyOfCopy = QuantityConverter::instance().convert(*intermediate, UnitSystem(UnitSystem::SI));
    ASSERT_TRUE(copyOfCopy);
    EXPECT_NEAR(oneKg.value(),copyOfCopy->value(),tol);
    EXPECT_EQ(oneKg.standardUnitsString(false),copyOfCopy->standardUnitsString(false));
}
Ejemplo n.º 5
0
TEST_F(ModelFixture, PlanarSurface_FilmResistanceConversions)
{
  Quantity q;
  OptionalQuantity qc;

  q = createQuantity(0.61,"ft^2*R*h/Btu").get();
  qc = QuantityConverter::instance().convert(q,UnitSystem(UnitSystem::SI));
  ASSERT_TRUE(qc);
  EXPECT_EQ("s^3*K/kg",qc->standardUnitsString());
  EXPECT_NEAR(qc->value(),PlanarSurface::filmResistance(FilmResistanceType::StillAir_HorizontalSurface_HeatFlowsUpward),1.0E-8);

  q = createQuantity(0.62,"ft^2*R*h/Btu").get();
  qc = QuantityConverter::instance().convert(q,UnitSystem(UnitSystem::SI));
  ASSERT_TRUE(qc);
  EXPECT_EQ("s^3*K/kg",qc->standardUnitsString());
  EXPECT_NEAR(qc->value(),PlanarSurface::filmResistance(FilmResistanceType::StillAir_45DegreeSurface_HeatFlowsUpward),1.0E-8);

  q = createQuantity(0.68,"ft^2*R*h/Btu").get();
  qc = QuantityConverter::instance().convert(q,UnitSystem(UnitSystem::SI));
  ASSERT_TRUE(qc);
  EXPECT_EQ("s^3*K/kg",qc->standardUnitsString());
  EXPECT_NEAR(qc->value(),PlanarSurface::filmResistance(FilmResistanceType::StillAir_VerticalSurface),1.0E-8);

  q = createQuantity(0.76,"ft^2*R*h/Btu").get();
  qc = QuantityConverter::instance().convert(q,UnitSystem(UnitSystem::SI));
  ASSERT_TRUE(qc);
  EXPECT_EQ("s^3*K/kg",qc->standardUnitsString());
  EXPECT_NEAR(qc->value(),PlanarSurface::filmResistance(FilmResistanceType::StillAir_45DegreeSurface_HeatFlowsDownward),1.0E-8);

  q = createQuantity(0.92,"ft^2*R*h/Btu").get();
  qc = QuantityConverter::instance().convert(q,UnitSystem(UnitSystem::SI));
  ASSERT_TRUE(qc);
  EXPECT_EQ("s^3*K/kg",qc->standardUnitsString());
  EXPECT_NEAR(qc->value(),PlanarSurface::filmResistance(FilmResistanceType::StillAir_HorizontalSurface_HeatFlowsDownward),1.0E-8);

  q = createQuantity(0.17,"ft^2*R*h/Btu").get();
  qc = QuantityConverter::instance().convert(q,UnitSystem(UnitSystem::SI));
  ASSERT_TRUE(qc);
  EXPECT_EQ("s^3*K/kg",qc->standardUnitsString());
  EXPECT_NEAR(qc->value(),PlanarSurface::filmResistance(FilmResistanceType::MovingAir_15mph),1.0E-8);

  q = createQuantity(0.25,"ft^2*R*h/Btu").get();
  qc = QuantityConverter::instance().convert(q,UnitSystem(UnitSystem::SI));
  ASSERT_TRUE(qc);
  EXPECT_EQ("s^3*K/kg",qc->standardUnitsString());
  EXPECT_NEAR(qc->value(),PlanarSurface::filmResistance(FilmResistanceType::MovingAir_7p5mph),1.0E-8);
}
Ejemplo n.º 6
0
TEST_F(IdfFixture, IdfObject_GetQuantity)
{
    std::string text = "Building,                !- Building \n\
                      Building,                !- Name \n\
                      30.,                     !- North Axis {deg} \n\
                      City,                    !- Terrain \n\
                      0.04,                    !- Loads Convergence Tolerance Value \n\
                      0.4,                     !- Temperature Convergence Tolerance Value {deltaC} \n\
                      FullExterior,            !- Solar Distribution \n\
                      25;                      !- Maximum Number of Warmup Days";

  // make an idf object
  OptionalIdfObject oObj = IdfObject::load(text);
  ASSERT_TRUE(oObj);

  // Test get.
  OSOptionalQuantity ooq = oObj->getQuantity (4);
  ASSERT_TRUE(ooq.isSet());
  Quantity q = ooq.get();
  EXPECT_TRUE(q.value() == 0.4);
  EXPECT_TRUE(q.system() == UnitSystem::SI);
  EXPECT_TRUE(q.standardUnitsString() == "K");

  // Test set.
  OptionalQuantity oq = convert(q,UnitSystem(UnitSystem::IP));
  ASSERT_TRUE(oq);
  EXPECT_TRUE(oq->system() == UnitSystem::IP);
  EXPECT_DOUBLE_EQ(0.72,oq->value());
  oq->setValue(1.5);

  EXPECT_TRUE(oObj->setQuantity(4, *oq));
  ooq = oObj->getQuantity(4);
  ASSERT_TRUE(ooq.isSet());
  q = ooq.get();
  EXPECT_DOUBLE_EQ(0.83333333333333333,q.value());
  EXPECT_TRUE(q.system() == UnitSystem::SI);
  EXPECT_TRUE(q.standardUnitsString() == "K");
}
double SchedulesTabController::defaultStartingValue(const model::ScheduleDay& scheduleDay) {
  double result(0.3);
  if (model::OptionalScheduleTypeLimits typeLimits = scheduleDay.scheduleTypeLimits()) {
    OptionalUnit siU = model::ScheduleTypeLimits::units(typeLimits->unitType(),false);
    if (siU) {
      std::string unitType = typeLimits->unitType();
      boost::to_lower(unitType);
      char firstLetter = unitType[0];
      OptionalQuantity siQ;
      switch (firstLetter) {
      case 'a' :
        { 
          if (unitType == "activitylevel") {          
            siQ = Quantity(100.0,*siU);
          }
          else if (unitType == "angle") {
            siQ = Quantity(0.0,*siU);
          }
          else if (unitType == "availability") {
            siQ = Quantity(1.0,*siU);
          }
          break;
        }
      case 'c' :
        {
          if (unitType == "capacity") {
            siQ = Quantity(100.0,*siU);
          }
          else if (unitType == "clothinginsulation") {
            siQ = Quantity(0.5,*siU);
          }
          else if (unitType == "controlmode") {
            siQ = Quantity(0.0,*siU);
          }
          else if (unitType == "convectioncoefficient") {
            siQ = Quantity(10.0,*siU);
          }
          break;
        }
      case 'd' :
        {
          if (unitType == "deltatemperature") {
            siQ = Quantity(3.0,*siU);
          }
          break;
        }
      case 'm' :
        {
          if (unitType == "massflowrate") {
            siQ = Quantity(1.0,*siU);
          }
          break;
        }
      case 'p' :
        {
          if (unitType == "percent") {
            siQ = Quantity(50.0,*siU);
          }
          else if (unitType == "power") {
            siQ = Quantity(100.0,*siU);
          }
          else if (unitType == "precipitationrate") {
            siQ = Quantity(0.01,*siU);
          }
          else if (unitType == "pressure") {
            siQ = Quantity(100.0,*siU);
          }
          break;
        }
      case 'r' :
        {
          siQ = Quantity(1500.0,*siU);
          break;
        }
      case 's' :
        {
          if (unitType == "solarenergy") {
            siQ = Quantity(1000.0,*siU);
          }
          break;
        }
      case 't' :
        {
          if (unitType == "temperature") {
            siQ = Quantity(23.5,*siU);
          }
          break;
        }
      case 'v' :
        {
          if (unitType == "velocity") {
            siQ = Quantity(1.0,*siU);
          }
          if (unitType == "volumetricflowrate") {
            siQ = Quantity(1.0E-4,*siU);
          }
          break;
        }
      default :
        break;
      } // switch
      if (siQ) {
        result = siQ->value();
      }
    } // if siU
  }
  return result;
}
TEST_F(UnitsFixture, QuantityConverter_IPandSIUsingSystem)
{
    LOG(Debug, "QuantityConvert_ConvertUsingSystem");
    UnitSystem siSys(UnitSystem::SI);
    UnitSystem ipSys(UnitSystem::IP);

    IPUnit ipu1(openstudio::IPExpnt(0,1));
    Quantity ipq1(110.0, ipu1);
    OptionalQuantity siq1 = QuantityConverter::instance().convert(ipq1, siSys);
    EXPECT_TRUE(siq1);
    if (siq1) {
        SCOPED_TRACE("ipu1 to SI");
        testNumbersEqual(33.528,siq1->value());
        testStreamOutput("33.5 m", *siq1, 1);
    }

    IPUnit ftSquared(openstudio::IPExpnt(0,2));
    Quantity ipqFtSquared( 100.0, ftSquared );
    OptionalQuantity siqMSquared = QuantityConverter::instance().convert(ipqFtSquared, siSys);
    EXPECT_TRUE(siqMSquared);
    if (siqMSquared) {
        SCOPED_TRACE("ipqFtSquared to SI");
        testNumbersEqual(9.290304, siqMSquared->value());
        testStreamOutput("9.29 m^2", *siqMSquared, 2);
    }

    IPUnit ipu2(openstudio::IPExpnt(0,0,0,0,0,0,0,1));
    Quantity ipq2( 130.0, ipu2 );
    OptionalQuantity siq2 = QuantityConverter::instance().convert(ipq2, siSys);
    EXPECT_TRUE(siq2);
    if (siq2) {
        SCOPED_TRACE("ipu2 to SI");
        testNumbersEqual(578.268809984, siq2->value());
        testStreamOutput("578.3 N", *siq2, 1);
    }

    IPUnit ipu3(openstudio::IPExpnt(0,0,0,1));
    Quantity ipq3( 529.67, ipu3 );
    OptionalQuantity siq3 = QuantityConverter::instance().convert(ipq3, siSys);
    EXPECT_TRUE(siq3);
    if (siq3) {
        SCOPED_TRACE("ipu3 to SI");
        testNumbersEqual(294.261111111, siq3->value());
        testStreamOutput("294 K", *siq3, 0);
    }

    SIUnit siu4(openstudio::SIExpnt(1,2,-2));
    Quantity siq4( 1300.0, siu4 );
    OptionalQuantity ipq4 = QuantityConverter::instance().convert(siq4, ipSys);
    EXPECT_TRUE(ipq4);
    if (ipq4) {
        SCOPED_TRACE("siu4 to IP");
        testNumbersEqual(30849.4685255, ipq4->value());
        testStreamOutput("30849.47 lb_m*ft^2/s^2", *ipq4, 2);
    }

    SIUnit siu5(openstudio::SIExpnt(0,0,0,1));
    Quantity siq5( 294.0, siu5 );
    OptionalQuantity ipq5 = QuantityConverter::instance().convert(siq5, ipSys);
    EXPECT_TRUE(ipq5);
    if (ipq5) {
        SCOPED_TRACE("siu5 to IP");
        testNumbersEqual(529.2, ipq5->value());
        testStreamOutput("529.2 R", *ipq5, 1);
    }
}
TEST_F(UnitsFixture,QuantityConverter_BTUandIPUsingSystem)
{
    LOG(Debug, "QuantityConverter_BTUandIPUsingSystem");

    UnitSystem siSys(UnitSystem::SI);
    UnitSystem ipSys(UnitSystem::IP);
    UnitSystem btuSys(UnitSystem::BTU);

    // uses BTU to SI, SI to IP
    BTUUnit btuu1(openstudio::BTUExpnt(1,-2,0,0), 3);
    Quantity bQ( 67.5, btuu1 );
    testStreamOutput("67.5 kBtu/ft^2",bQ);
    OptionalQuantity ipQ = QuantityConverter::instance().convert( bQ, ipSys);
    EXPECT_TRUE(ipQ);
    if (ipQ) {
        EXPECT_EQ("lb_m/s^2",ipQ->standardUnitsString(false));
        EXPECT_EQ("klb_m/s^2",ipQ->standardUnitsString());
        SCOPED_TRACE("btu1 to IP");
        testNumbersEqual(1689985.20448, ipQ->value());
    }

    BTUUnit btuu2(openstudio::BTUExpnt(0,0,-1));
    bQ = Quantity(5000.0, btuu2);
    ipQ = QuantityConverter::instance().convert( bQ, ipSys);
    EXPECT_TRUE(ipQ);
    if (ipQ) {
        SCOPED_TRACE("bQ to IP, 1");
        testStreamOutput("1.3889 1/s",*ipQ,4);
    }

    bQ *= bQ; // 25E6/h^2
    ipQ = QuantityConverter::instance().convert( bQ, ipSys);
    EXPECT_TRUE(ipQ);
    if (ipQ) {
        SCOPED_TRACE("bQ to IP, 2");
        testStreamOutput("1.9290 1/s^2",*ipQ,4);
    }

    BTUUnit btuu3(openstudio::BTUExpnt(-1),-3);
    bQ = Quantity(1.0, btuu3);
    testStreamOutput("1 1/kBtu",bQ);
    OptionalQuantity siQ = QuantityConverter::instance().convert(bQ,siSys);
    EXPECT_TRUE(siQ);
    if (siQ) {
        EXPECT_EQ("1/J",siQ->prettyUnitsString(false));
        SCOPED_TRACE("btu3 to SI");
        testNumbersEqual(9.478171203133172e-4,siQ->value());
        siQ->setScale(0);
        SCOPED_TRACE("rescaled btu3 to SI");
        testNumbersEqual(9.478171203133172e-7,siQ->value());
    }

    // uses IP to SI, SI to BTU
    IPUnit ipu1(openstudio::IPExpnt(0,1,0,-1,0,0,0,1), -2);
    Quantity ipQ2( 2.0, ipu1);
    OptionalQuantity bQ2 = QuantityConverter::instance().convert( ipQ2, btuSys);
    EXPECT_TRUE(bQ2);
    if (bQ2) {
        EXPECT_EQ("Btu/R", bQ2->standardUnitsString(false));
        EXPECT_EQ("cBtu/R", bQ2->standardUnitsString());
        SCOPED_TRACE("ipu1 to BTU");
        testNumbersEqual(0.002570134927, bQ2->value(),1.0e-5);
        bQ2->setScale(0);
        EXPECT_EQ("Btu/R", bQ2->standardUnitsString());
        testNumbersEqual(2.570134927e-5, bQ2->value(),1.0e-5);
    }
}