src/model/GeneratorMicroTurbineHeatRecovery.cpp
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /*********************************************************************************************************************** | ||
| 2 | * OpenStudio(R), Copyright (c) Alliance for Energy Innovation, LLC. | ||
| 3 | * See also https://openstudio.net/license | ||
| 4 | ***********************************************************************************************************************/ | ||
| 5 | |||
| 6 | #include "Model.hpp" | ||
| 7 | #include "Model_Impl.hpp" | ||
| 8 | |||
| 9 | #include "GeneratorMicroTurbine.hpp" | ||
| 10 | #include "GeneratorMicroTurbine_Impl.hpp" | ||
| 11 | #include "GeneratorMicroTurbineHeatRecovery.hpp" | ||
| 12 | #include "GeneratorMicroTurbineHeatRecovery_Impl.hpp" | ||
| 13 | |||
| 14 | #include "Node.hpp" | ||
| 15 | #include "Node_Impl.hpp" | ||
| 16 | #include "PlantLoop.hpp" | ||
| 17 | #include "PlantLoop_Impl.hpp" | ||
| 18 | |||
| 19 | #include "Curve.hpp" | ||
| 20 | #include "Curve_Impl.hpp" | ||
| 21 | // TODO: add the tables class if they get added to OS later? | ||
| 22 | //#include "DataTables.hpp" | ||
| 23 | |||
| 24 | #include "../utilities/core/Assert.hpp" | ||
| 25 | #include "../utilities/data/DataEnums.hpp" | ||
| 26 | |||
| 27 | #include <utilities/idd/IddFactory.hxx> | ||
| 28 | #include <utilities/idd/IddEnums.hxx> | ||
| 29 | #include <utilities/idd/OS_Generator_MicroTurbine_HeatRecovery_FieldEnums.hxx> | ||
| 30 | |||
| 31 | namespace openstudio { | ||
| 32 | namespace model { | ||
| 33 | |||
| 34 | namespace detail { | ||
| 35 | |||
| 36 | 7 | GeneratorMicroTurbineHeatRecovery_Impl::GeneratorMicroTurbineHeatRecovery_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle) | |
| 37 | 7 | : StraightComponent_Impl(idfObject, model, keepHandle) { | |
| 38 |
4/6✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
✓ Branch 7 taken 7 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 7 times.
✗ Branch 13 not taken.
|
7 | OS_ASSERT(idfObject.iddObject().type() == GeneratorMicroTurbineHeatRecovery::iddObjectType()); |
| 39 | 7 | } | |
| 40 | |||
| 41 | ✗ | GeneratorMicroTurbineHeatRecovery_Impl::GeneratorMicroTurbineHeatRecovery_Impl(const openstudio::detail::WorkspaceObject_Impl& other, | |
| 42 | ✗ | Model_Impl* model, bool keepHandle) | |
| 43 | ✗ | : StraightComponent_Impl(other, model, keepHandle) { | |
| 44 | ✗ | OS_ASSERT(other.iddObject().type() == GeneratorMicroTurbineHeatRecovery::iddObjectType()); | |
| 45 | ✗ | } | |
| 46 | |||
| 47 | 8 | GeneratorMicroTurbineHeatRecovery_Impl::GeneratorMicroTurbineHeatRecovery_Impl(const GeneratorMicroTurbineHeatRecovery_Impl& other, | |
| 48 | 8 | Model_Impl* model, bool keepHandle) | |
| 49 | 8 | : StraightComponent_Impl(other, model, keepHandle) {} | |
| 50 | |||
| 51 | // Lists the output variables that are specific to the heat recovery portion of a Generator:MicroTurbine | ||
| 52 | ✗ | const std::vector<std::string>& GeneratorMicroTurbineHeatRecovery_Impl::outputVariableNames() const { | |
| 53 | static const std::vector<std::string> result{ | ||
| 54 | "Generator Produced Thermal Rate", "Generator Produced Thermal Energy", "Generator Thermal Efficiency LHV Basis", | ||
| 55 | ✗ | "Generator Heat Recovery Inlet Temperature", "Generator Heat Recovery Outlet Temperature", "Generator Heat Recovery Water Mass Flow Rate"}; | |
| 56 | ✗ | return result; | |
| 57 | ✗ | } | |
| 58 | |||
| 59 | ✗ | IddObjectType GeneratorMicroTurbineHeatRecovery_Impl::iddObjectType() const { | |
| 60 | ✗ | return GeneratorMicroTurbineHeatRecovery::iddObjectType(); | |
| 61 | } | ||
| 62 | |||
| 63 | // This will clone both the GeneratorMicroTurbineHeatRecovery and its linked GeneratorMicroTurbineHeatRecovery | ||
| 64 | // and will return a reference to the GeneratorMicroTurbineHeatRecovery | ||
| 65 | 1 | ModelObject GeneratorMicroTurbineHeatRecovery_Impl::clone(Model model) const { | |
| 66 | |||
| 67 | // We call the parent generator's Clone method which will clone both the mchp and mchpHR | ||
| 68 |
1/1✓ Branch 1 taken 1 time.
|
1 | GeneratorMicroTurbine mchp = generatorMicroTurbine(); |
| 69 |
3/3✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
|
1 | auto mchpClone = mchp.clone(model).cast<GeneratorMicroTurbine>(); |
| 70 | |||
| 71 | // We get the clone of the parent generator's MTHR so we can return that | ||
| 72 |
3/3✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
|
1 | GeneratorMicroTurbineHeatRecovery mchpHRClone = mchpClone.generatorMicroTurbineHeatRecovery().get(); |
| 73 | |||
| 74 | 2 | return std::move(mchpHRClone); | |
| 75 | 1 | } | |
| 76 | |||
| 77 | ✗ | std::vector<IddObjectType> GeneratorMicroTurbineHeatRecovery_Impl::allowableChildTypes() const { | |
| 78 | return { | ||
| 79 | IddObjectType::OS_Curve_Bicubic, | ||
| 80 | IddObjectType::OS_Curve_Biquadratic, | ||
| 81 | IddObjectType::OS_Curve_Cubic, | ||
| 82 | IddObjectType::OS_Curve_Quadratic, | ||
| 83 | ✗ | }; | |
| 84 | } | ||
| 85 | |||
| 86 | // Returns the children objects (max of 4 curves) | ||
| 87 | 3 | std::vector<ModelObject> GeneratorMicroTurbineHeatRecovery_Impl::children() const { | |
| 88 | 3 | std::vector<ModelObject> result; | |
| 89 | 3 | boost::optional<Curve> oCurve; | |
| 90 | |||
| 91 | // Curves should be included | ||
| 92 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 2 times.
|
6 | if ((oCurve = thermalEfficiencyFunctionofTemperatureandElevationCurve())) { |
| 93 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | result.push_back(oCurve.get()); |
| 94 | } | ||
| 95 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 2 times.
|
6 | if ((oCurve = heatRecoveryRateFunctionofPartLoadRatioCurve())) { |
| 96 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | result.push_back(oCurve.get()); |
| 97 | } | ||
| 98 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 2 times.
|
6 | if ((oCurve = heatRecoveryRateFunctionofInletWaterTemperatureCurve())) { |
| 99 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | result.push_back(oCurve.get()); |
| 100 | } | ||
| 101 | |||
| 102 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 2 times.
|
6 | if ((oCurve = heatRecoveryRateFunctionofWaterFlowRateCurve())) { |
| 103 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | result.push_back(oCurve.get()); |
| 104 | } | ||
| 105 | |||
| 106 | 6 | return result; | |
| 107 | 3 | } | |
| 108 | |||
| 109 | 11 | unsigned GeneratorMicroTurbineHeatRecovery_Impl::inletPort() const { | |
| 110 | 11 | return OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterInletNodeName; | |
| 111 | } | ||
| 112 | |||
| 113 | 38 | unsigned GeneratorMicroTurbineHeatRecovery_Impl::outletPort() const { | |
| 114 | 38 | return OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterOutletNodeName; | |
| 115 | } | ||
| 116 | |||
| 117 | // Add to plantLoop Node: accepts to be placed on both the supply and the demand | ||
| 118 | // You should make sure that this is compatible with your Generator Operation Scheme | ||
| 119 | // For example, if FollowThermal, it must be placed on the supply side of the plant loop | ||
| 120 | 7 | bool GeneratorMicroTurbineHeatRecovery_Impl::addToNode(Node& node) { | |
| 121 | // This can be placed on the supply or the demand side | ||
| 122 |
3/3✓ Branch 1 taken 7 times.
✓ Branch 3 taken 5 times.
✓ Branch 4 taken 2 times.
|
14 | if (boost::optional<PlantLoop> plant = node.plantLoop()) { |
| 123 |
1/1✓ Branch 1 taken 5 times.
|
5 | return StraightComponent_Impl::addToNode(node); |
| 124 | 7 | } | |
| 125 | |||
| 126 | 2 | return false; | |
| 127 | } | ||
| 128 | |||
| 129 | //boost::optional<Connection> GeneratorMicroTurbineHeatRecovery_Impl::heatRecoveryWaterInletNode() const { | ||
| 130 | // return getObject<ModelObject>().getModelObjectTarget<Connection>(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterInletNodeName); | ||
| 131 | //} | ||
| 132 | |||
| 133 | //boost::optional<Connection> GeneratorMicroTurbineHeatRecovery_Impl::heatRecoveryWaterOutletNode() const { | ||
| 134 | // return getObject<ModelObject>().getModelObjectTarget<Connection>(OS_Generator_MicroTurbineHeatRecoveryFields::HeatRecoveryWaterOutletNodeName); | ||
| 135 | //} | ||
| 136 | |||
| 137 | 5 | double GeneratorMicroTurbineHeatRecovery_Impl::referenceThermalEfficiencyUsingLowerHeatValue() const { | |
| 138 |
1/1✓ Branch 1 taken 5 times.
|
5 | boost::optional<double> value = getDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceThermalEfficiencyUsingLowerHeatValue, true); |
| 139 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 4 not taken.
|
5 | OS_ASSERT(value); |
| 140 |
1/1✓ Branch 1 taken 5 times.
|
10 | return value.get(); |
| 141 | } | ||
| 142 | |||
| 143 | 3 | bool GeneratorMicroTurbineHeatRecovery_Impl::isReferenceThermalEfficiencyUsingLowerHeatValueDefaulted() const { | |
| 144 | 3 | return isEmpty(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceThermalEfficiencyUsingLowerHeatValue); | |
| 145 | } | ||
| 146 | |||
| 147 | 4 | double GeneratorMicroTurbineHeatRecovery_Impl::referenceInletWaterTemperature() const { | |
| 148 |
1/1✓ Branch 1 taken 4 times.
|
4 | boost::optional<double> value = getDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceInletWaterTemperature, true); |
| 149 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
|
4 | OS_ASSERT(value); |
| 150 |
1/1✓ Branch 1 taken 4 times.
|
8 | return value.get(); |
| 151 | } | ||
| 152 | |||
| 153 | 4 | std::string GeneratorMicroTurbineHeatRecovery_Impl::heatRecoveryWaterFlowOperatingMode() const { | |
| 154 |
1/1✓ Branch 1 taken 4 times.
|
4 | boost::optional<std::string> value = getString(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowOperatingMode, true); |
| 155 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
|
4 | OS_ASSERT(value); |
| 156 |
2/2✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
|
8 | return value.get(); |
| 157 | 4 | } | |
| 158 | |||
| 159 | 3 | bool GeneratorMicroTurbineHeatRecovery_Impl::isHeatRecoveryWaterFlowOperatingModeDefaulted() const { | |
| 160 | 3 | return isEmpty(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowOperatingMode); | |
| 161 | } | ||
| 162 | |||
| 163 | 4 | double GeneratorMicroTurbineHeatRecovery_Impl::referenceHeatRecoveryWaterFlowRate() const { | |
| 164 |
1/1✓ Branch 1 taken 4 times.
|
4 | boost::optional<double> value = getDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceHeatRecoveryWaterFlowRate, true); |
| 165 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
|
4 | OS_ASSERT(value); |
| 166 |
1/1✓ Branch 1 taken 4 times.
|
8 | return value.get(); |
| 167 | } | ||
| 168 | |||
| 169 | 5 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery_Impl::heatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve() const { | |
| 170 |
1/1✓ Branch 1 taken 5 times.
|
10 | return getObject<ModelObject>().getModelObjectTarget<Curve>( |
| 171 |
1/1✓ Branch 1 taken 5 times.
|
10 | OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurveName); |
| 172 | } | ||
| 173 | |||
| 174 | 8 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery_Impl::thermalEfficiencyFunctionofTemperatureandElevationCurve() const { | |
| 175 |
1/1✓ Branch 1 taken 8 times.
|
16 | return getObject<ModelObject>().getModelObjectTarget<Curve>( |
| 176 |
1/1✓ Branch 1 taken 8 times.
|
16 | OS_Generator_MicroTurbine_HeatRecoveryFields::ThermalEfficiencyFunctionofTemperatureandElevationCurveName); |
| 177 | } | ||
| 178 | |||
| 179 | 8 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery_Impl::heatRecoveryRateFunctionofPartLoadRatioCurve() const { | |
| 180 |
1/1✓ Branch 1 taken 8 times.
|
16 | return getObject<ModelObject>().getModelObjectTarget<Curve>( |
| 181 |
1/1✓ Branch 1 taken 8 times.
|
16 | OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofPartLoadRatioCurveName); |
| 182 | } | ||
| 183 | |||
| 184 | 8 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery_Impl::heatRecoveryRateFunctionofInletWaterTemperatureCurve() const { | |
| 185 |
1/1✓ Branch 1 taken 8 times.
|
16 | return getObject<ModelObject>().getModelObjectTarget<Curve>( |
| 186 |
1/1✓ Branch 1 taken 8 times.
|
16 | OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofInletWaterTemperatureCurveName); |
| 187 | } | ||
| 188 | |||
| 189 | 8 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery_Impl::heatRecoveryRateFunctionofWaterFlowRateCurve() const { | |
| 190 |
1/1✓ Branch 1 taken 8 times.
|
16 | return getObject<ModelObject>().getModelObjectTarget<Curve>( |
| 191 |
1/1✓ Branch 1 taken 8 times.
|
16 | OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofWaterFlowRateCurveName); |
| 192 | } | ||
| 193 | |||
| 194 | 4 | double GeneratorMicroTurbineHeatRecovery_Impl::minimumHeatRecoveryWaterFlowRate() const { | |
| 195 |
1/1✓ Branch 1 taken 4 times.
|
4 | boost::optional<double> value = getDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::MinimumHeatRecoveryWaterFlowRate, true); |
| 196 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
|
4 | OS_ASSERT(value); |
| 197 |
1/1✓ Branch 1 taken 4 times.
|
8 | return value.get(); |
| 198 | } | ||
| 199 | |||
| 200 | 3 | bool GeneratorMicroTurbineHeatRecovery_Impl::isMinimumHeatRecoveryWaterFlowRateDefaulted() const { | |
| 201 | 3 | return isEmpty(OS_Generator_MicroTurbine_HeatRecoveryFields::MinimumHeatRecoveryWaterFlowRate); | |
| 202 | } | ||
| 203 | |||
| 204 | 3 | double GeneratorMicroTurbineHeatRecovery_Impl::maximumHeatRecoveryWaterFlowRate() const { | |
| 205 |
1/1✓ Branch 1 taken 3 times.
|
3 | boost::optional<double> value = getDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::MaximumHeatRecoveryWaterFlowRate, true); |
| 206 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 4 not taken.
|
3 | OS_ASSERT(value); |
| 207 |
1/1✓ Branch 1 taken 3 times.
|
6 | return value.get(); |
| 208 | } | ||
| 209 | |||
| 210 | 3 | bool GeneratorMicroTurbineHeatRecovery_Impl::isMaximumHeatRecoveryWaterFlowRateDefaulted() const { | |
| 211 | 3 | return isEmpty(OS_Generator_MicroTurbine_HeatRecoveryFields::MaximumHeatRecoveryWaterFlowRate); | |
| 212 | } | ||
| 213 | |||
| 214 | 4 | boost::optional<double> GeneratorMicroTurbineHeatRecovery_Impl::maximumHeatRecoveryWaterTemperature() const { | |
| 215 | 4 | return getDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::MaximumHeatRecoveryWaterTemperature, true); | |
| 216 | } | ||
| 217 | |||
| 218 | // Get the parent generatorMicroTurbine | ||
| 219 | 7 | GeneratorMicroTurbine GeneratorMicroTurbineHeatRecovery_Impl::generatorMicroTurbine() const { | |
| 220 | |||
| 221 | 7 | boost::optional<GeneratorMicroTurbine> result; | |
| 222 |
4/4✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
✓ Branch 12 taken 7 times.
✓ Branch 13 taken 7 times.
|
14 | for (const GeneratorMicroTurbine& mchp : this->model().getConcreteModelObjects<GeneratorMicroTurbine>()) { |
| 223 |
2/3✓ Branch 1 taken 7 times.
✓ Branch 3 taken 7 times.
✗ Branch 4 not taken.
|
14 | if (boost::optional<GeneratorMicroTurbineHeatRecovery> mchpHR = mchp.generatorMicroTurbineHeatRecovery()) { |
| 224 |
5/6✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
✓ Branch 7 taken 7 times.
✓ Branch 10 taken 7 times.
✓ Branch 12 taken 7 times.
✗ Branch 13 not taken.
|
7 | if (mchpHR->handle() == this->handle()) { |
| 225 |
1/1✓ Branch 1 taken 7 times.
|
7 | result = mchp; |
| 226 | } | ||
| 227 | 7 | } | |
| 228 | 7 | } | |
| 229 | // This doesn't return an optional | ||
| 230 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 4 not taken.
|
7 | OS_ASSERT(result); |
| 231 |
2/2✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
|
14 | return result.get(); |
| 232 | 7 | } | |
| 233 | |||
| 234 | // If defaulted, return generatorMicroTurbineHeatRecovery 'Reference Thermal Efficiency Using Lower Heat Value' divided by its generatorMicroTurbine 'Reference Electrical Efficiency Using Lower Heating Value' | ||
| 235 | 3 | double GeneratorMicroTurbineHeatRecovery_Impl::ratedThermaltoElectricalPowerRatio() const { | |
| 236 | boost::optional<double> optRatedThermaltoElectricalPowerRatio = | ||
| 237 |
1/1✓ Branch 1 taken 3 times.
|
3 | getDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::RatedThermaltoElectricalPowerRatio, true); |
| 238 | // If there it's set | ||
| 239 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 time.
|
3 | if (optRatedThermaltoElectricalPowerRatio) { |
| 240 | // Get it and return | ||
| 241 |
1/1✓ Branch 1 taken 2 times.
|
2 | return optRatedThermaltoElectricalPowerRatio.get(); |
| 242 | } else { | ||
| 243 | // We try to default it | ||
| 244 | // First, check if there's a linked generator | ||
| 245 | // TODO: This should return an actual mchp once I make it part of the constructor. | ||
| 246 | //boost::optional<GeneratorMicroTurbine> mchp = this->generatorMicroTurbine(); | ||
| 247 | //if ( mchp ) { | ||
| 248 |
1/1✓ Branch 1 taken 1 time.
|
1 | GeneratorMicroTurbine mchp = this->generatorMicroTurbine(); |
| 249 |
1/1✓ Branch 1 taken 1 time.
|
1 | double refElecEffUsingLowerHeatingVal = mchp.referenceElectricalEfficiencyUsingLowerHeatingValue(); |
| 250 |
1/1✓ Branch 1 taken 1 time.
|
1 | double refThermalEffUsingLowerHeatVal = this->referenceThermalEfficiencyUsingLowerHeatValue(); |
| 251 | 1 | double ratedThermaltoElectricalPowerRatio = refThermalEffUsingLowerHeatVal / refElecEffUsingLowerHeatingVal; | |
| 252 | 1 | return ratedThermaltoElectricalPowerRatio; | |
| 253 | //} | ||
| 254 | 1 | } | |
| 255 | } | ||
| 256 | |||
| 257 | ✗ | bool GeneratorMicroTurbineHeatRecovery_Impl::isRatedThermaltoElectricalPowerRatioDefaulted() const { | |
| 258 | ✗ | return isEmpty(OS_Generator_MicroTurbine_HeatRecoveryFields::RatedThermaltoElectricalPowerRatio); | |
| 259 | } | ||
| 260 | |||
| 261 | /*bool GeneratorMicroTurbineHeatRecovery_Impl::setHeatRecoveryWaterInletNode(const boost::optional<Connection>& connection) { | ||
| 262 | bool result(false); | ||
| 263 | if (connection) { | ||
| 264 | result = setPointer(OS_Generator_MicroTurbineHeatRecoveryFields::HeatRecoveryWaterInletNodeName, connection.get().handle()); | ||
| 265 | } | ||
| 266 | else { | ||
| 267 | resetHeatRecoveryWaterInletNode(); | ||
| 268 | result = true; | ||
| 269 | } | ||
| 270 | return result; | ||
| 271 | } | ||
| 272 | |||
| 273 | void GeneratorMicroTurbineHeatRecovery_Impl::resetHeatRecoveryWaterInletNode() { | ||
| 274 | bool result = setString(OS_Generator_MicroTurbineHeatRecoveryFields::HeatRecoveryWaterInletNodeName, ""); | ||
| 275 | OS_ASSERT(result); | ||
| 276 | } | ||
| 277 | |||
| 278 | bool GeneratorMicroTurbineHeatRecovery_Impl::setHeatRecoveryWaterOutletNode(const boost::optional<Connection>& connection) { | ||
| 279 | bool result(false); | ||
| 280 | if (connection) { | ||
| 281 | result = setPointer(OS_Generator_MicroTurbineHeatRecoveryFields::HeatRecoveryWaterOutletNodeName, connection.get().handle()); | ||
| 282 | } | ||
| 283 | else { | ||
| 284 | resetHeatRecoveryWaterOutletNode(); | ||
| 285 | result = true; | ||
| 286 | } | ||
| 287 | return result; | ||
| 288 | } | ||
| 289 | |||
| 290 | void GeneratorMicroTurbineHeatRecovery_Impl::resetHeatRecoveryWaterOutletNode() { | ||
| 291 | bool result = setString(OS_Generator_MicroTurbineHeatRecoveryFields::HeatRecoveryWaterOutletNodeName, ""); | ||
| 292 | OS_ASSERT(result); | ||
| 293 | } */ | ||
| 294 | |||
| 295 | 8 | bool GeneratorMicroTurbineHeatRecovery_Impl::setReferenceThermalEfficiencyUsingLowerHeatValue(double value) { | |
| 296 | 8 | bool result = setDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceThermalEfficiencyUsingLowerHeatValue, value); | |
| 297 | 8 | return result; | |
| 298 | } | ||
| 299 | |||
| 300 | 1 | void GeneratorMicroTurbineHeatRecovery_Impl::resetReferenceThermalEfficiencyUsingLowerHeatValue() { | |
| 301 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceThermalEfficiencyUsingLowerHeatValue, ""); |
| 302 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 303 | 1 | } | |
| 304 | |||
| 305 | 8 | bool GeneratorMicroTurbineHeatRecovery_Impl::setReferenceInletWaterTemperature(double value) { | |
| 306 | 8 | bool result = setDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceInletWaterTemperature, value); | |
| 307 | 8 | return result; | |
| 308 | } | ||
| 309 | |||
| 310 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setHeatRecoveryWaterFlowOperatingMode(const std::string& heatRecoveryWaterFlowOperatingMode) { | |
| 311 | 1 | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowOperatingMode, heatRecoveryWaterFlowOperatingMode); | |
| 312 | 1 | return result; | |
| 313 | } | ||
| 314 | |||
| 315 | 1 | void GeneratorMicroTurbineHeatRecovery_Impl::resetHeatRecoveryWaterFlowOperatingMode() { | |
| 316 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowOperatingMode, ""); |
| 317 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 318 | 1 | } | |
| 319 | |||
| 320 | 8 | bool GeneratorMicroTurbineHeatRecovery_Impl::setReferenceHeatRecoveryWaterFlowRate(double value) { | |
| 321 | 8 | bool result = setDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::ReferenceHeatRecoveryWaterFlowRate, value); | |
| 322 | 8 | return result; | |
| 323 | } | ||
| 324 | |||
| 325 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(const Curve& curve) { | |
| 326 | bool result = | ||
| 327 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | setPointer(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurveName, curve.handle()); |
| 328 | 1 | return result; | |
| 329 | } | ||
| 330 | |||
| 331 | ✗ | void GeneratorMicroTurbineHeatRecovery_Impl::resetHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve() { | |
| 332 | ✗ | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurveName, ""); | |
| 333 | ✗ | OS_ASSERT(result); | |
| 334 | ✗ | } | |
| 335 | |||
| 336 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setThermalEfficiencyFunctionofTemperatureandElevationCurve(const Curve& curve) { | |
| 337 | bool result = | ||
| 338 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | setPointer(OS_Generator_MicroTurbine_HeatRecoveryFields::ThermalEfficiencyFunctionofTemperatureandElevationCurveName, curve.handle()); |
| 339 | 1 | return result; | |
| 340 | } | ||
| 341 | |||
| 342 | ✗ | void GeneratorMicroTurbineHeatRecovery_Impl::resetThermalEfficiencyFunctionofTemperatureandElevationCurve() { | |
| 343 | ✗ | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::ThermalEfficiencyFunctionofTemperatureandElevationCurveName, ""); | |
| 344 | ✗ | OS_ASSERT(result); | |
| 345 | ✗ | } | |
| 346 | |||
| 347 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setHeatRecoveryRateFunctionofPartLoadRatioCurve(const Curve& curve) { | |
| 348 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | bool result = setPointer(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofPartLoadRatioCurveName, curve.handle()); |
| 349 | 1 | return result; | |
| 350 | } | ||
| 351 | |||
| 352 | ✗ | void GeneratorMicroTurbineHeatRecovery_Impl::resetHeatRecoveryRateFunctionofPartLoadRatioCurve() { | |
| 353 | ✗ | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofPartLoadRatioCurveName, ""); | |
| 354 | ✗ | OS_ASSERT(result); | |
| 355 | ✗ | } | |
| 356 | |||
| 357 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(const Curve& curve) { | |
| 358 | bool result = | ||
| 359 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | setPointer(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofInletWaterTemperatureCurveName, curve.handle()); |
| 360 | 1 | return result; | |
| 361 | } | ||
| 362 | |||
| 363 | ✗ | void GeneratorMicroTurbineHeatRecovery_Impl::resetHeatRecoveryRateFunctionofInletWaterTemperatureCurve() { | |
| 364 | ✗ | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofInletWaterTemperatureCurveName, ""); | |
| 365 | ✗ | OS_ASSERT(result); | |
| 366 | ✗ | } | |
| 367 | |||
| 368 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setHeatRecoveryRateFunctionofWaterFlowRateCurve(const Curve& curve) { | |
| 369 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | bool result = setPointer(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofWaterFlowRateCurveName, curve.handle()); |
| 370 | 1 | return result; | |
| 371 | } | ||
| 372 | |||
| 373 | ✗ | void GeneratorMicroTurbineHeatRecovery_Impl::resetHeatRecoveryRateFunctionofWaterFlowRateCurve() { | |
| 374 | ✗ | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryRateFunctionofWaterFlowRateCurveName, ""); | |
| 375 | ✗ | OS_ASSERT(result); | |
| 376 | ✗ | } | |
| 377 | |||
| 378 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setMinimumHeatRecoveryWaterFlowRate(double minimumHeatRecoveryWaterFlowRate) { | |
| 379 | 1 | bool result = setDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::MinimumHeatRecoveryWaterFlowRate, minimumHeatRecoveryWaterFlowRate); | |
| 380 | 1 | return result; | |
| 381 | } | ||
| 382 | |||
| 383 | 1 | void GeneratorMicroTurbineHeatRecovery_Impl::resetMinimumHeatRecoveryWaterFlowRate() { | |
| 384 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::MinimumHeatRecoveryWaterFlowRate, ""); |
| 385 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 386 | 1 | } | |
| 387 | |||
| 388 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setMaximumHeatRecoveryWaterFlowRate(double maximumHeatRecoveryWaterFlowRate) { | |
| 389 | 1 | bool result = setDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::MaximumHeatRecoveryWaterFlowRate, maximumHeatRecoveryWaterFlowRate); | |
| 390 | 1 | return result; | |
| 391 | } | ||
| 392 | |||
| 393 | 1 | void GeneratorMicroTurbineHeatRecovery_Impl::resetMaximumHeatRecoveryWaterFlowRate() { | |
| 394 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::MaximumHeatRecoveryWaterFlowRate, ""); |
| 395 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 396 | 1 | } | |
| 397 | |||
| 398 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setMaximumHeatRecoveryWaterTemperature(double maximumHeatRecoveryWaterTemperature) { | |
| 399 | 1 | bool result = setDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::MaximumHeatRecoveryWaterTemperature, maximumHeatRecoveryWaterTemperature); | |
| 400 | 1 | return result; | |
| 401 | } | ||
| 402 | |||
| 403 | ✗ | void GeneratorMicroTurbineHeatRecovery_Impl::resetMaximumHeatRecoveryWaterTemperature() { | |
| 404 | ✗ | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::MaximumHeatRecoveryWaterTemperature, ""); | |
| 405 | ✗ | OS_ASSERT(result); | |
| 406 | ✗ | } | |
| 407 | |||
| 408 | 1 | bool GeneratorMicroTurbineHeatRecovery_Impl::setRatedThermaltoElectricalPowerRatio(double ratedThermaltoElectricalPowerRatio) { | |
| 409 | 1 | bool result = setDouble(OS_Generator_MicroTurbine_HeatRecoveryFields::RatedThermaltoElectricalPowerRatio, ratedThermaltoElectricalPowerRatio); | |
| 410 | 1 | return result; | |
| 411 | } | ||
| 412 | |||
| 413 | ✗ | void GeneratorMicroTurbineHeatRecovery_Impl::resetRatedThermaltoElectricalPowerRatio() { | |
| 414 | ✗ | bool result = setString(OS_Generator_MicroTurbine_HeatRecoveryFields::RatedThermaltoElectricalPowerRatio, ""); | |
| 415 | ✗ | OS_ASSERT(result); | |
| 416 | ✗ | } | |
| 417 | |||
| 418 | ✗ | std::vector<EMSActuatorNames> GeneratorMicroTurbineHeatRecovery_Impl::emsActuatorNames() const { | |
| 419 | ✗ | std::vector<EMSActuatorNames> actuators{{"On-Site Generator Control", "Requested Power"}}; | |
| 420 | ✗ | return actuators; | |
| 421 | ✗ | } | |
| 422 | |||
| 423 | ✗ | std::vector<std::string> GeneratorMicroTurbineHeatRecovery_Impl::emsInternalVariableNames() const { | |
| 424 | ✗ | std::vector<std::string> types{"Generator Nominal Maximum Power", "Generator Nominal Thermal To Electric Ratio"}; | |
| 425 | ✗ | return types; | |
| 426 | ✗ | } | |
| 427 | |||
| 428 | 1 | ComponentType GeneratorMicroTurbineHeatRecovery_Impl::componentType() const { | |
| 429 |
1/1✓ Branch 1 taken 1 time.
|
1 | return ComponentType::Heating; |
| 430 | } | ||
| 431 | |||
| 432 | ✗ | std::vector<FuelType> GeneratorMicroTurbineHeatRecovery_Impl::coolingFuelTypes() const { | |
| 433 | ✗ | return {}; | |
| 434 | } | ||
| 435 | |||
| 436 | ✗ | std::vector<FuelType> GeneratorMicroTurbineHeatRecovery_Impl::heatingFuelTypes() const { | |
| 437 | ✗ | return {FuelType(generatorMicroTurbine().fuelType())}; | |
| 438 | } | ||
| 439 | |||
| 440 | ✗ | std::vector<AppGFuelType> GeneratorMicroTurbineHeatRecovery_Impl::appGHeatingFuelTypes() const { | |
| 441 | ✗ | return {convertFuelTypeToAppG(FuelType(generatorMicroTurbine().fuelType()))}; | |
| 442 | } | ||
| 443 | |||
| 444 | } // namespace detail | ||
| 445 | |||
| 446 | // The constructor needs model, and a GeneratorMicroTurbine | ||
| 447 | 7 | GeneratorMicroTurbineHeatRecovery::GeneratorMicroTurbineHeatRecovery(const Model& model, GeneratorMicroTurbine& mchp) | |
| 448 | 7 | : StraightComponent(GeneratorMicroTurbineHeatRecovery::iddObjectType(), model) { | |
| 449 | |||
| 450 | // Set object in parent | ||
| 451 |
1/1✓ Branch 3 taken 7 times.
|
7 | mchp.getImpl<detail::GeneratorMicroTurbine_Impl>()->setGeneratorMicroTurbineHeatRecovery((*this)); |
| 452 | //mchp.setGeneratorMicroTurbineHeatRecovery( (*this) ); | ||
| 453 | |||
| 454 | // Set the Name to mchp.name + " Heat Recovery" | ||
| 455 |
2/3✓ Branch 1 taken 7 times.
✓ Branch 3 taken 7 times.
✗ Branch 4 not taken.
|
14 | if (OptionalString parentName = mchp.name()) { |
| 456 |
3/3✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
✓ Branch 7 taken 7 times.
|
7 | setName((*parentName) + " Heat Recovery"); |
| 457 | 7 | } | |
| 458 | |||
| 459 | // Reference Thermal Efficiency Using Lower Heat Value has a default of 0 in E+ idd which isn't smart in this case | ||
| 460 | // TODO Should I set it here, or change the .idd?? | ||
| 461 | // 0.4975 would be better | ||
| 462 | // Going with Kyle and Mark's way | ||
| 463 |
1/1✓ Branch 1 taken 7 times.
|
7 | setReferenceThermalEfficiencyUsingLowerHeatValue(0.4975); |
| 464 | |||
| 465 | // Assign all values that are required but have no default | ||
| 466 | |||
| 467 | // Reference Inlet Water Temperature | ||
| 468 |
1/1✓ Branch 1 taken 7 times.
|
7 | setReferenceInletWaterTemperature(60); |
| 469 | |||
| 470 | // Reference Heat Recovery Water Flow Rate | ||
| 471 |
1/1✓ Branch 1 taken 7 times.
|
7 | setReferenceHeatRecoveryWaterFlowRate(0.00252362); |
| 472 | |||
| 473 | // Maximum Heat Recovery Water Flow Rate: has a default value of 0 in E+.idd which isn't right in this case | ||
| 474 | // TODO: Should I set it here or change default in .idd? | ||
| 475 | // 0.003785432 | ||
| 476 | // TODO: Or make it an optional and set it to the reference Heat recovery water flow rate times 1.5? | ||
| 477 | 7 | } | |
| 478 | |||
| 479 | 7612 | IddObjectType GeneratorMicroTurbineHeatRecovery::iddObjectType() { | |
| 480 |
1/1✓ Branch 1 taken 7612 times.
|
7612 | return {IddObjectType::OS_Generator_MicroTurbine_HeatRecovery}; |
| 481 | } | ||
| 482 | |||
| 483 | ✗ | std::vector<std::string> GeneratorMicroTurbineHeatRecovery::validHeatRecoveryWaterFlowOperatingModeValues() { | |
| 484 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), | |
| 485 | ✗ | OS_Generator_MicroTurbine_HeatRecoveryFields::HeatRecoveryWaterFlowOperatingMode); | |
| 486 | } | ||
| 487 | |||
| 488 | /* | ||
| 489 | boost::optional<Connection> GeneratorMicroTurbineHeatRecovery::heatRecoveryWaterInletNode() const { | ||
| 490 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->heatRecoveryWaterInletNode(); | ||
| 491 | } | ||
| 492 | |||
| 493 | boost::optional<Connection> GeneratorMicroTurbineHeatRecovery::heatRecoveryWaterOutletNode() const { | ||
| 494 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->heatRecoveryWaterOutletNode(); | ||
| 495 | } | ||
| 496 | */ | ||
| 497 | |||
| 498 | 4 | double GeneratorMicroTurbineHeatRecovery::referenceThermalEfficiencyUsingLowerHeatValue() const { | |
| 499 |
1/1✓ Branch 3 taken 4 times.
|
4 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->referenceThermalEfficiencyUsingLowerHeatValue(); |
| 500 | } | ||
| 501 | |||
| 502 | 3 | bool GeneratorMicroTurbineHeatRecovery::isReferenceThermalEfficiencyUsingLowerHeatValueDefaulted() const { | |
| 503 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->isReferenceThermalEfficiencyUsingLowerHeatValueDefaulted(); |
| 504 | } | ||
| 505 | |||
| 506 | 4 | double GeneratorMicroTurbineHeatRecovery::referenceInletWaterTemperature() const { | |
| 507 |
1/1✓ Branch 3 taken 4 times.
|
4 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->referenceInletWaterTemperature(); |
| 508 | } | ||
| 509 | |||
| 510 | 4 | std::string GeneratorMicroTurbineHeatRecovery::heatRecoveryWaterFlowOperatingMode() const { | |
| 511 |
1/1✓ Branch 3 taken 4 times.
|
4 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->heatRecoveryWaterFlowOperatingMode(); |
| 512 | } | ||
| 513 | |||
| 514 | 3 | bool GeneratorMicroTurbineHeatRecovery::isHeatRecoveryWaterFlowOperatingModeDefaulted() const { | |
| 515 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->isHeatRecoveryWaterFlowOperatingModeDefaulted(); |
| 516 | } | ||
| 517 | |||
| 518 | 4 | double GeneratorMicroTurbineHeatRecovery::referenceHeatRecoveryWaterFlowRate() const { | |
| 519 |
1/1✓ Branch 3 taken 4 times.
|
4 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->referenceHeatRecoveryWaterFlowRate(); |
| 520 | } | ||
| 521 | |||
| 522 | 5 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery::heatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve() const { | |
| 523 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->heatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(); |
| 524 | } | ||
| 525 | |||
| 526 | 5 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery::thermalEfficiencyFunctionofTemperatureandElevationCurve() const { | |
| 527 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->thermalEfficiencyFunctionofTemperatureandElevationCurve(); |
| 528 | } | ||
| 529 | |||
| 530 | 5 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery::heatRecoveryRateFunctionofPartLoadRatioCurve() const { | |
| 531 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->heatRecoveryRateFunctionofPartLoadRatioCurve(); |
| 532 | } | ||
| 533 | |||
| 534 | 5 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery::heatRecoveryRateFunctionofInletWaterTemperatureCurve() const { | |
| 535 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->heatRecoveryRateFunctionofInletWaterTemperatureCurve(); |
| 536 | } | ||
| 537 | |||
| 538 | 5 | boost::optional<Curve> GeneratorMicroTurbineHeatRecovery::heatRecoveryRateFunctionofWaterFlowRateCurve() const { | |
| 539 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->heatRecoveryRateFunctionofWaterFlowRateCurve(); |
| 540 | } | ||
| 541 | |||
| 542 | 4 | double GeneratorMicroTurbineHeatRecovery::minimumHeatRecoveryWaterFlowRate() const { | |
| 543 |
1/1✓ Branch 3 taken 4 times.
|
4 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->minimumHeatRecoveryWaterFlowRate(); |
| 544 | } | ||
| 545 | |||
| 546 | 3 | bool GeneratorMicroTurbineHeatRecovery::isMinimumHeatRecoveryWaterFlowRateDefaulted() const { | |
| 547 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->isMinimumHeatRecoveryWaterFlowRateDefaulted(); |
| 548 | } | ||
| 549 | |||
| 550 | 3 | double GeneratorMicroTurbineHeatRecovery::maximumHeatRecoveryWaterFlowRate() const { | |
| 551 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->maximumHeatRecoveryWaterFlowRate(); |
| 552 | } | ||
| 553 | |||
| 554 | 3 | bool GeneratorMicroTurbineHeatRecovery::isMaximumHeatRecoveryWaterFlowRateDefaulted() const { | |
| 555 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->isMaximumHeatRecoveryWaterFlowRateDefaulted(); |
| 556 | } | ||
| 557 | |||
| 558 | 4 | boost::optional<double> GeneratorMicroTurbineHeatRecovery::maximumHeatRecoveryWaterTemperature() const { | |
| 559 |
1/1✓ Branch 3 taken 4 times.
|
4 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->maximumHeatRecoveryWaterTemperature(); |
| 560 | } | ||
| 561 | |||
| 562 | 3 | double GeneratorMicroTurbineHeatRecovery::ratedThermaltoElectricalPowerRatio() const { | |
| 563 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->ratedThermaltoElectricalPowerRatio(); |
| 564 | } | ||
| 565 | |||
| 566 | ✗ | bool GeneratorMicroTurbineHeatRecovery::isRatedThermaltoElectricalPowerRatioDefaulted() const { | |
| 567 | ✗ | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->isRatedThermaltoElectricalPowerRatioDefaulted(); | |
| 568 | } | ||
| 569 | |||
| 570 | 5 | GeneratorMicroTurbine GeneratorMicroTurbineHeatRecovery::generatorMicroTurbine() const { | |
| 571 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->generatorMicroTurbine(); |
| 572 | } | ||
| 573 | |||
| 574 | /* | ||
| 575 | bool GeneratorMicroTurbineHeatRecovery::setHeatRecoveryWaterInletNode(const Connection& connection) { | ||
| 576 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setHeatRecoveryWaterInletNode(connection); | ||
| 577 | } | ||
| 578 | |||
| 579 | void GeneratorMicroTurbineHeatRecovery::resetHeatRecoveryWaterInletNode() { | ||
| 580 | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetHeatRecoveryWaterInletNode(); | ||
| 581 | } | ||
| 582 | |||
| 583 | bool GeneratorMicroTurbineHeatRecovery::setHeatRecoveryWaterOutletNode(const Connection& connection) { | ||
| 584 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setHeatRecoveryWaterOutletNode(connection); | ||
| 585 | } | ||
| 586 | |||
| 587 | void GeneratorMicroTurbineHeatRecovery::resetHeatRecoveryWaterOutletNode() { | ||
| 588 | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetHeatRecoveryWaterOutletNode(); | ||
| 589 | } */ | ||
| 590 | |||
| 591 | 8 | bool GeneratorMicroTurbineHeatRecovery::setReferenceThermalEfficiencyUsingLowerHeatValue(double referenceThermalEfficiencyUsingLowerHeatValue) { | |
| 592 |
1/1✓ Branch 3 taken 8 times.
|
16 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setReferenceThermalEfficiencyUsingLowerHeatValue( |
| 593 | 16 | referenceThermalEfficiencyUsingLowerHeatValue); | |
| 594 | } | ||
| 595 | |||
| 596 | 1 | void GeneratorMicroTurbineHeatRecovery::resetReferenceThermalEfficiencyUsingLowerHeatValue() { | |
| 597 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetReferenceThermalEfficiencyUsingLowerHeatValue(); |
| 598 | 1 | } | |
| 599 | |||
| 600 | 8 | bool GeneratorMicroTurbineHeatRecovery::setReferenceInletWaterTemperature(double value) { | |
| 601 |
1/1✓ Branch 3 taken 8 times.
|
8 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setReferenceInletWaterTemperature(value); |
| 602 | } | ||
| 603 | |||
| 604 | 1 | bool GeneratorMicroTurbineHeatRecovery::setHeatRecoveryWaterFlowOperatingMode(const std::string& heatRecoveryWaterFlowOperatingMode) { | |
| 605 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setHeatRecoveryWaterFlowOperatingMode(heatRecoveryWaterFlowOperatingMode); |
| 606 | } | ||
| 607 | |||
| 608 | 1 | void GeneratorMicroTurbineHeatRecovery::resetHeatRecoveryWaterFlowOperatingMode() { | |
| 609 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetHeatRecoveryWaterFlowOperatingMode(); |
| 610 | 1 | } | |
| 611 | |||
| 612 | 8 | bool GeneratorMicroTurbineHeatRecovery::setReferenceHeatRecoveryWaterFlowRate(double value) { | |
| 613 |
1/1✓ Branch 3 taken 8 times.
|
8 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setReferenceHeatRecoveryWaterFlowRate(value); |
| 614 | } | ||
| 615 | |||
| 616 | 1 | bool GeneratorMicroTurbineHeatRecovery::setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(const Curve& curve) { | |
| 617 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(curve); |
| 618 | } | ||
| 619 | |||
| 620 | ✗ | void GeneratorMicroTurbineHeatRecovery::resetHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve() { | |
| 621 | ✗ | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(); | |
| 622 | ✗ | } | |
| 623 | |||
| 624 | 1 | bool GeneratorMicroTurbineHeatRecovery::setThermalEfficiencyFunctionofTemperatureandElevationCurve(const Curve& curve) { | |
| 625 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setThermalEfficiencyFunctionofTemperatureandElevationCurve(curve); |
| 626 | } | ||
| 627 | |||
| 628 | ✗ | void GeneratorMicroTurbineHeatRecovery::resetThermalEfficiencyFunctionofTemperatureandElevationCurve() { | |
| 629 | ✗ | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetThermalEfficiencyFunctionofTemperatureandElevationCurve(); | |
| 630 | ✗ | } | |
| 631 | |||
| 632 | 1 | bool GeneratorMicroTurbineHeatRecovery::setHeatRecoveryRateFunctionofPartLoadRatioCurve(const Curve& curve) { | |
| 633 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setHeatRecoveryRateFunctionofPartLoadRatioCurve(curve); |
| 634 | } | ||
| 635 | |||
| 636 | ✗ | void GeneratorMicroTurbineHeatRecovery::resetHeatRecoveryRateFunctionofPartLoadRatioCurve() { | |
| 637 | ✗ | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetHeatRecoveryRateFunctionofPartLoadRatioCurve(); | |
| 638 | ✗ | } | |
| 639 | |||
| 640 | 1 | bool GeneratorMicroTurbineHeatRecovery::setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(const Curve& curve) { | |
| 641 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(curve); |
| 642 | } | ||
| 643 | |||
| 644 | ✗ | void GeneratorMicroTurbineHeatRecovery::resetHeatRecoveryRateFunctionofInletWaterTemperatureCurve() { | |
| 645 | ✗ | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetHeatRecoveryRateFunctionofInletWaterTemperatureCurve(); | |
| 646 | ✗ | } | |
| 647 | |||
| 648 | 1 | bool GeneratorMicroTurbineHeatRecovery::setHeatRecoveryRateFunctionofWaterFlowRateCurve(const Curve& curve) { | |
| 649 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setHeatRecoveryRateFunctionofWaterFlowRateCurve(curve); |
| 650 | } | ||
| 651 | |||
| 652 | ✗ | void GeneratorMicroTurbineHeatRecovery::resetHeatRecoveryRateFunctionofWaterFlowRateCurve() { | |
| 653 | ✗ | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetHeatRecoveryRateFunctionofWaterFlowRateCurve(); | |
| 654 | ✗ | } | |
| 655 | |||
| 656 | 1 | bool GeneratorMicroTurbineHeatRecovery::setMinimumHeatRecoveryWaterFlowRate(double minimumHeatRecoveryWaterFlowRate) { | |
| 657 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setMinimumHeatRecoveryWaterFlowRate(minimumHeatRecoveryWaterFlowRate); |
| 658 | } | ||
| 659 | |||
| 660 | 1 | void GeneratorMicroTurbineHeatRecovery::resetMinimumHeatRecoveryWaterFlowRate() { | |
| 661 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetMinimumHeatRecoveryWaterFlowRate(); |
| 662 | 1 | } | |
| 663 | |||
| 664 | 1 | bool GeneratorMicroTurbineHeatRecovery::setMaximumHeatRecoveryWaterFlowRate(double maximumHeatRecoveryWaterFlowRate) { | |
| 665 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setMaximumHeatRecoveryWaterFlowRate(maximumHeatRecoveryWaterFlowRate); |
| 666 | } | ||
| 667 | |||
| 668 | 1 | void GeneratorMicroTurbineHeatRecovery::resetMaximumHeatRecoveryWaterFlowRate() { | |
| 669 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetMaximumHeatRecoveryWaterFlowRate(); |
| 670 | 1 | } | |
| 671 | |||
| 672 | 1 | bool GeneratorMicroTurbineHeatRecovery::setMaximumHeatRecoveryWaterTemperature(double maximumHeatRecoveryWaterTemperature) { | |
| 673 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setMaximumHeatRecoveryWaterTemperature(maximumHeatRecoveryWaterTemperature); |
| 674 | } | ||
| 675 | |||
| 676 | ✗ | void GeneratorMicroTurbineHeatRecovery::resetMaximumHeatRecoveryWaterTemperature() { | |
| 677 | ✗ | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetMaximumHeatRecoveryWaterTemperature(); | |
| 678 | ✗ | } | |
| 679 | |||
| 680 | 1 | bool GeneratorMicroTurbineHeatRecovery::setRatedThermaltoElectricalPowerRatio(double ratedThermaltoElectricalPowerRatio) { | |
| 681 |
1/1✓ Branch 3 taken 1 time.
|
1 | return getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->setRatedThermaltoElectricalPowerRatio(ratedThermaltoElectricalPowerRatio); |
| 682 | } | ||
| 683 | |||
| 684 | ✗ | void GeneratorMicroTurbineHeatRecovery::resetRatedThermaltoElectricalPowerRatio() { | |
| 685 | ✗ | getImpl<detail::GeneratorMicroTurbineHeatRecovery_Impl>()->resetRatedThermaltoElectricalPowerRatio(); | |
| 686 | ✗ | } | |
| 687 | |||
| 688 | /// @cond | ||
| 689 | 32 | GeneratorMicroTurbineHeatRecovery::GeneratorMicroTurbineHeatRecovery(std::shared_ptr<detail::GeneratorMicroTurbineHeatRecovery_Impl> impl) | |
| 690 |
1/1✓ Branch 3 taken 32 times.
|
32 | : StraightComponent(std::move(impl)) {} |
| 691 | /// @endcond | ||
| 692 | |||
| 693 | } // namespace model | ||
| 694 | } // namespace openstudio | ||
| 695 |