Esempio n. 1
0
boost::optional<Quantity> QuantityConverterSingleton::convert(const Quantity &original,
                                                              const Unit& targetUnits) const
{
  Quantity working(original);
  OptionalQuantity candidate;

  // See if nothing to be done. (Check for equality of system and base units + exponents.)
  if ((working.system() == targetUnits.system()) && (working.units() == targetUnits))
  {
    // Assume targetUnits has desired scale.
    working.setScale(targetUnits.scale().exponent);
    return working;
  }

  // All conversions go through SI
  if (working.system() != UnitSystem::SI) {
    candidate = m_convertToSI(working);
    if (!candidate) {
      return boost::none;
    }
    working = *candidate;
  }

  // Retain pretty string
  OptionalQuantity result = m_convertToTargetFromSI(working,targetUnits);
  if (result && 
      result->prettyUnitsString(false).empty() && 
      !targetUnits.prettyString(false).empty()) 
  {
    result->setPrettyUnitsString(targetUnits.prettyString(false));
  }

  return result;
}
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());
}
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);
    }
}