GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 37.4% 117 / 0 / 313
Functions: 37.4% 37 / 0 / 99
Branches: 24.2% 62 / 0 / 256

src/model/HeaderedPumpsConstantSpeed.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 "HeaderedPumpsConstantSpeed.hpp"
7 #include "HeaderedPumpsConstantSpeed_Impl.hpp"
8 #include "Schedule.hpp"
9 #include "Schedule_Impl.hpp"
10 #include "ThermalZone.hpp"
11 #include "ThermalZone_Impl.hpp"
12 #include "PlantLoop.hpp"
13 #include "PlantLoop_Impl.hpp"
14 #include "Node.hpp"
15 #include "Node_Impl.hpp"
16 #include "ScheduleTypeLimits.hpp"
17 #include "ScheduleTypeRegistry.hpp"
18 #include <utilities/idd/IddFactory.hxx>
19 #include <utilities/idd/OS_HeaderedPumps_ConstantSpeed_FieldEnums.hxx>
20 #include "../utilities/core/Assert.hpp"
21 #include "../utilities/data/DataEnums.hpp"
22
23 namespace openstudio {
24 namespace model {
25
26 namespace detail {
27
28 2 HeaderedPumpsConstantSpeed_Impl::HeaderedPumpsConstantSpeed_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
29 2 : StraightComponent_Impl(idfObject, model, keepHandle) {
30
4/6
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
✗ Branch 13 not taken.
2 OS_ASSERT(idfObject.iddObject().type() == HeaderedPumpsConstantSpeed::iddObjectType());
31 2 }
32
33 ✗ HeaderedPumpsConstantSpeed_Impl::HeaderedPumpsConstantSpeed_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
34 ✗ bool keepHandle)
35 ✗ : StraightComponent_Impl(other, model, keepHandle) {
36 ✗ OS_ASSERT(other.iddObject().type() == HeaderedPumpsConstantSpeed::iddObjectType());
37 ✗ }
38
39 ✗ HeaderedPumpsConstantSpeed_Impl::HeaderedPumpsConstantSpeed_Impl(const HeaderedPumpsConstantSpeed_Impl& other, Model_Impl* model, bool keepHandle)
40 ✗ : StraightComponent_Impl(other, model, keepHandle) {}
41
42 ✗ const std::vector<std::string>& HeaderedPumpsConstantSpeed_Impl::outputVariableNames() const {
43 static const std::vector<std::string> result{
44 "Pump Electricity Rate", "Pump Electricity Energy", "Pump Shaft Power", "Pump Fluid Heat Gain Rate", "Pump Fluid Heat Gain Energy",
45 "Pump Outlet Temperature", "Pump Mass Flow Rate", "Number of Pumps Operating",
46 // The Key is the Pump, not the zone, so it's right to report here
47 // EnergyPlus/Pumps.cc::GetPumpInput()
48 // TODO: Implement this check and make not static above once ModelObject return type has changed
49 //if (! p.zone().empty() ) {
50 "Pump Zone Total Heating Rate", "Pump Zone Total Heating Energy", "Pump Zone Convective Heating Rate", "Pump Zone Radiative Heating Rate"
51 // }
52 ✗ };
53 ✗ return result;
54 ✗ }
55
56 ✗ IddObjectType HeaderedPumpsConstantSpeed_Impl::iddObjectType() const {
57 ✗ return HeaderedPumpsConstantSpeed::iddObjectType();
58 }
59
60 ✗ std::vector<ScheduleTypeKey> HeaderedPumpsConstantSpeed_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
61 ✗ std::vector<ScheduleTypeKey> result;
62 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
63 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
64 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
65 ✗ if (std::find(b, e, OS_HeaderedPumps_ConstantSpeedFields::PumpFlowRateSchedule) != e) {
66 ✗ result.push_back(ScheduleTypeKey("HeaderedPumpsConstantSpeed", "Pump Flow Rate Schedule"));
67 }
68 ✗ return result;
69 ✗ }
70
71 ✗ boost::optional<double> HeaderedPumpsConstantSpeed_Impl::totalRatedFlowRate() const {
72 ✗ return getDouble(OS_HeaderedPumps_ConstantSpeedFields::TotalRatedFlowRate, true);
73 }
74
75 ✗ bool HeaderedPumpsConstantSpeed_Impl::isTotalRatedFlowRateAutosized() const {
76 ✗ bool result = false;
77 ✗ boost::optional<std::string> value = getString(OS_HeaderedPumps_ConstantSpeedFields::TotalRatedFlowRate, true);
78 ✗ if (value) {
79 ✗ result = openstudio::istringEqual(value.get(), "autosize");
80 }
81 ✗ return result;
82 ✗ }
83
84 ✗ int HeaderedPumpsConstantSpeed_Impl::numberofPumpsinBank() const {
85 ✗ boost::optional<int> value = getInt(OS_HeaderedPumps_ConstantSpeedFields::NumberofPumpsinBank, true);
86 ✗ OS_ASSERT(value);
87 ✗ return value.get();
88 }
89
90 ✗ std::string HeaderedPumpsConstantSpeed_Impl::flowSequencingControlScheme() const {
91 ✗ boost::optional<std::string> value = getString(OS_HeaderedPumps_ConstantSpeedFields::FlowSequencingControlScheme, true);
92 ✗ OS_ASSERT(value);
93 ✗ return value.get();
94 ✗ }
95
96 ✗ double HeaderedPumpsConstantSpeed_Impl::ratedPumpHead() const {
97 ✗ boost::optional<double> value = getDouble(OS_HeaderedPumps_ConstantSpeedFields::RatedPumpHead, true);
98 ✗ OS_ASSERT(value);
99 ✗ return value.get();
100 }
101
102 ✗ boost::optional<double> HeaderedPumpsConstantSpeed_Impl::ratedPowerConsumption() const {
103 ✗ return getDouble(OS_HeaderedPumps_ConstantSpeedFields::RatedPowerConsumption, true);
104 }
105
106 ✗ bool HeaderedPumpsConstantSpeed_Impl::isRatedPowerConsumptionAutosized() const {
107 ✗ bool result = false;
108 ✗ boost::optional<std::string> value = getString(OS_HeaderedPumps_ConstantSpeedFields::RatedPowerConsumption, true);
109 ✗ if (value) {
110 ✗ result = openstudio::istringEqual(value.get(), "autosize");
111 }
112 ✗ return result;
113 ✗ }
114
115 ✗ double HeaderedPumpsConstantSpeed_Impl::motorEfficiency() const {
116 ✗ boost::optional<double> value = getDouble(OS_HeaderedPumps_ConstantSpeedFields::MotorEfficiency, true);
117 ✗ OS_ASSERT(value);
118 ✗ return value.get();
119 }
120
121 ✗ double HeaderedPumpsConstantSpeed_Impl::fractionofMotorInefficienciestoFluidStream() const {
122 ✗ boost::optional<double> value = getDouble(OS_HeaderedPumps_ConstantSpeedFields::FractionofMotorInefficienciestoFluidStream, true);
123 ✗ OS_ASSERT(value);
124 ✗ return value.get();
125 }
126
127 ✗ std::string HeaderedPumpsConstantSpeed_Impl::pumpControlType() const {
128 ✗ boost::optional<std::string> value = getString(OS_HeaderedPumps_ConstantSpeedFields::PumpControlType, true);
129 ✗ OS_ASSERT(value);
130 ✗ return value.get();
131 ✗ }
132
133 ✗ boost::optional<Schedule> HeaderedPumpsConstantSpeed_Impl::pumpFlowRateSchedule() const {
134 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_HeaderedPumps_ConstantSpeedFields::PumpFlowRateSchedule);
135 }
136
137 ✗ boost::optional<ThermalZone> HeaderedPumpsConstantSpeed_Impl::thermalZone() const {
138 ✗ return getObject<ModelObject>().getModelObjectTarget<ThermalZone>(OS_HeaderedPumps_ConstantSpeedFields::ThermalZone);
139 }
140
141 ✗ double HeaderedPumpsConstantSpeed_Impl::skinLossRadiativeFraction() const {
142 ✗ boost::optional<double> value = getDouble(OS_HeaderedPumps_ConstantSpeedFields::SkinLossRadiativeFraction, true);
143 ✗ OS_ASSERT(value);
144 ✗ return value.get();
145 }
146
147 ✗ bool HeaderedPumpsConstantSpeed_Impl::setTotalRatedFlowRate(boost::optional<double> totalRatedFlowRate) {
148 ✗ bool result(false);
149 ✗ if (totalRatedFlowRate) {
150 ✗ result = setDouble(OS_HeaderedPumps_ConstantSpeedFields::TotalRatedFlowRate, totalRatedFlowRate.get());
151 }
152 ✗ return result;
153 }
154
155 2 void HeaderedPumpsConstantSpeed_Impl::autosizeTotalRatedFlowRate() {
156
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 bool result = setString(OS_HeaderedPumps_ConstantSpeedFields::TotalRatedFlowRate, "autosize");
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
158 2 }
159
160 2 bool HeaderedPumpsConstantSpeed_Impl::setNumberofPumpsinBank(int numberofPumpsinBank) {
161 2 bool result = setInt(OS_HeaderedPumps_ConstantSpeedFields::NumberofPumpsinBank, numberofPumpsinBank);
162
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
163 2 return result;
164 }
165
166 2 bool HeaderedPumpsConstantSpeed_Impl::setFlowSequencingControlScheme(const std::string& flowSequencingControlScheme) {
167 2 bool result = setString(OS_HeaderedPumps_ConstantSpeedFields::FlowSequencingControlScheme, flowSequencingControlScheme);
168 2 return result;
169 }
170
171 2 bool HeaderedPumpsConstantSpeed_Impl::setRatedPumpHead(double ratedPumpHead) {
172 2 bool result = setDouble(OS_HeaderedPumps_ConstantSpeedFields::RatedPumpHead, ratedPumpHead);
173
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
174 2 return result;
175 }
176
177 ✗ bool HeaderedPumpsConstantSpeed_Impl::setRatedPowerConsumption(boost::optional<double> ratedPowerConsumption) {
178 ✗ bool result(false);
179 ✗ if (ratedPowerConsumption) {
180 ✗ result = setDouble(OS_HeaderedPumps_ConstantSpeedFields::RatedPowerConsumption, ratedPowerConsumption.get());
181 }
182 ✗ OS_ASSERT(result);
183 ✗ return result;
184 }
185
186 2 void HeaderedPumpsConstantSpeed_Impl::autosizeRatedPowerConsumption() {
187
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 bool result = setString(OS_HeaderedPumps_ConstantSpeedFields::RatedPowerConsumption, "autosize");
188
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
189 2 }
190
191 2 bool HeaderedPumpsConstantSpeed_Impl::setMotorEfficiency(double motorEfficiency) {
192 2 bool result = setDouble(OS_HeaderedPumps_ConstantSpeedFields::MotorEfficiency, motorEfficiency);
193 2 return result;
194 }
195
196 2 bool HeaderedPumpsConstantSpeed_Impl::setFractionofMotorInefficienciestoFluidStream(double fractionofMotorInefficienciestoFluidStream) {
197 bool result =
198 2 setDouble(OS_HeaderedPumps_ConstantSpeedFields::FractionofMotorInefficienciestoFluidStream, fractionofMotorInefficienciestoFluidStream);
199 2 return result;
200 }
201
202 2 bool HeaderedPumpsConstantSpeed_Impl::setPumpControlType(const std::string& pumpControlType) {
203 2 bool result = setString(OS_HeaderedPumps_ConstantSpeedFields::PumpControlType, pumpControlType);
204 2 return result;
205 }
206
207 ✗ bool HeaderedPumpsConstantSpeed_Impl::setPumpFlowRateSchedule(Schedule& schedule) {
208 bool result =
209 ✗ setSchedule(OS_HeaderedPumps_ConstantSpeedFields::PumpFlowRateSchedule, "HeaderedPumpsConstantSpeed", "Pump Flow Rate Schedule", schedule);
210 ✗ return result;
211 }
212
213 ✗ void HeaderedPumpsConstantSpeed_Impl::resetPumpFlowRateSchedule() {
214 ✗ bool result = setString(OS_HeaderedPumps_ConstantSpeedFields::PumpFlowRateSchedule, "");
215 ✗ OS_ASSERT(result);
216 ✗ }
217
218 ✗ bool HeaderedPumpsConstantSpeed_Impl::setThermalZone(const boost::optional<ThermalZone>& thermalZone) {
219 ✗ bool result(false);
220 ✗ if (thermalZone) {
221 ✗ result = setPointer(OS_HeaderedPumps_ConstantSpeedFields::ThermalZone, thermalZone.get().handle());
222 } else {
223 ✗ resetThermalZone();
224 ✗ result = true;
225 }
226 ✗ return result;
227 }
228
229 ✗ void HeaderedPumpsConstantSpeed_Impl::resetThermalZone() {
230 ✗ bool result = setString(OS_HeaderedPumps_ConstantSpeedFields::ThermalZone, "");
231 ✗ OS_ASSERT(result);
232 ✗ }
233
234 2 bool HeaderedPumpsConstantSpeed_Impl::setSkinLossRadiativeFraction(double skinLossRadiativeFraction) {
235 2 bool result = setDouble(OS_HeaderedPumps_ConstantSpeedFields::SkinLossRadiativeFraction, skinLossRadiativeFraction);
236 2 return result;
237 }
238
239 ✗ unsigned HeaderedPumpsConstantSpeed_Impl::inletPort() const {
240 ✗ return OS_HeaderedPumps_ConstantSpeedFields::InletNodeName;
241 }
242
243 ✗ unsigned HeaderedPumpsConstantSpeed_Impl::outletPort() const {
244 ✗ return OS_HeaderedPumps_ConstantSpeedFields::OutletNodeName;
245 }
246
247 ✗ bool HeaderedPumpsConstantSpeed_Impl::addToNode(Node& node) {
248 ✗ if (node.plantLoop()) {
249 ✗ return StraightComponent_Impl::addToNode(node);
250 }
251
252 ✗ return false;
253 }
254
255 ✗ boost::optional<double> HeaderedPumpsConstantSpeed_Impl::autosizedTotalRatedFlowRate() const {
256 ✗ return getAutosizedValue("Design Flow Rate", "m3/s");
257 }
258
259 ✗ boost::optional<double> HeaderedPumpsConstantSpeed_Impl::autosizedRatedPowerConsumption() const {
260 ✗ return getAutosizedValue("Design Power Consumption", "W");
261 }
262
263 ✗ void HeaderedPumpsConstantSpeed_Impl::autosize() {
264 ✗ autosizeTotalRatedFlowRate();
265 ✗ autosizeRatedPowerConsumption();
266 ✗ }
267
268 ✗ void HeaderedPumpsConstantSpeed_Impl::applySizingValues() {
269 ✗ boost::optional<double> val;
270 ✗ val = autosizedTotalRatedFlowRate();
271 ✗ if (val) {
272 ✗ setTotalRatedFlowRate(val.get());
273 }
274
275 ✗ val = autosizedRatedPowerConsumption();
276 ✗ if (val) {
277 ✗ setRatedPowerConsumption(val.get());
278 }
279 ✗ }
280
281 ✗ std::vector<EMSActuatorNames> HeaderedPumpsConstantSpeed_Impl::emsActuatorNames() const {
282 ✗ std::vector<EMSActuatorNames> actuators{{"Pump", "Pump Mass Flow Rate"}, {"Pump", "Pump Pressure Rise"}};
283 ✗ return actuators;
284 ✗ }
285
286 ✗ std::vector<std::string> HeaderedPumpsConstantSpeed_Impl::emsInternalVariableNames() const {
287 ✗ std::vector<std::string> types{"Pump Maximum Mass Flow Rate"};
288 ✗ return types;
289 ✗ }
290
291 3 std::string HeaderedPumpsConstantSpeed_Impl::designPowerSizingMethod() const {
292
1/1
✓ Branch 1 taken 3 times.
3 auto value = getString(OS_HeaderedPumps_ConstantSpeedFields::DesignPowerSizingMethod, true);
293
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 4 not taken.
3 OS_ASSERT(value);
294
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
6 return value.get();
295 3 }
296
297 4 bool HeaderedPumpsConstantSpeed_Impl::setDesignPowerSizingMethod(const std::string& designPowerSizingMethod) {
298 4 return setString(OS_HeaderedPumps_ConstantSpeedFields::DesignPowerSizingMethod, designPowerSizingMethod);
299 }
300
301 2 double HeaderedPumpsConstantSpeed_Impl::designElectricPowerPerUnitFlowRate() const {
302
1/1
✓ Branch 1 taken 2 times.
2 auto value = getDouble(OS_HeaderedPumps_ConstantSpeedFields::DesignElectricPowerperUnitFlowRate, true);
303
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 4 not taken.
2 OS_ASSERT(value);
304
1/1
✓ Branch 1 taken 2 times.
4 return value.get();
305 }
306
307 3 bool HeaderedPumpsConstantSpeed_Impl::setDesignElectricPowerPerUnitFlowRate(double designElectricPowerPerUnitFlowRate) {
308 3 return setDouble(OS_HeaderedPumps_ConstantSpeedFields::DesignElectricPowerperUnitFlowRate, designElectricPowerPerUnitFlowRate);
309 }
310
311 2 double HeaderedPumpsConstantSpeed_Impl::designShaftPowerPerUnitFlowRatePerUnitHead() const {
312
1/1
✓ Branch 1 taken 2 times.
2 auto value = getDouble(OS_HeaderedPumps_ConstantSpeedFields::DesignShaftPowerperUnitFlowRateperUnitHead, true);
313
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 4 not taken.
2 OS_ASSERT(value);
314
1/1
✓ Branch 1 taken 2 times.
4 return value.get();
315 }
316
317 3 bool HeaderedPumpsConstantSpeed_Impl::setDesignShaftPowerPerUnitFlowRatePerUnitHead(double designShaftPowerPerUnitFlowRatePerUnitHead) {
318 3 return setDouble(OS_HeaderedPumps_ConstantSpeedFields::DesignShaftPowerperUnitFlowRateperUnitHead, designShaftPowerPerUnitFlowRatePerUnitHead);
319 }
320
321 2 std::string HeaderedPumpsConstantSpeed_Impl::endUseSubcategory() const {
322
1/1
✓ Branch 1 taken 2 times.
2 auto value = getString(OS_HeaderedPumps_ConstantSpeedFields::EndUseSubcategory, true);
323
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 4 not taken.
2 OS_ASSERT(value);
324
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 return value.get();
325 2 }
326
327 3 bool HeaderedPumpsConstantSpeed_Impl::setEndUseSubcategory(const std::string& endUseSubcategory) {
328 3 return setString(OS_HeaderedPumps_ConstantSpeedFields::EndUseSubcategory, endUseSubcategory);
329 }
330
331 ✗ ComponentType HeaderedPumpsConstantSpeed_Impl::componentType() const {
332 ✗ return ComponentType::None;
333 }
334
335 ✗ std::vector<FuelType> HeaderedPumpsConstantSpeed_Impl::coolingFuelTypes() const {
336 ✗ return {};
337 }
338
339 ✗ std::vector<FuelType> HeaderedPumpsConstantSpeed_Impl::heatingFuelTypes() const {
340 ✗ return {};
341 }
342
343 ✗ std::vector<AppGFuelType> HeaderedPumpsConstantSpeed_Impl::appGHeatingFuelTypes() const {
344 ✗ return {};
345 }
346
347 } // namespace detail
348
349 2 HeaderedPumpsConstantSpeed::HeaderedPumpsConstantSpeed(const Model& model) : StraightComponent(HeaderedPumpsConstantSpeed::iddObjectType(), model) {
350
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✗ Branch 5 not taken.
2 OS_ASSERT(getImpl<detail::HeaderedPumpsConstantSpeed_Impl>());
351
352
1/1
✓ Branch 1 taken 2 times.
2 autosizeTotalRatedFlowRate();
353
1/1
✓ Branch 1 taken 2 times.
2 setNumberofPumpsinBank(2);
354
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 setFlowSequencingControlScheme("Sequential");
355
1/1
✓ Branch 1 taken 2 times.
2 setRatedPumpHead(179352);
356
1/1
✓ Branch 1 taken 2 times.
2 autosizeRatedPowerConsumption();
357
1/1
✓ Branch 1 taken 2 times.
2 setMotorEfficiency(0.9);
358
1/1
✓ Branch 1 taken 2 times.
2 setFractionofMotorInefficienciestoFluidStream(0.0);
359
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 setPumpControlType("Continuous");
360
1/1
✓ Branch 1 taken 2 times.
2 setSkinLossRadiativeFraction(0.1);
361
362
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 setDesignPowerSizingMethod("PowerPerFlowPerPressure");
363
1/1
✓ Branch 1 taken 2 times.
2 setDesignElectricPowerPerUnitFlowRate(348701.1);
364
1/1
✓ Branch 1 taken 2 times.
2 setDesignShaftPowerPerUnitFlowRatePerUnitHead(1.282051282);
365
366
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 setEndUseSubcategory("General");
367 2 }
368
369 7732 IddObjectType HeaderedPumpsConstantSpeed::iddObjectType() {
370
1/1
✓ Branch 1 taken 7732 times.
7732 return {IddObjectType::OS_HeaderedPumps_ConstantSpeed};
371 }
372
373 ✗ std::vector<std::string> HeaderedPumpsConstantSpeed::flowSequencingControlSchemeValues() {
374 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeaderedPumps_ConstantSpeedFields::FlowSequencingControlScheme);
375 }
376
377 ✗ std::vector<std::string> HeaderedPumpsConstantSpeed::pumpControlTypeValues() {
378 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeaderedPumps_ConstantSpeedFields::PumpControlType);
379 }
380
381 ✗ std::vector<std::string> HeaderedPumpsConstantSpeed::designPowerSizingMethodValues() {
382 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeaderedPumps_ConstantSpeedFields::DesignPowerSizingMethod);
383 }
384
385 ✗ boost::optional<double> HeaderedPumpsConstantSpeed::totalRatedFlowRate() const {
386 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->totalRatedFlowRate();
387 }
388
389 ✗ bool HeaderedPumpsConstantSpeed::isTotalRatedFlowRateAutosized() const {
390 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->isTotalRatedFlowRateAutosized();
391 }
392
393 ✗ int HeaderedPumpsConstantSpeed::numberofPumpsinBank() const {
394 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->numberofPumpsinBank();
395 }
396
397 ✗ std::string HeaderedPumpsConstantSpeed::flowSequencingControlScheme() const {
398 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->flowSequencingControlScheme();
399 }
400
401 ✗ double HeaderedPumpsConstantSpeed::ratedPumpHead() const {
402 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->ratedPumpHead();
403 }
404
405 ✗ boost::optional<double> HeaderedPumpsConstantSpeed::ratedPowerConsumption() const {
406 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->ratedPowerConsumption();
407 }
408
409 ✗ bool HeaderedPumpsConstantSpeed::isRatedPowerConsumptionAutosized() const {
410 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->isRatedPowerConsumptionAutosized();
411 }
412
413 ✗ double HeaderedPumpsConstantSpeed::motorEfficiency() const {
414 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->motorEfficiency();
415 }
416
417 ✗ double HeaderedPumpsConstantSpeed::fractionofMotorInefficienciestoFluidStream() const {
418 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->fractionofMotorInefficienciestoFluidStream();
419 }
420
421 ✗ std::string HeaderedPumpsConstantSpeed::pumpControlType() const {
422 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->pumpControlType();
423 }
424
425 ✗ boost::optional<Schedule> HeaderedPumpsConstantSpeed::pumpFlowRateSchedule() const {
426 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->pumpFlowRateSchedule();
427 }
428
429 ✗ boost::optional<ThermalZone> HeaderedPumpsConstantSpeed::thermalZone() const {
430 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->thermalZone();
431 }
432
433 ✗ double HeaderedPumpsConstantSpeed::skinLossRadiativeFraction() const {
434 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->skinLossRadiativeFraction();
435 }
436
437 ✗ bool HeaderedPumpsConstantSpeed::setTotalRatedFlowRate(double totalRatedFlowRate) {
438 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setTotalRatedFlowRate(totalRatedFlowRate);
439 }
440
441 2 void HeaderedPumpsConstantSpeed::autosizeTotalRatedFlowRate() {
442
1/1
✓ Branch 3 taken 2 times.
2 getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->autosizeTotalRatedFlowRate();
443 2 }
444
445 2 bool HeaderedPumpsConstantSpeed::setNumberofPumpsinBank(int numberofPumpsinBank) {
446
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setNumberofPumpsinBank(numberofPumpsinBank);
447 }
448
449 2 bool HeaderedPumpsConstantSpeed::setFlowSequencingControlScheme(const std::string& flowSequencingControlScheme) {
450
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setFlowSequencingControlScheme(flowSequencingControlScheme);
451 }
452
453 2 bool HeaderedPumpsConstantSpeed::setRatedPumpHead(double ratedPumpHead) {
454
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setRatedPumpHead(ratedPumpHead);
455 }
456
457 ✗ bool HeaderedPumpsConstantSpeed::setRatedPowerConsumption(double ratedPowerConsumption) {
458 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setRatedPowerConsumption(ratedPowerConsumption);
459 }
460
461 2 void HeaderedPumpsConstantSpeed::autosizeRatedPowerConsumption() {
462
1/1
✓ Branch 3 taken 2 times.
2 getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->autosizeRatedPowerConsumption();
463 2 }
464
465 2 bool HeaderedPumpsConstantSpeed::setMotorEfficiency(double motorEfficiency) {
466
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setMotorEfficiency(motorEfficiency);
467 }
468
469 2 bool HeaderedPumpsConstantSpeed::setFractionofMotorInefficienciestoFluidStream(double fractionofMotorInefficienciestoFluidStream) {
470
1/1
✓ Branch 3 taken 2 times.
4 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setFractionofMotorInefficienciestoFluidStream(
471 4 fractionofMotorInefficienciestoFluidStream);
472 }
473
474 2 bool HeaderedPumpsConstantSpeed::setPumpControlType(const std::string& pumpControlType) {
475
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setPumpControlType(pumpControlType);
476 }
477
478 ✗ bool HeaderedPumpsConstantSpeed::setPumpFlowRateSchedule(Schedule& schedule) {
479 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setPumpFlowRateSchedule(schedule);
480 }
481
482 ✗ void HeaderedPumpsConstantSpeed::resetPumpFlowRateSchedule() {
483 ✗ getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->resetPumpFlowRateSchedule();
484 ✗ }
485
486 ✗ bool HeaderedPumpsConstantSpeed::setThermalZone(const ThermalZone& thermalZone) {
487 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setThermalZone(thermalZone);
488 }
489
490 ✗ void HeaderedPumpsConstantSpeed::resetThermalZone() {
491 ✗ getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->resetThermalZone();
492 ✗ }
493
494 2 bool HeaderedPumpsConstantSpeed::setSkinLossRadiativeFraction(double skinLossRadiativeFraction) {
495
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setSkinLossRadiativeFraction(skinLossRadiativeFraction);
496 }
497
498 3 std::string HeaderedPumpsConstantSpeed::designPowerSizingMethod() const {
499
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->designPowerSizingMethod();
500 }
501
502 4 bool HeaderedPumpsConstantSpeed::setDesignPowerSizingMethod(const std::string& designPowerSizingMethod) {
503
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setDesignPowerSizingMethod(designPowerSizingMethod);
504 }
505
506 2 double HeaderedPumpsConstantSpeed::designElectricPowerPerUnitFlowRate() const {
507
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->designElectricPowerPerUnitFlowRate();
508 }
509
510 3 bool HeaderedPumpsConstantSpeed::setDesignElectricPowerPerUnitFlowRate(double designElectricPowerPerUnitFlowRate) {
511
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setDesignElectricPowerPerUnitFlowRate(designElectricPowerPerUnitFlowRate);
512 }
513
514 2 double HeaderedPumpsConstantSpeed::designShaftPowerPerUnitFlowRatePerUnitHead() const {
515
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->designShaftPowerPerUnitFlowRatePerUnitHead();
516 }
517
518 3 bool HeaderedPumpsConstantSpeed::setDesignShaftPowerPerUnitFlowRatePerUnitHead(double designShaftPowerPerUnitFlowRatePerUnitHead) {
519
1/1
✓ Branch 3 taken 3 times.
6 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setDesignShaftPowerPerUnitFlowRatePerUnitHead(
520 6 designShaftPowerPerUnitFlowRatePerUnitHead);
521 }
522
523 2 std::string HeaderedPumpsConstantSpeed::endUseSubcategory() const {
524
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->endUseSubcategory();
525 }
526
527 3 bool HeaderedPumpsConstantSpeed::setEndUseSubcategory(const std::string& endUseSubcategory) {
528
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->setEndUseSubcategory(endUseSubcategory);
529 }
530
531 /// @cond
532 ✗ HeaderedPumpsConstantSpeed::HeaderedPumpsConstantSpeed(std::shared_ptr<detail::HeaderedPumpsConstantSpeed_Impl> impl)
533 ✗ : StraightComponent(std::move(impl)) {}
534 /// @endcond
535
536 ✗ boost::optional<double> HeaderedPumpsConstantSpeed::autosizedTotalRatedFlowRate() const {
537 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->autosizedTotalRatedFlowRate();
538 }
539
540 ✗ boost::optional<double> HeaderedPumpsConstantSpeed::autosizedRatedPowerConsumption() const {
541 ✗ return getImpl<detail::HeaderedPumpsConstantSpeed_Impl>()->autosizedRatedPowerConsumption();
542 }
543
544 } // namespace model
545 } // namespace openstudio
546