TEST_F(ModelFixture, ElectricLoadCenterStorageConverter_Instantiate) {
bool result;
Model model;
ThermalZone thermalZone(model);
ElectricLoadCenterStorageConverter elcConv(model);
// Availability Schedule, defaults to model.alwaysOnDiscrete
EXPECT_TRUE(elcConv.isAvailabilityScheduleDefaulted());
EXPECT_EQ(elcConv.availabilitySchedule(), model.alwaysOnDiscreteSchedule());
ScheduleCompact scheduleCompact(model);
EXPECT_TRUE(elcConv.setAvailabilitySchedule(scheduleCompact));
EXPECT_EQ(elcConv.availabilitySchedule(), scheduleCompact);
elcConv.resetAvailabilitySchedule();
EXPECT_TRUE(elcConv.isAvailabilityScheduleDefaulted());
EXPECT_EQ(elcConv.availabilitySchedule(), model.alwaysOnDiscreteSchedule());
// SimpleFixedEfficiency
EXPECT_TRUE(elcConv.simpleFixedEfficiency());
EXPECT_EQ(elcConv.simpleFixedEfficiency().get(), 0.95);
EXPECT_EQ(elcConv.powerConversionEfficiencyMethod(), "SimpleFixed");
EXPECT_TRUE(elcConv.setSimpleFixedEfficiency(0.80));
EXPECT_EQ(elcConv.simpleFixedEfficiency().get(), 0.80);
// designMaximumContinuousInputPower
EXPECT_FALSE(elcConv.designMaximumContinuousInputPower());
EXPECT_TRUE(elcConv.setDesignMaximumContinuousInputPower(10000.0));
EXPECT_EQ(elcConv.powerConversionEfficiencyMethod(), "FunctionOfPower");
EXPECT_FALSE(elcConv.simpleFixedEfficiency());
EXPECT_EQ(elcConv.designMaximumContinuousInputPower().get(), 10000.0);
// Reset to SimpleFixed
EXPECT_TRUE(elcConv.setSimpleFixedEfficiency(0.80));
EXPECT_EQ(elcConv.powerConversionEfficiencyMethod(), "SimpleFixed");
EXPECT_FALSE(elcConv.designMaximumContinuousInputPower());
EXPECT_FALSE(elcConv.efficiencyFunctionofPowerCurve());
// efficiencyFunctionofPowerCurveName
CurveQuadratic effFPower = CurveQuadratic(model);
EXPECT_FALSE(elcConv.efficiencyFunctionofPowerCurve());
EXPECT_TRUE(elcConv.setEfficiencyFunctionofPowerCurve(effFPower));
EXPECT_EQ(elcConv.powerConversionEfficiencyMethod(), "FunctionOfPower");
EXPECT_FALSE(elcConv.simpleFixedEfficiency());
ASSERT_TRUE(elcConv.efficiencyFunctionofPowerCurve());
if (boost::optional<Curve> setCurve = elcConv.efficiencyFunctionofPowerCurve()) {
EXPECT_EQ(effFPower.handle(), setCurve->handle());
}
EXPECT_TRUE(elcConv.setDesignMaximumContinuousInputPower(10000.0));
// Reset to SimpleFixed
EXPECT_TRUE(elcConv.setSimpleFixedEfficiency(0.80));
EXPECT_EQ(elcConv.powerConversionEfficiencyMethod(), "SimpleFixed");
EXPECT_FALSE(elcConv.designMaximumContinuousInputPower());
EXPECT_FALSE(elcConv.efficiencyFunctionofPowerCurve());
// ancillaryPowerConsumedInStandby
EXPECT_TRUE(elcConv.isAncillaryPowerConsumedInStandbyDefaulted());
EXPECT_EQ(0.0, elcConv.ancillaryPowerConsumedInStandby());
elcConv.setAncillaryPowerConsumedInStandby(20);
EXPECT_EQ(20.0, elcConv.ancillaryPowerConsumedInStandby());
EXPECT_FALSE(elcConv.isAncillaryPowerConsumedInStandbyDefaulted());
elcConv.resetAncillaryPowerConsumedInStandby();
EXPECT_TRUE(elcConv.isAncillaryPowerConsumedInStandbyDefaulted());
// ZoneName
EXPECT_FALSE(elcConv.thermalZone());
EXPECT_TRUE(elcConv.setThermalZone(thermalZone));
ASSERT_TRUE(elcConv.thermalZone());
// radiativeFraction
EXPECT_TRUE(elcConv.isRadiativeFractionDefaulted());
result = elcConv.setRadiativeFraction(0.25);
EXPECT_TRUE(result);
EXPECT_FALSE(elcConv.isRadiativeFractionDefaulted());
EXPECT_EQ(elcConv.radiativeFraction(), 0.25);
elcConv.resetRadiativeFraction();
EXPECT_TRUE(elcConv.isRadiativeFractionDefaulted());
// Try to assign it to an ELCD
ElectricLoadCenterDistribution elcd(model);
EXPECT_TRUE(elcd.setStorageConverter(elcConv));
if (boost::optional<ElectricLoadCenterStorageConverter> setConv = elcd.storageConverter()) {
EXPECT_EQ(elcConv.handle(), setConv->handle());
}
elcd.resetStorageConverter();
EXPECT_TRUE(elcd.setStorageConverter(elcConv));
}
TEST_F(ModelFixture,ZoneHVACPackagedTerminalHeatPump_ZoneHVACPackagedTerminalHeatPump)
{
::testing::FLAGS_gtest_death_test_style = "threadsafe";
ASSERT_EXIT (
{
model::Model m;
model::ScheduleCompact availabilitySchedule(m);
model::FanConstantVolume fan(m,availabilitySchedule);
model::CoilHeatingElectric supplementalHeatingCoil(m,availabilitySchedule);
model::CurveBiquadratic coolingCurveFofTemp = CurveBiquadratic(m);
coolingCurveFofTemp.setCoefficient1Constant(0.42415);
coolingCurveFofTemp.setCoefficient2x(0.04426);
coolingCurveFofTemp.setCoefficient3xPOW2(-0.00042);
coolingCurveFofTemp.setCoefficient4y(0.00333);
coolingCurveFofTemp.setCoefficient5yPOW2(-0.00008);
coolingCurveFofTemp.setCoefficient6xTIMESY(-0.00021);
coolingCurveFofTemp.setMinimumValueofx(17.0);
coolingCurveFofTemp.setMaximumValueofx(22.0);
coolingCurveFofTemp.setMinimumValueofy(13.0);
coolingCurveFofTemp.setMaximumValueofy(46.0);
CurveQuadratic coolingCurveFofFlow = CurveQuadratic(m);
coolingCurveFofFlow.setCoefficient1Constant(0.77136);
coolingCurveFofFlow.setCoefficient2x(0.34053);
coolingCurveFofFlow.setCoefficient3xPOW2(-0.11088);
coolingCurveFofFlow.setMinimumValueofx(0.75918);
coolingCurveFofFlow.setMaximumValueofx(1.13877);
CurveBiquadratic energyInputRatioFofTemp = CurveBiquadratic(m);
energyInputRatioFofTemp.setCoefficient1Constant(1.23649);
energyInputRatioFofTemp.setCoefficient2x(-0.02431);
energyInputRatioFofTemp.setCoefficient3xPOW2(0.00057);
energyInputRatioFofTemp.setCoefficient4y(-0.01434);
energyInputRatioFofTemp.setCoefficient5yPOW2(0.00063);
energyInputRatioFofTemp.setCoefficient6xTIMESY(-0.00038);
energyInputRatioFofTemp.setMinimumValueofx(17.0);
energyInputRatioFofTemp.setMaximumValueofx(22.0);
energyInputRatioFofTemp.setMinimumValueofy(13.0);
energyInputRatioFofTemp.setMaximumValueofy(46.0);
CurveQuadratic energyInputRatioFofFlow = CurveQuadratic(m);
energyInputRatioFofFlow.setCoefficient1Constant(1.20550);
energyInputRatioFofFlow.setCoefficient2x(-0.32953);
energyInputRatioFofFlow.setCoefficient3xPOW2(0.12308);
energyInputRatioFofFlow.setMinimumValueofx(0.75918);
energyInputRatioFofFlow.setMaximumValueofx(1.13877);
CurveQuadratic partLoadFraction = CurveQuadratic(m);
partLoadFraction.setCoefficient1Constant(0.77100);
partLoadFraction.setCoefficient2x(0.22900);
partLoadFraction.setCoefficient3xPOW2(0.0);
partLoadFraction.setMinimumValueofx(0.0);
partLoadFraction.setMaximumValueofx(1.0);
CoilCoolingDXSingleSpeed coolingCoil = CoilCoolingDXSingleSpeed( m,
availabilitySchedule,
coolingCurveFofTemp,
coolingCurveFofFlow,
energyInputRatioFofTemp,
energyInputRatioFofFlow,
partLoadFraction );
CurveBiquadratic totalHeatingCapacityFunctionofTemperatureCurve(m);
totalHeatingCapacityFunctionofTemperatureCurve.setCoefficient1Constant(0.758746);
totalHeatingCapacityFunctionofTemperatureCurve.setCoefficient2x(0.0);
totalHeatingCapacityFunctionofTemperatureCurve.setCoefficient3xPOW2(0.0);
totalHeatingCapacityFunctionofTemperatureCurve.setCoefficient4y(0.027626);
totalHeatingCapacityFunctionofTemperatureCurve.setCoefficient5yPOW2(0.000148716);
totalHeatingCapacityFunctionofTemperatureCurve.setCoefficient6xTIMESY(0.0);
CurveQuadratic totalHeatingCapacityFunctionofFlowFractionCurve(m);
totalHeatingCapacityFunctionofFlowFractionCurve.setCoefficient1Constant(0.84);
totalHeatingCapacityFunctionofFlowFractionCurve.setCoefficient2x(0.16);
totalHeatingCapacityFunctionofFlowFractionCurve.setCoefficient3xPOW2(0.0);
totalHeatingCapacityFunctionofFlowFractionCurve.setMinimumValueofx(0.5);
totalHeatingCapacityFunctionofFlowFractionCurve.setMaximumValueofx(1.5);
CurveBiquadratic energyInputRatioFunctionofTemperatureCurve(m);
energyInputRatioFunctionofTemperatureCurve.setCoefficient1Constant(1.19248);
energyInputRatioFunctionofTemperatureCurve.setCoefficient2x(-0.0300438);
energyInputRatioFunctionofTemperatureCurve.setCoefficient3xPOW2(0.00103745);
energyInputRatioFunctionofTemperatureCurve.setCoefficient4y(0.0);
energyInputRatioFunctionofTemperatureCurve.setMinimumValueofx(-20.0);
energyInputRatioFunctionofTemperatureCurve.setMaximumValueofx(20.0);
CurveQuadratic energyInputRatioFunctionofFlowFractionCurve(m);
energyInputRatioFunctionofFlowFractionCurve.setCoefficient1Constant(1.3824);
energyInputRatioFunctionofFlowFractionCurve.setCoefficient2x(-0.4336);
energyInputRatioFunctionofFlowFractionCurve.setCoefficient3xPOW2(0.0512);
energyInputRatioFunctionofFlowFractionCurve.setMinimumValueofx(0.0);
energyInputRatioFunctionofFlowFractionCurve.setMaximumValueofx(1.0);
CurveQuadratic partLoadFractionCorrelationCurve(m);
partLoadFractionCorrelationCurve.setCoefficient1Constant(0.85);
partLoadFractionCorrelationCurve.setCoefficient2x(0.15);
partLoadFractionCorrelationCurve.setCoefficient3xPOW2(0.0);
partLoadFractionCorrelationCurve.setMinimumValueofx(0.0);
partLoadFractionCorrelationCurve.setMaximumValueofx(1.0);
CoilHeatingDXSingleSpeed heatingCoil( m,
availabilitySchedule,
totalHeatingCapacityFunctionofTemperatureCurve,
totalHeatingCapacityFunctionofFlowFractionCurve,
energyInputRatioFunctionofTemperatureCurve,
energyInputRatioFunctionofFlowFractionCurve,
partLoadFractionCorrelationCurve );
model::ZoneHVACPackagedTerminalHeatPump pthp( m,
availabilitySchedule,
fan,
heatingCoil,
coolingCoil,
supplementalHeatingCoil );
pthp.availabilitySchedule();
pthp.supplyAirFan();
pthp.heatingCoil();
pthp.coolingCoil();
pthp.supplementalHeatingCoil();
exit(0);
} ,
boost::optional<IdfObject> ForwardTranslator::translateCurveQuadratic(
CurveQuadratic& modelObject)
{
IdfObject idfObject(IddObjectType::Curve_Quadratic);
m_idfObjects.push_back(idfObject);
OptionalString s;
OptionalDouble d;
if ((s = modelObject.name())) {
idfObject.setName(*s);
}
idfObject.setDouble(Curve_QuadraticFields::Coefficient1Constant,modelObject.coefficient1Constant());
idfObject.setDouble(Curve_QuadraticFields::Coefficient2x,modelObject.coefficient2x());
idfObject.setDouble(Curve_QuadraticFields::Coefficient3x_POW_2,modelObject.coefficient3xPOW2());
idfObject.setDouble(Curve_QuadraticFields::MinimumValueofx,modelObject.minimumValueofx());
idfObject.setDouble(Curve_QuadraticFields::MaximumValueofx,modelObject.maximumValueofx());
if ((d = modelObject.minimumCurveOutput())) {
idfObject.setDouble(Curve_QuadraticFields::MinimumCurveOutput,*d);
}
if ((d = modelObject.maximumCurveOutput())) {
idfObject.setDouble(Curve_QuadraticFields::MaximumCurveOutput,*d);
}
if (!modelObject.isInputUnitTypeforXDefaulted()) {
idfObject.setString(Curve_QuadraticFields::InputUnitTypeforX,modelObject.inputUnitTypeforX());
}
if (!modelObject.isOutputUnitTypeDefaulted()) {
idfObject.setString(Curve_QuadraticFields::OutputUnitType,modelObject.outputUnitType());
}
return idfObject;
}
TEST(ZoneHVACPackagedTerminalAirConditioner,ZoneHVACPackagedTerminalAirConditioner_ZoneHVACPackagedTerminalAirConditioner)
{
::testing::FLAGS_gtest_death_test_style = "threadsafe";
ASSERT_EXIT (
{
model::Model m;
model::ScheduleCompact availabilitySchedule(m);
model::FanConstantVolume fan(m,availabilitySchedule);
model::CoilHeatingWater heatingCoil(m,availabilitySchedule);
model::CurveBiquadratic coolingCurveFofTemp = CurveBiquadratic(m);
coolingCurveFofTemp.setCoefficient1Constant(0.42415);
coolingCurveFofTemp.setCoefficient2x(0.04426);
coolingCurveFofTemp.setCoefficient3xPOW2(-0.00042);
coolingCurveFofTemp.setCoefficient4y(0.00333);
coolingCurveFofTemp.setCoefficient5yPOW2(-0.00008);
coolingCurveFofTemp.setCoefficient6xTIMESY(-0.00021);
coolingCurveFofTemp.setMinimumValueofx(17.0);
coolingCurveFofTemp.setMaximumValueofx(22.0);
coolingCurveFofTemp.setMinimumValueofy(13.0);
coolingCurveFofTemp.setMaximumValueofy(46.0);
CurveQuadratic coolingCurveFofFlow = CurveQuadratic(m);
coolingCurveFofFlow.setCoefficient1Constant(0.77136);
coolingCurveFofFlow.setCoefficient2x(0.34053);
coolingCurveFofFlow.setCoefficient3xPOW2(-0.11088);
coolingCurveFofFlow.setMinimumValueofx(0.75918);
coolingCurveFofFlow.setMaximumValueofx(1.13877);
CurveBiquadratic energyInputRatioFofTemp = CurveBiquadratic(m);
energyInputRatioFofTemp.setCoefficient1Constant(1.23649);
energyInputRatioFofTemp.setCoefficient2x(-0.02431);
energyInputRatioFofTemp.setCoefficient3xPOW2(0.00057);
energyInputRatioFofTemp.setCoefficient4y(-0.01434);
energyInputRatioFofTemp.setCoefficient5yPOW2(0.00063);
energyInputRatioFofTemp.setCoefficient6xTIMESY(-0.00038);
energyInputRatioFofTemp.setMinimumValueofx(17.0);
energyInputRatioFofTemp.setMaximumValueofx(22.0);
energyInputRatioFofTemp.setMinimumValueofy(13.0);
energyInputRatioFofTemp.setMaximumValueofy(46.0);
CurveQuadratic energyInputRatioFofFlow = CurveQuadratic(m);
energyInputRatioFofFlow.setCoefficient1Constant(1.20550);
energyInputRatioFofFlow.setCoefficient2x(-0.32953);
energyInputRatioFofFlow.setCoefficient3xPOW2(0.12308);
energyInputRatioFofFlow.setMinimumValueofx(0.75918);
energyInputRatioFofFlow.setMaximumValueofx(1.13877);
CurveQuadratic partLoadFraction = CurveQuadratic(m);
partLoadFraction.setCoefficient1Constant(0.77100);
partLoadFraction.setCoefficient2x(0.22900);
partLoadFraction.setCoefficient3xPOW2(0.0);
partLoadFraction.setMinimumValueofx(0.0);
partLoadFraction.setMaximumValueofx(1.0);
CoilCoolingDXSingleSpeed coolingCoil = CoilCoolingDXSingleSpeed( m,
availabilitySchedule,
coolingCurveFofTemp,
coolingCurveFofFlow,
energyInputRatioFofTemp,
energyInputRatioFofFlow,
partLoadFraction );
model::ZoneHVACPackagedTerminalAirConditioner ptac( m,
availabilitySchedule,
fan,
heatingCoil,
coolingCoil );
ptac.availabilitySchedule();
ptac.supplyAirFan();
ptac.heatingCoil();
ptac.coolingCoil();
exit(0);
} ,
TEST_F(EnergyPlusFixture,ForwardTranslatorFuelCell) {
Model model;
Building building = model.getUniqueModelObject<Building>();
//ThermalZone zone1(model);
//ThermalZone zone2(model);
// create default fuelcell
GeneratorFuelCell fuelcell(model);
// get default power module
GeneratorFuelCellPowerModule fCPM = fuelcell.powerModule();
// check default power module curve values
Curve curve = fCPM.efficiencyCurve();
CurveQuadratic curveQ = curve.cast<CurveQuadratic>();
EXPECT_EQ(0.642388, curveQ.coefficient1Constant());
EXPECT_EQ(-0.0001619, curveQ.coefficient2x());
EXPECT_EQ(2.26e-008, curveQ.coefficient3xPOW2());
EXPECT_EQ("Annex42", fCPM.efficiencyCurveMode());
// check default Airsupply
GeneratorFuelCellAirSupply fAS = fuelcell.airSupply();
EXPECT_EQ("AirRatiobyStoics", fAS.airSupplyRateCalculationMode());
EXPECT_EQ(1.0, fAS.stoichiometricRatio());
EXPECT_EQ("NoRecovery", fAS.airIntakeHeatRecoveryMode());
EXPECT_EQ("AmbientAir", fAS.airSupplyConstituentMode());
// check default fuel supply
GeneratorFuelSupply fS = fuelcell.fuelSupply();
// check default water supply
GeneratorFuelCellWaterSupply fWS = fuelcell.waterSupply();
fWS.setWaterTemperatureModelingMode("MainsWaterTemperature");
// check default aux heater
GeneratorFuelCellAuxiliaryHeater fAX = fuelcell.auxiliaryHeater();
// check default heat exchanger
GeneratorFuelCellExhaustGasToWaterHeatExchanger fHX = fuelcell.heatExchanger();
// check default electric storage
GeneratorFuelCellElectricalStorage fES = fuelcell.electricalStorage();
// check default inverter
GeneratorFuelCellInverter fI = fuelcell.inverter();
// check default optional stackcooler
boost::optional<GeneratorFuelCellStackCooler> fSC = fuelcell.stackCooler();
EXPECT_FALSE(fSC);
ForwardTranslator forwardTranslator;
Workspace workspace = forwardTranslator.translateModel(model);
EXPECT_EQ(0u, forwardTranslator.errors().size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_AirSupply).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_AuxiliaryHeater).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_ElectricalStorage).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_ExhaustGasToWaterHeatExchanger).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_Inverter).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_PowerModule).size());
// no stack cooler by default
EXPECT_EQ(0u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_StackCooler).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelCell_WaterSupply).size());
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Generator_FuelSupply).size());
//expect site water mains
EXPECT_EQ(1u, workspace.getObjectsByType(IddObjectType::Site_WaterMainsTemperature).size());
model.save(toPath("./fuelcell.osm"), true);
workspace.save(toPath("./fuelcell.idf"), true);
}
