TEST_F(ModelFixture,ZoneHVACFourPipeFanCoil_MaximumSupplyAirFlowRate_Quantity) {
Model model;
EXPECT_EQ(0u,model.objects().size());
EXPECT_TRUE(model.versionObject());
// need schedule
ScheduleConstant sched(model);
EXPECT_EQ(1u,model.objects().size());
sched.setValue(1.0); // Always on
// need fan
FanConstantVolume fan(model,sched);
// need cooling and heating coils
CoilCoolingWater coolingCoil(model,sched);
CoilHeatingWater heatingCoil(model,sched);
// construct object
ZoneHVACFourPipeFanCoil zoneHVACFourPipeFanCoil(model,sched,fan,coolingCoil,heatingCoil);
EXPECT_EQ(6u,model.objects().size());
Unit units = zoneHVACFourPipeFanCoil.getMaximumSupplyAirFlowRate(true).units(); // Get IP units.
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(zoneHVACFourPipeFanCoil.setMaximumSupplyAirFlowRate(testQ));
OSOptionalQuantity q = zoneHVACFourPipeFanCoil.getMaximumSupplyAirFlowRate(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
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(ModelFixture,ThermalZone_Volume_Quantity) {
Model model;
ThermalZone thermalZone(model);
Unit units = thermalZone.getVolume(true).units(); // Get IP units.
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(thermalZone.setVolume(testQ));
OSOptionalQuantity q = thermalZone.getVolume(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.get().units().standardString());
}
TEST_F(ModelFixture,HeatExchangerAirToAirSensibleAndLatent_RateofDefrostTimeFractionIncrease_Quantity) {
Model model;
HeatExchangerAirToAirSensibleAndLatent heatExchangerAirToAirSensibleAndLatent(model);
Unit units = heatExchangerAirToAirSensibleAndLatent.getRateofDefrostTimeFractionIncrease(true).units(); // Get IP units.
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(heatExchangerAirToAirSensibleAndLatent.setRateofDefrostTimeFractionIncrease(testQ));
OSOptionalQuantity q = heatExchangerAirToAirSensibleAndLatent.getRateofDefrostTimeFractionIncrease(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,PeopleDefinition_SensibleHeatFraction_Quantity) {
Model model;
PeopleDefinition peopleDefinition(model);
Unit units = peopleDefinition.getSensibleHeatFraction(true).units(); // Get IP units.
double value(0.5);
Quantity testQ(value,units);
EXPECT_TRUE(peopleDefinition.setSensibleHeatFraction(testQ));
OSOptionalQuantity q = peopleDefinition.getSensibleHeatFraction(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
bool AirGap_Impl::setThermalResistance(const OSOptionalQuantity& thermalResistance) {
bool result(false);
OptionalDouble value;
if (thermalResistance.isSet()) {
value = getDoubleFromQuantity(OS_Material_AirGapFields::ThermalResistance,thermalResistance.get());
if (value) {
result = setThermalResistance(value);
}
}
else {
result = setThermalResistance(value);
}
return result;
}
bool GasMixture_Impl::setGas4Fraction(const OSOptionalQuantity& gas4Fraction) {
bool result(false);
OptionalDouble value;
if (gas4Fraction.isSet()) {
value = getDoubleFromQuantity(OS_WindowMaterial_GasMixtureFields::Gas4Fraction,gas4Fraction.get());
if (value) {
result = setGas4Fraction(value);
}
}
else {
result = setGas4Fraction(value);
}
return result;
}
bool Gas_Impl::setSpecificHeatRatio(const OSOptionalQuantity& specificHeatRatio) {
bool result(false);
OptionalDouble value;
if (specificHeatRatio.isSet()) {
value = getDoubleFromQuantity(OS_WindowMaterial_GasFields::SpecificHeatRatio,specificHeatRatio.get());
if (value) {
result = setSpecificHeatRatio(value);
}
}
else {
result = setSpecificHeatRatio(value);
}
return result;
}
bool Gas_Impl::setMolecularWeight(const OSOptionalQuantity& molecularWeight) {
bool result(false);
OptionalDouble value;
if (molecularWeight.isSet()) {
value = getDoubleFromQuantity(OS_WindowMaterial_GasFields::MolecularWeight,molecularWeight.get());
if (value) {
result = setMolecularWeight(value);
}
}
else {
result = setMolecularWeight(value);
}
return result;
}
bool FanConstantVolume_Impl::setMaximumFlowRate(const OSOptionalQuantity& maximumFlowRate) {
bool result(false);
OptionalDouble value;
if (maximumFlowRate.isSet()) {
value = getDoubleFromQuantity(OS_Fan_ConstantVolumeFields::MaximumFlowRate,maximumFlowRate.get());
if (value) {
result = setMaximumFlowRate(value);
}
}
else {
result = setMaximumFlowRate(value);
}
return result;
}
bool BoilerSteam_Impl::setOptimumPartLoadRatio(const OSOptionalQuantity& optimumPartLoadRatio) {
bool result(false);
OptionalDouble value;
if (optimumPartLoadRatio.isSet()) {
value = getDoubleFromQuantity(OS_Boiler_SteamFields::OptimumPartLoadRatio,optimumPartLoadRatio.get());
if (value) {
result = setOptimumPartLoadRatio(value);
}
}
else {
result = setOptimumPartLoadRatio(value);
}
return result;
}
bool BoilerSteam_Impl::setTheoreticalEfficiency(const OSOptionalQuantity& theoreticalEfficiency) {
bool result(false);
OptionalDouble value;
if (theoreticalEfficiency.isSet()) {
value = getDoubleFromQuantity(OS_Boiler_SteamFields::TheoreticalEfficiency,theoreticalEfficiency.get());
if (value) {
result = setTheoreticalEfficiency(value);
}
}
else {
result = setTheoreticalEfficiency(value);
}
return result;
}
TEST_F(ModelFixture,ZoneHVACIdealLoadsAirSystem_MaximumHeatingAirFlowRate_Quantity) {
Model model;
// TODO: Check constructor.
ZoneHVACIdealLoadsAirSystem zoneHVACIdealLoadsAirSystem(model);
Unit units = zoneHVACIdealLoadsAirSystem.getMaximumHeatingAirFlowRate(true).units(); // Get IP units.
// TODO: Check that value is appropriate (within bounds)
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(zoneHVACIdealLoadsAirSystem.setMaximumHeatingAirFlowRate(testQ));
OSOptionalQuantity q = zoneHVACIdealLoadsAirSystem.getMaximumHeatingAirFlowRate(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,AirGap_ThermalResistance_Quantity) {
Model model;
// TODO: Check constructor.
AirGap airGap(model);
Unit units = airGap.getThermalResistance(true).units(); // Get IP units.
// TODO: Check that value is appropriate (within bounds)
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(airGap.setThermalResistance(testQ));
OSOptionalQuantity q = airGap.getThermalResistance(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,StandardGlazing_VisibleTransmittanceatNormalIncidence_Quantity) {
Model model;
// TODO: Check constructor.
StandardGlazing standardGlazing(model);
Unit units = standardGlazing.getVisibleTransmittanceatNormalIncidence(true).units(); // Get IP units.
// TODO: Check that value is appropriate (within bounds)
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(standardGlazing.setVisibleTransmittanceatNormalIncidence(testQ));
OSOptionalQuantity q = standardGlazing.getVisibleTransmittanceatNormalIncidence(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,ScheduleTypeLimits_UpperLimitValue_Quantity) {
Model model;
// TODO: Check constructor.
ScheduleTypeLimits scheduleTypeLimits(model);
Unit units = scheduleTypeLimits.getUpperLimitValue(true).units(); // Get IP units.
// TODO: Check that value is appropriate (within bounds)
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(scheduleTypeLimits.setUpperLimitValue(testQ));
OSOptionalQuantity q = scheduleTypeLimits.getUpperLimitValue(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,BoilerSteam_MinimumPartLoadRatio_Quantity) {
Model model;
// TODO: Check constructor.
BoilerSteam boilerSteam(model);
Unit units = boilerSteam.getMinimumPartLoadRatio(true).units(); // Get IP units.
// TODO: Check that value is appropriate (within bounds)
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(boilerSteam.setMinimumPartLoadRatio(testQ));
OSOptionalQuantity q = boilerSteam.getMinimumPartLoadRatio(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,SizingZone_ZoneHeatingSizingFactor_Quantity) {
Model model;
ThermalZone zone(model);
SizingZone sizingZone(model,zone);
Unit units = sizingZone.getZoneHeatingSizingFactor(true).units(); // Get IP units.
// TODO: Check that value is appropriate (within bounds)
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(sizingZone.setZoneHeatingSizingFactor(testQ));
OSOptionalQuantity q = sizingZone.getZoneHeatingSizingFactor(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,GasMixture_Gas4Fraction_Quantity) {
Model model;
// TODO: Check constructor.
GasMixture gasMixture(model);
Unit units = gasMixture.getGas4Fraction(true).units(); // Get IP units.
// TODO: Check that value is appropriate (within bounds)
double value(1.0);
Quantity testQ(value,units);
EXPECT_TRUE(gasMixture.setGas4Fraction(testQ));
OSOptionalQuantity q = gasMixture.getGas4Fraction(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
bool ScheduleTypeLimits_Impl::setUpperLimitValue(const OSOptionalQuantity& upperLimitValue) {
bool result(false);
OptionalDouble value;
if (upperLimitValue.isSet()) {
value = getDoubleFromQuantity(OS_ScheduleTypeLimitsFields::UpperLimitValue,upperLimitValue.get());
if (value) {
setUpperLimitValue(value);
result = true;
}
}
else {
setUpperLimitValue(value);
result = true;
}
return result;
}
bool BoilerSteam_Impl::setNominalCapacity(const OSOptionalQuantity& nominalCapacity) {
bool result(false);
OptionalDouble value;
if (nominalCapacity.isSet()) {
value = getDoubleFromQuantity(OS_Boiler_SteamFields::NominalCapacity,nominalCapacity.get());
if (value) {
setNominalCapacity(value);
result = true;
}
}
else {
setNominalCapacity(value);
result = true;
}
return result;
}
bool BoilerSteam_Impl::setMaximumOperatingPressure(const OSOptionalQuantity& maximumOperatingPressure) {
bool result(false);
OptionalDouble value;
if (maximumOperatingPressure.isSet()) {
value = getDoubleFromQuantity(OS_Boiler_SteamFields::MaximumOperatingPressure,maximumOperatingPressure.get());
if (value) {
setMaximumOperatingPressure(value);
result = true;
}
}
else {
setMaximumOperatingPressure(value);
result = true;
}
return result;
}
TEST_F(ModelFixture,Gas_MolecularWeight_Quantity) {
Model model;
// TODO: Check constructor.
Gas gas(model);
Unit units = gas.getMolecularWeight(true).units(); // Get IP units.
// Bounds: 20 <= value <= 200)
double value(1.0);
Quantity testQ(value,units);
EXPECT_FALSE(gas.setMolecularWeight(testQ));
double value2(20.0);
Quantity testQ2(value2,units);
EXPECT_TRUE(gas.setMolecularWeight(testQ2));
OSOptionalQuantity q = gas.getMolecularWeight(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value2,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,Blind_BackSideSlatDiffuseVisibleReflectance_Quantity) {
Model model;
// TODO: Check constructor.
Blind blind(model);
Unit units = blind.getBackSideSlatDiffuseVisibleReflectance(true).units(); // Get IP units.
// Bounds: 0.0 <= value < 1.0
double value(1.0);
Quantity testQ(value,units);
EXPECT_FALSE(blind.setBackSideSlatDiffuseVisibleReflectance(testQ));
double value2(0.1);
Quantity testQ2(value2,units);
EXPECT_TRUE(blind.setBackSideSlatDiffuseVisibleReflectance(testQ2));
OSOptionalQuantity q = blind.getBackSideSlatDiffuseVisibleReflectance(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value2,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
TEST_F(ModelFixture,SimpleGlazing_VisibleTransmittance_Quantity) {
Model model;
// TODO: Check constructor.
SimpleGlazing simpleGlazing(model);
Unit units = simpleGlazing.getVisibleTransmittance(true).units(); // Get IP units.
// Bounds: 0.0 < value < 1.0
double value(1.0);
Quantity testQ(value,units);
EXPECT_FALSE(simpleGlazing.setVisibleTransmittance(testQ));
double value2(0.1);
Quantity testQ2(value2,units);
EXPECT_TRUE(simpleGlazing.setVisibleTransmittance(testQ2));
OSOptionalQuantity q = simpleGlazing.getVisibleTransmittance(true);
ASSERT_TRUE(q.isSet());
EXPECT_NEAR(value2,q.get().value(),1.0E-8);
EXPECT_EQ(units.standardString(),q.units().standardString());
}
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");
}
bool Gas_Impl::setViscosityCoefficientA(const OSOptionalQuantity& viscosityCoefficientA) {
bool result(false);
OptionalDouble value;
if (viscosityCoefficientA.isSet()) {
value = getDoubleFromQuantity(OS_WindowMaterial_GasFields::ViscosityCoefficientA,viscosityCoefficientA.get());
if (value) {
result = setViscosityCoefficientA(value);
}
}
else {
result = setViscosityCoefficientA(value);
}
return result;
}
bool SiteWaterMainsTemperature_Impl::setMaximumDifferenceInMonthlyAverageOutdoorAirTemperatures(const OSOptionalQuantity& maximumDifferenceInMonthlyAverageOutdoorAirTemperatures) {
bool result(false);
OptionalDouble value;
if (maximumDifferenceInMonthlyAverageOutdoorAirTemperatures.isSet()) {
value = getDoubleFromQuantity(OS_Site_WaterMainsTemperatureFields::MaximumDifferenceInMonthlyAverageOutdoorAirTemperatures,maximumDifferenceInMonthlyAverageOutdoorAirTemperatures.get());
if (value) {
result = setMaximumDifferenceInMonthlyAverageOutdoorAirTemperatures(value);
}
}
else {
result = setMaximumDifferenceInMonthlyAverageOutdoorAirTemperatures(value);
}
return result;
}
bool AirTerminalSingleDuctUncontrolled_Impl::setMaximumAirFlowRate(const OSOptionalQuantity& maximumAirFlowRate) {
bool result(false);
OptionalDouble value;
if (maximumAirFlowRate.isSet()) {
value = getDoubleFromQuantity(OS_AirTerminal_SingleDuct_UncontrolledFields::MaximumAirFlowRate,maximumAirFlowRate.get());
if (value) {
result = setMaximumAirFlowRate(value);
}
}
else {
result = setMaximumAirFlowRate(value);
}
return result;
}
bool SimpleGlazing_Impl::setVisibleTransmittance(const OSOptionalQuantity& visibleTransmittance) {
bool result(false);
OptionalDouble value;
if (visibleTransmittance.isSet()) {
value = getDoubleFromQuantity(OS_WindowMaterial_SimpleGlazingSystemFields::VisibleTransmittance,visibleTransmittance.get());
if (value) {
result = setVisibleTransmittance(value);
}
}
else {
result = setVisibleTransmittance(value);
}
return result;
}
