GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 32.5% 65 / 0 / 200
Functions: 41.5% 22 / 0 / 53
Branches: 20.8% 40 / 0 / 192

src/model/SteamEquipment.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 "SteamEquipment.hpp"
7 #include "SteamEquipment_Impl.hpp"
8
9 #include "SteamEquipmentDefinition.hpp"
10 #include "SteamEquipmentDefinition_Impl.hpp"
11 #include "Schedule.hpp"
12 #include "Schedule_Impl.hpp"
13 #include "Space.hpp"
14 #include "Space_Impl.hpp"
15 #include "SpaceType.hpp"
16 #include "SpaceType_Impl.hpp"
17 #include "DefaultScheduleSet.hpp"
18 #include "DefaultScheduleSet_Impl.hpp"
19 #include "LifeCycleCost.hpp"
20 #include "Model.hpp"
21
22 #include <utilities/idd/OS_SteamEquipment_FieldEnums.hxx>
23 #include <utilities/idd/IddEnums.hxx>
24
25 #include "../utilities/core/Assert.hpp"
26
27 namespace openstudio {
28 namespace model {
29
30 namespace detail {
31
32 5 SteamEquipment_Impl::SteamEquipment_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
33 5 : SpaceLoadInstance_Impl(idfObject, model, keepHandle) {
34
4/6
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 5 times.
✗ Branch 13 not taken.
5 OS_ASSERT(idfObject.iddObject().type() == SteamEquipment::iddObjectType());
35 5 }
36
37 ✗ SteamEquipment_Impl::SteamEquipment_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
38 ✗ : SpaceLoadInstance_Impl(other, model, keepHandle) {
39 ✗ OS_ASSERT(other.iddObject().type() == SteamEquipment::iddObjectType());
40 ✗ }
41
42 4 SteamEquipment_Impl::SteamEquipment_Impl(const SteamEquipment_Impl& other, Model_Impl* model, bool keepHandle)
43 4 : SpaceLoadInstance_Impl(other, model, keepHandle) {}
44
45 ✗ const std::vector<std::string>& SteamEquipment_Impl::outputVariableNames() const {
46 static const std::vector<std::string> result{
47 "Steam Equipment District Heating Rate",
48 "Steam Equipment District Heating Energy",
49 "Steam Equipment Radiant Heating Energy",
50 "Steam Equipment Radiant Heating Rate",
51 "Steam Equipment Convective Heating Energy",
52 "Steam Equipment Convective Heating Rate",
53 "Steam Equipment Latent Gain Energy",
54 "Steam Equipment Latent Gain Rate",
55 "Steam Equipment Lost Heat Energy",
56 "Steam Equipment Lost Heat Rate",
57 "Steam Equipment Total Heating Energy",
58 "Steam Equipment Total Heating Rate"
59
60 // Reported in ThermalZone
61 //"Zone Steam Equipment District Heating Rate",
62 //"Zone Steam Equipment District Heating Energy",
63 //"Zone Steam Equipment Radiant Heating Energy",
64 //"Zone Steam Equipment Radiant Heating Rate",
65 //"Zone Steam Equipment Convective Heating Energy",
66 //"Zone Steam Equipment Convective Heating Rate",
67 //"Zone Steam Equipment Latent Gain Energy",
68 //"Zone Steam Equipment Latent Gain Rate",
69 //"Zone Steam Equipment Lost Heat Energy",
70 //"Zone Steam Equipment Lost Heat Rate",
71 //"Zone Steam Equipment Total Heating Energy",
72 //"Zone Steam Equipment Total Heating Rate"
73 ✗ };
74 ✗ return result;
75 ✗ }
76
77 ✗ IddObjectType SteamEquipment_Impl::iddObjectType() const {
78 ✗ return SteamEquipment::iddObjectType();
79 }
80
81 ✗ std::vector<ScheduleTypeKey> SteamEquipment_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
82 ✗ std::vector<ScheduleTypeKey> result;
83 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
84 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
85 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
86 ✗ if (std::find(b, e, OS_SteamEquipmentFields::ScheduleName) != e) {
87 ✗ result.push_back(ScheduleTypeKey("SteamEquipment", "Steam Equipment"));
88 }
89 ✗ return result;
90 ✗ }
91
92 ✗ bool SteamEquipment_Impl::hardSize() {
93 ✗ OptionalSpace space = this->space();
94 ✗ if (!space) {
95 ✗ return false;
96 }
97
98 ✗ makeUnique();
99
100 ✗ SteamEquipmentDefinition definition = steamEquipmentDefinition();
101 ✗ for (LifeCycleCost& cost : definition.lifeCycleCosts()) {
102 ✗ cost.convertToCostPerEach();
103 ✗ }
104
105 ✗ if (definition.designLevel()) {
106 ✗ return true;
107 }
108 ✗ if (OptionalDouble areaDensity = definition.wattsperSpaceFloorArea()) {
109 ✗ return definition.setDesignLevel(*areaDensity * space->floorArea());
110 }
111 ✗ if (OptionalDouble peopleDensity = definition.wattsperPerson()) {
112 ✗ return definition.setDesignLevel(*peopleDensity * space->numberOfPeople());
113 }
114
115 ✗ OS_ASSERT(false);
116 ✗ return false;
117 ✗ }
118
119 ✗ bool SteamEquipment_Impl::hardApplySchedules() {
120 ✗ if (OptionalSchedule schedule = this->schedule()) {
121 ✗ return setSchedule(*schedule);
122 ✗ }
123 ✗ return false;
124 }
125
126 4 SteamEquipmentDefinition SteamEquipment_Impl::steamEquipmentDefinition() const {
127
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 return definition().cast<SteamEquipmentDefinition>();
128 }
129
130 4 boost::optional<Schedule> SteamEquipment_Impl::schedule() const {
131
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 OptionalSchedule result = getObject<SteamEquipment>().getModelObjectTarget<Schedule>(OS_SteamEquipmentFields::ScheduleName);
132
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1 time.
4 if (!result) {
133 // search upwards
134
1/1
✓ Branch 1 taken 3 times.
3 OptionalSpace space = this->space();
135
1/1
✓ Branch 1 taken 3 times.
3 OptionalSpaceType spaceType = this->spaceType();
136
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (space) {
137
3/3
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
3 result = space->getDefaultSchedule(DefaultScheduleType::SteamEquipmentSchedule);
138 ✗ } else if (spaceType) {
139 ✗ result = spaceType->getDefaultSchedule(DefaultScheduleType::SteamEquipmentSchedule);
140 }
141 3 }
142 4 return result;
143 ✗ }
144
145 ✗ bool SteamEquipment_Impl::isScheduleDefaulted() const {
146 ✗ return isEmpty(OS_SteamEquipmentFields::ScheduleName);
147 }
148
149 4 double SteamEquipment_Impl::multiplier() const {
150
1/1
✓ Branch 1 taken 4 times.
4 boost::optional<double> value = getDouble(OS_SteamEquipmentFields::Multiplier, true);
151
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
4 OS_ASSERT(value);
152
1/1
✓ Branch 1 taken 4 times.
8 return value.get();
153 }
154
155 ✗ bool SteamEquipment_Impl::isMultiplierDefaulted() const {
156 ✗ return isEmpty(OS_SteamEquipmentFields::Multiplier);
157 }
158
159 ✗ bool SteamEquipment_Impl::isAbsolute() const {
160 ✗ SteamEquipmentDefinition definition = steamEquipmentDefinition();
161 ✗ if (definition.designLevel()) {
162 ✗ return true;
163 }
164 ✗ return false;
165 ✗ }
166
167 4 std::string SteamEquipment_Impl::endUseSubcategory() const {
168
1/1
✓ Branch 1 taken 4 times.
4 boost::optional<std::string> value = getString(OS_SteamEquipmentFields::EndUseSubcategory, true);
169
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
4 OS_ASSERT(value);
170
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 return value.get();
171 4 }
172
173 4 bool SteamEquipment_Impl::isEndUseSubcategoryDefaulted() const {
174 4 return isEmpty(OS_SteamEquipmentFields::EndUseSubcategory);
175 }
176
177 ✗ bool SteamEquipment_Impl::setSteamEquipmentDefinition(const SteamEquipmentDefinition& definition) {
178 ✗ return setPointer(definitionIndex(), definition.handle());
179 }
180
181 ✗ bool SteamEquipment_Impl::setDefinition(const SpaceLoadDefinition& definition) {
182 ✗ if (OptionalSteamEquipmentDefinition steamEquipmentDefinition = definition.optionalCast<SteamEquipmentDefinition>()) {
183 ✗ return setSteamEquipmentDefinition(*steamEquipmentDefinition);
184 ✗ }
185 ✗ return false;
186 }
187
188 1 bool SteamEquipment_Impl::setSchedule(Schedule& schedule) {
189
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
4 bool result = ModelObject_Impl::setSchedule(OS_SteamEquipmentFields::ScheduleName, "SteamEquipment", "Steam Equipment", schedule);
190 1 return result;
191 }
192
193 ✗ void SteamEquipment_Impl::resetSchedule() {
194 ✗ bool ok = setString(OS_SteamEquipmentFields::ScheduleName, "");
195 ✗ OS_ASSERT(ok);
196 ✗ }
197
198 3 bool SteamEquipment_Impl::setMultiplier(double multiplier) {
199 3 bool result = setDouble(OS_SteamEquipmentFields::Multiplier, multiplier);
200 3 return result;
201 }
202
203 ✗ void SteamEquipment_Impl::resetMultiplier() {
204 ✗ bool result = setString(OS_SteamEquipmentFields::Multiplier, "");
205 ✗ OS_ASSERT(result);
206 ✗ }
207
208 6 bool SteamEquipment_Impl::setEndUseSubcategory(const std::string& endUseSubcategory) {
209 6 bool result = setString(OS_SteamEquipmentFields::EndUseSubcategory, endUseSubcategory);
210
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 OS_ASSERT(result);
211 6 return result;
212 }
213
214 ✗ void SteamEquipment_Impl::resetEndUseSubcategory() {
215 ✗ bool result = setString(OS_SteamEquipmentFields::EndUseSubcategory, "");
216 ✗ OS_ASSERT(result);
217 ✗ }
218
219 ✗ double SteamEquipment_Impl::getDesignLevel(double floorArea, double numPeople) const {
220 ✗ return steamEquipmentDefinition().getDesignLevel(floorArea, numPeople) * multiplier();
221 }
222
223 ✗ double SteamEquipment_Impl::getPowerPerFloorArea(double floorArea, double numPeople) const {
224 ✗ return steamEquipmentDefinition().getPowerPerFloorArea(floorArea, numPeople) * multiplier();
225 }
226
227 ✗ double SteamEquipment_Impl::getPowerPerPerson(double floorArea, double numPeople) const {
228 ✗ return steamEquipmentDefinition().getPowerPerPerson(floorArea, numPeople) * multiplier();
229 }
230
231 18 int SteamEquipment_Impl::spaceIndex() const {
232 18 return OS_SteamEquipmentFields::SpaceorSpaceTypeName;
233 }
234
235 10 int SteamEquipment_Impl::definitionIndex() const {
236 10 return OS_SteamEquipmentFields::SteamEquipmentDefinitionName;
237 }
238
239 ✗ boost::optional<ModelObject> SteamEquipment_Impl::steamEquipmentDefinitionAsModelObject() const {
240 ✗ OptionalModelObject result = steamEquipmentDefinition();
241 ✗ return result;
242 }
243
244 ✗ boost::optional<ModelObject> SteamEquipment_Impl::scheduleAsModelObject() const {
245 ✗ OptionalModelObject result;
246 ✗ OptionalSchedule intermediate = schedule();
247 ✗ if (intermediate) {
248 ✗ result = *intermediate;
249 }
250 ✗ return result;
251 ✗ }
252
253 ✗ bool SteamEquipment_Impl::setSteamEquipmentDefinitionAsModelObject(const boost::optional<ModelObject>& modelObject) {
254 ✗ if (modelObject) {
255 ✗ OptionalSteamEquipmentDefinition intermediate = modelObject->optionalCast<SteamEquipmentDefinition>();
256 ✗ if (intermediate) {
257 ✗ return setSteamEquipmentDefinition(*intermediate);
258 }
259 ✗ }
260 ✗ return false;
261 }
262
263 ✗ bool SteamEquipment_Impl::setScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
264 ✗ if (modelObject) {
265 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
266 ✗ if (intermediate) {
267 ✗ Schedule schedule(*intermediate);
268 ✗ return setSchedule(schedule);
269 ✗ } else {
270 ✗ return false;
271 }
272 ✗ } else {
273 ✗ resetSchedule();
274 }
275 ✗ return true;
276 }
277
278 ✗ std::vector<EMSActuatorNames> SteamEquipment_Impl::emsActuatorNames() const {
279 ✗ std::vector<EMSActuatorNames> actuators{{"SteamEquipment", "District Heating Power Level"}};
280 ✗ return actuators;
281 ✗ }
282
283 ✗ std::vector<std::string> SteamEquipment_Impl::emsInternalVariableNames() const {
284 ✗ std::vector<std::string> types{"Process Steam District Heat Design Level"};
285 ✗ return types;
286 ✗ }
287
288 } // namespace detail
289
290 5 SteamEquipment::SteamEquipment(const SteamEquipmentDefinition& definition) : SpaceLoadInstance(SteamEquipment::iddObjectType(), definition) {
291
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
✗ Branch 5 not taken.
5 OS_ASSERT(getImpl<detail::SteamEquipment_Impl>());
292
293 /*
294 *Schedule sch = this->model().alwaysOnDiscreteSchedule();
295 *bool test = this->setSchedule(sch);
296 *OS_ASSERT(test);
297 *test = this->setMultiplier(1.0);
298 *OS_ASSERT(test);
299 */
300
2/2
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
5 bool test = this->setEndUseSubcategory("General");
301
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
✗ Branch 3 not taken.
5 OS_ASSERT(test);
302 5 }
303
304 10797 IddObjectType SteamEquipment::iddObjectType() {
305
1/1
✓ Branch 1 taken 10797 times.
10797 IddObjectType result(IddObjectType::OS_SteamEquipment);
306 10797 return result;
307 }
308
309 4 SteamEquipmentDefinition SteamEquipment::steamEquipmentDefinition() const {
310
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::SteamEquipment_Impl>()->steamEquipmentDefinition();
311 }
312
313 4 boost::optional<Schedule> SteamEquipment::schedule() const {
314
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::SteamEquipment_Impl>()->schedule();
315 }
316
317 ✗ bool SteamEquipment::isScheduleDefaulted() const {
318 ✗ return getImpl<detail::SteamEquipment_Impl>()->isScheduleDefaulted();
319 }
320
321 4 std::string SteamEquipment::endUseSubcategory() const {
322
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::SteamEquipment_Impl>()->endUseSubcategory();
323 }
324
325 4 bool SteamEquipment::isEndUseSubcategoryDefaulted() const {
326
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::SteamEquipment_Impl>()->isEndUseSubcategoryDefaulted();
327 }
328
329 ✗ bool SteamEquipment::setSteamEquipmentDefinition(const SteamEquipmentDefinition& definition) {
330 ✗ return getImpl<detail::SteamEquipment_Impl>()->setSteamEquipmentDefinition(definition);
331 }
332
333 1 bool SteamEquipment::setSchedule(Schedule& schedule) {
334
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::SteamEquipment_Impl>()->setSchedule(schedule);
335 }
336
337 ✗ void SteamEquipment::resetSchedule() {
338 ✗ getImpl<detail::SteamEquipment_Impl>()->resetSchedule();
339 ✗ }
340
341 3 bool SteamEquipment::setMultiplier(double multiplier) {
342
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::SteamEquipment_Impl>()->setMultiplier(multiplier);
343 }
344
345 ✗ void SteamEquipment::resetMultiplier() {
346 ✗ getImpl<detail::SteamEquipment_Impl>()->resetMultiplier();
347 ✗ }
348
349 6 bool SteamEquipment::setEndUseSubcategory(const std::string& endUseSubcategory) {
350
1/1
✓ Branch 3 taken 6 times.
6 return getImpl<detail::SteamEquipment_Impl>()->setEndUseSubcategory(endUseSubcategory);
351 }
352
353 ✗ void SteamEquipment::resetEndUseSubcategory() {
354 ✗ getImpl<detail::SteamEquipment_Impl>()->resetEndUseSubcategory();
355 ✗ }
356
357 ✗ double SteamEquipment::getDesignLevel(double floorArea, double numPeople) const {
358 ✗ return getImpl<detail::SteamEquipment_Impl>()->getDesignLevel(floorArea, numPeople);
359 }
360
361 ✗ double SteamEquipment::getPowerPerFloorArea(double floorArea, double numPeople) const {
362 ✗ return getImpl<detail::SteamEquipment_Impl>()->getPowerPerFloorArea(floorArea, numPeople);
363 }
364
365 ✗ double SteamEquipment::getPowerPerPerson(double floorArea, double numPeople) const {
366 ✗ return getImpl<detail::SteamEquipment_Impl>()->getPowerPerPerson(floorArea, numPeople);
367 }
368
369 /// @cond
370
1/1
✓ Branch 3 taken 16 times.
16 SteamEquipment::SteamEquipment(std::shared_ptr<detail::SteamEquipment_Impl> impl) : SpaceLoadInstance(std::move(impl)) {}
371 /// @endcond
372
373 } // namespace model
374 } // namespace openstudio
375