GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 17.6% 67 / 0 / 381
Functions: 18.6% 31 / 0 / 167
Branches: 21.6% 8 / 0 / 37

src/airflow/contam/PrjModel.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 "PrjModel.hpp"
7 #include "PrjReader.hpp"
8 #include "SimFile.hpp"
9
10 #include "PrjModelImpl.hpp"
11
12 namespace openstudio {
13 namespace contam {
14
15
2/4
✓ Branch 2 taken 8 times.
✓ Branch 5 taken 8 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
8 IndexModel::IndexModel() : m_impl(std::shared_ptr<detail::IndexModelImpl>(new detail::IndexModelImpl)) {}
16
17 ✗ IndexModel::IndexModel(openstudio::path path) : m_impl(std::shared_ptr<detail::IndexModelImpl>(new detail::IndexModelImpl)) {
18 ✗ m_impl->read(path);
19 ✗ }
20
21 ✗ IndexModel::IndexModel(std::string filename) : m_impl(std::shared_ptr<detail::IndexModelImpl>(new detail::IndexModelImpl)) {
22 ✗ m_impl->read(filename);
23 ✗ }
24
25 ✗ IndexModel::IndexModel(Reader& input) : m_impl(std::shared_ptr<detail::IndexModelImpl>(new detail::IndexModelImpl)) {
26 ✗ m_impl->read(input);
27 ✗ }
28
29 9 IndexModel::IndexModel(const IndexModel& other) = default;
30
31 ✗ IndexModel& IndexModel::operator=(const IndexModel& other) = default;
32
33 ✗ bool IndexModel::operator==(const IndexModel& other) const {
34 ✗ return m_impl == other.m_impl;
35 }
36
37 ✗ bool IndexModel::operator!=(const IndexModel& other) const {
38 ✗ return m_impl != other.m_impl;
39 }
40
41 ✗ bool IndexModel::read(openstudio::path path) {
42 ✗ return m_impl->read(openstudio::toString(path));
43 }
44
45 ✗ bool IndexModel::read(std::string filename) {
46 ✗ return m_impl->read(filename);
47 }
48
49 6 bool IndexModel::read(Reader& input) {
50 6 return m_impl->read(input);
51 }
52
53 1 std::string IndexModel::toString() {
54 1 return m_impl->toString();
55 }
56
57 ✗ std::string IndexModel::programName() const {
58 ✗ return m_impl->programName();
59 }
60
61 ✗ void IndexModel::setProgramName(const std::string& name) {
62 ✗ m_impl->setProgramName(name);
63 ✗ }
64
65 ✗ std::string IndexModel::version() const {
66 ✗ return m_impl->version();
67 }
68
69 ✗ void IndexModel::setVersion(const std::string& version) {
70 ✗ m_impl->setVersion(version);
71 ✗ }
72
73 ✗ int IndexModel::echo() const {
74 ✗ return m_impl->echo();
75 }
76
77 ✗ void IndexModel::setEcho(const int echo) {
78 ✗ m_impl->setEcho(echo);
79 ✗ }
80
81 ✗ std::string IndexModel::desc() const {
82 ✗ return m_impl->desc();
83 }
84
85 6 void IndexModel::setDesc(const std::string& prjdesc) {
86 6 m_impl->setDesc(prjdesc);
87 6 }
88
89 ✗ int IndexModel::skheight() const {
90 ✗ return m_impl->skheight();
91 }
92
93 ✗ void IndexModel::setSkheight(const int skheight) {
94 ✗ m_impl->setSkheight(skheight);
95 ✗ }
96
97 ✗ int IndexModel::skwidth() const {
98 ✗ return m_impl->skwidth();
99 }
100
101 ✗ void IndexModel::setSkwidth(const int skwidth) {
102 ✗ m_impl->setSkwidth(skwidth);
103 ✗ }
104
105 ✗ int IndexModel::def_units() const {
106 ✗ return m_impl->def_units();
107 }
108
109 ✗ void IndexModel::setDef_units(const int def_units) {
110 ✗ m_impl->setDef_units(def_units);
111 ✗ }
112
113 ✗ int IndexModel::def_flows() const {
114 ✗ return m_impl->def_flows();
115 }
116
117 ✗ void IndexModel::setDef_flows(const int def_flows) {
118 ✗ m_impl->setDef_flows(def_flows);
119 ✗ }
120
121 1 double IndexModel::def_T() const {
122 1 return m_impl->def_T();
123 }
124
125 1 bool IndexModel::setDef_T(const double def_T) {
126 1 return m_impl->setDef_T(def_T);
127 }
128
129 2 bool IndexModel::setDef_T(const std::string& def_T) {
130 2 return m_impl->setDef_T(def_T);
131 }
132
133 ✗ int IndexModel::udefT() const {
134 ✗ return m_impl->udefT();
135 }
136
137 ✗ void IndexModel::setUdefT(const int udefT) {
138 ✗ m_impl->setUdefT(udefT);
139 ✗ }
140
141 ✗ double IndexModel::rel_N() const {
142 ✗ return m_impl->rel_N();
143 }
144
145 ✗ bool IndexModel::setRel_N(const double rel_N) {
146 ✗ return m_impl->setRel_N(rel_N);
147 }
148
149 ✗ bool IndexModel::setRel_N(const std::string& rel_N) {
150 ✗ return m_impl->setRel_N(rel_N);
151 }
152
153 36 double IndexModel::wind_H() const {
154 36 return m_impl->wind_H();
155 }
156
157 ✗ bool IndexModel::setWind_H(const double wind_H) {
158 ✗ return m_impl->setWind_H(wind_H);
159 }
160
161 4 bool IndexModel::setWind_H(const std::string& wind_H) {
162 4 return m_impl->setWind_H(wind_H);
163 }
164
165 ✗ int IndexModel::uwH() const {
166 ✗ return m_impl->uwH();
167 }
168
169 ✗ void IndexModel::setUwH(const int uwH) {
170 ✗ m_impl->setUwH(uwH);
171 ✗ }
172
173 ✗ double IndexModel::wind_Ao() const {
174 ✗ return m_impl->wind_Ao();
175 }
176
177 ✗ bool IndexModel::setWind_Ao(const double wind_Ao) {
178 ✗ return m_impl->setWind_Ao(wind_Ao);
179 }
180
181 ✗ bool IndexModel::setWind_Ao(const std::string& wind_Ao) {
182 ✗ return m_impl->setWind_Ao(wind_Ao);
183 }
184
185 ✗ double IndexModel::wind_a() const {
186 ✗ return m_impl->wind_a();
187 }
188
189 ✗ bool IndexModel::setWind_a(const double wind_a) {
190 ✗ return m_impl->setWind_a(wind_a);
191 }
192
193 ✗ bool IndexModel::setWind_a(const std::string& wind_a) {
194 ✗ return m_impl->setWind_a(wind_a);
195 }
196
197 ✗ double IndexModel::scale() const {
198 ✗ return m_impl->scale();
199 }
200
201 ✗ bool IndexModel::setScale(const double scale) {
202 ✗ return m_impl->setScale(scale);
203 }
204
205 ✗ bool IndexModel::setScale(const std::string& scale) {
206 ✗ return m_impl->setScale(scale);
207 }
208
209 ✗ int IndexModel::uScale() const {
210 ✗ return m_impl->uScale();
211 }
212
213 ✗ void IndexModel::setUScale(const int uScale) {
214 ✗ m_impl->setUScale(uScale);
215 ✗ }
216
217 ✗ int IndexModel::orgRow() const {
218 ✗ return m_impl->orgRow();
219 }
220
221 ✗ void IndexModel::setOrgRow(const int orgRow) {
222 ✗ m_impl->setOrgRow(orgRow);
223 ✗ }
224
225 ✗ int IndexModel::orgCol() const {
226 ✗ return m_impl->orgCol();
227 }
228
229 ✗ void IndexModel::setOrgCol(const int orgCol) {
230 ✗ m_impl->setOrgCol(orgCol);
231 ✗ }
232
233 ✗ int IndexModel::invYaxis() const {
234 ✗ return m_impl->invYaxis();
235 }
236
237 ✗ void IndexModel::setInvYaxis(const int invYaxis) {
238 ✗ m_impl->setInvYaxis(invYaxis);
239 ✗ }
240
241 ✗ int IndexModel::showGeom() const {
242 ✗ return m_impl->showGeom();
243 }
244
245 ✗ void IndexModel::setShowGeom(const int showGeom) {
246 ✗ m_impl->setShowGeom(showGeom);
247 ✗ }
248
249 ✗ WeatherData IndexModel::ssWeather() const {
250 ✗ return m_impl->ssWeather();
251 }
252
253 ✗ void IndexModel::setSsWeather(const WeatherData& ssWeather) {
254 ✗ m_impl->setSsWeather(ssWeather);
255 ✗ }
256
257 ✗ WeatherData IndexModel::wptWeather() const {
258 ✗ return m_impl->wptWeather();
259 }
260
261 ✗ void IndexModel::setWptWeather(const WeatherData& wptWeather) {
262 ✗ m_impl->setWptWeather(wptWeather);
263 ✗ }
264
265 ✗ std::string IndexModel::WTHpath() const {
266 ✗ return m_impl->WTHpath();
267 }
268
269 ✗ void IndexModel::setWTHpath(const std::string& WTHpath) {
270 ✗ m_impl->setWTHpath(WTHpath);
271 ✗ }
272
273 ✗ std::string IndexModel::CTMpath() const {
274 ✗ return m_impl->CTMpath();
275 }
276
277 ✗ void IndexModel::setCTMpath(const std::string& CTMpath) {
278 ✗ m_impl->setCTMpath(CTMpath);
279 ✗ }
280
281 ✗ std::string IndexModel::CVFpath() const {
282 ✗ return m_impl->CVFpath();
283 }
284
285 ✗ void IndexModel::setCVFpath(const std::string& CVFpath) {
286 ✗ m_impl->setCVFpath(CVFpath);
287 ✗ }
288
289 ✗ std::string IndexModel::DVFpath() const {
290 ✗ return m_impl->DVFpath();
291 }
292
293 ✗ void IndexModel::setDVFpath(const std::string& DVFpath) {
294 ✗ m_impl->setDVFpath(DVFpath);
295 ✗ }
296
297 ✗ std::string IndexModel::WPCfile() const {
298 ✗ return m_impl->WPCfile();
299 }
300
301 ✗ void IndexModel::setWPCfile(const std::string& WPCfile) {
302 ✗ m_impl->setWPCfile(WPCfile);
303 ✗ }
304
305 ✗ std::string IndexModel::EWCfile() const {
306 ✗ return m_impl->EWCfile();
307 }
308
309 ✗ void IndexModel::setEWCfile(const std::string& EWCfile) {
310 ✗ m_impl->setEWCfile(EWCfile);
311 ✗ }
312
313 ✗ std::string IndexModel::WPCdesc() const {
314 ✗ return m_impl->WPCdesc();
315 }
316
317 ✗ void IndexModel::setWPCdesc(const std::string& WPCdesc) {
318 ✗ m_impl->setWPCdesc(WPCdesc);
319 ✗ }
320
321 ✗ double IndexModel::X0() const {
322 ✗ return m_impl->X0();
323 }
324
325 ✗ bool IndexModel::setX0(const double X0) {
326 ✗ return m_impl->setX0(X0);
327 }
328
329 ✗ bool IndexModel::setX0(const std::string& X0) {
330 ✗ return m_impl->setX0(X0);
331 }
332
333 ✗ double IndexModel::Y0() const {
334 ✗ return m_impl->Y0();
335 }
336
337 ✗ bool IndexModel::setY0(const double Y0) {
338 ✗ return m_impl->setY0(Y0);
339 }
340
341 ✗ bool IndexModel::setY0(const std::string& Y0) {
342 ✗ return m_impl->setY0(Y0);
343 }
344
345 ✗ double IndexModel::Z0() const {
346 ✗ return m_impl->Z0();
347 }
348
349 ✗ bool IndexModel::setZ0(const double Z0) {
350 ✗ return m_impl->setZ0(Z0);
351 }
352
353 ✗ bool IndexModel::setZ0(const std::string& Z0) {
354 ✗ return m_impl->setZ0(Z0);
355 }
356
357 ✗ double IndexModel::angle() const {
358 ✗ return m_impl->angle();
359 }
360
361 ✗ bool IndexModel::setAngle(const double angle) {
362 ✗ return m_impl->setAngle(angle);
363 }
364
365 ✗ bool IndexModel::setAngle(const std::string& angle) {
366 ✗ return m_impl->setAngle(angle);
367 }
368
369 ✗ int IndexModel::u_XYZ() const {
370 ✗ return m_impl->u_XYZ();
371 }
372
373 ✗ void IndexModel::setU_XYZ(const int u_XYZ) {
374 ✗ m_impl->setU_XYZ(u_XYZ);
375 ✗ }
376
377 ✗ double IndexModel::epsPath() const {
378 ✗ return m_impl->epsPath();
379 }
380
381 ✗ bool IndexModel::setEpsPath(const double epsPath) {
382 ✗ return m_impl->setEpsPath(epsPath);
383 }
384
385 ✗ bool IndexModel::setEpsPath(const std::string& epsPath) {
386 ✗ return m_impl->setEpsPath(epsPath);
387 }
388
389 ✗ double IndexModel::epsSpcs() const {
390 ✗ return m_impl->epsSpcs();
391 }
392
393 ✗ bool IndexModel::setEpsSpcs(const double epsSpcs) {
394 ✗ return m_impl->setEpsSpcs(epsSpcs);
395 }
396
397 ✗ bool IndexModel::setEpsSpcs(const std::string& epsSpcs) {
398 ✗ return m_impl->setEpsSpcs(epsSpcs);
399 }
400
401 ✗ std::string IndexModel::tShift() const {
402 ✗ return m_impl->tShift();
403 }
404
405 ✗ void IndexModel::setTShift(const std::string& tShift) {
406 ✗ m_impl->setTShift(tShift);
407 ✗ }
408
409 ✗ std::string IndexModel::dStart() const {
410 ✗ return m_impl->dStart();
411 }
412
413 ✗ void IndexModel::setDStart(const std::string& dStart) {
414 ✗ m_impl->setDStart(dStart);
415 ✗ }
416
417 ✗ std::string IndexModel::dEnd() const {
418 ✗ return m_impl->dEnd();
419 }
420
421 ✗ void IndexModel::setDEnd(const std::string& dEnd) {
422 ✗ m_impl->setDEnd(dEnd);
423 ✗ }
424
425 ✗ int IndexModel::useWPCwp() const {
426 ✗ return m_impl->useWPCwp();
427 }
428
429 ✗ void IndexModel::setUseWPCwp(const int useWPCwp) {
430 ✗ m_impl->setUseWPCwp(useWPCwp);
431 ✗ }
432
433 ✗ int IndexModel::useWPCmf() const {
434 ✗ return m_impl->useWPCmf();
435 }
436
437 ✗ void IndexModel::setUseWPCmf(const int useWPCmf) {
438 ✗ m_impl->setUseWPCmf(useWPCmf);
439 ✗ }
440
441 ✗ int IndexModel::wpctrig() const {
442 ✗ return m_impl->wpctrig();
443 }
444
445 ✗ void IndexModel::setWpctrig(const int wpctrig) {
446 ✗ m_impl->setWpctrig(wpctrig);
447 ✗ }
448
449 ✗ double IndexModel::latd() const {
450 ✗ return m_impl->latd();
451 }
452
453 ✗ bool IndexModel::setLatd(const double latd) {
454 ✗ return m_impl->setLatd(latd);
455 }
456
457 ✗ bool IndexModel::setLatd(const std::string& latd) {
458 ✗ return m_impl->setLatd(latd);
459 }
460
461 ✗ double IndexModel::lgtd() const {
462 ✗ return m_impl->lgtd();
463 }
464
465 ✗ bool IndexModel::setLgtd(const double lgtd) {
466 ✗ return m_impl->setLgtd(lgtd);
467 }
468
469 ✗ bool IndexModel::setLgtd(const std::string& lgtd) {
470 ✗ return m_impl->setLgtd(lgtd);
471 }
472
473 ✗ double IndexModel::Tznr() const {
474 ✗ return m_impl->Tznr();
475 }
476
477 ✗ bool IndexModel::setTznr(const double Tznr) {
478 ✗ return m_impl->setTznr(Tznr);
479 }
480
481 ✗ bool IndexModel::setTznr(const std::string& Tznr) {
482 ✗ return m_impl->setTznr(Tznr);
483 }
484
485 ✗ double IndexModel::altd() const {
486 ✗ return m_impl->altd();
487 }
488
489 ✗ bool IndexModel::setAltd(const double altd) {
490 ✗ return m_impl->setAltd(altd);
491 }
492
493 ✗ bool IndexModel::setAltd(const std::string& altd) {
494 ✗ return m_impl->setAltd(altd);
495 }
496
497 ✗ double IndexModel::Tgrnd() const {
498 ✗ return m_impl->Tgrnd();
499 }
500
501 ✗ bool IndexModel::setTgrnd(const double Tgrnd) {
502 ✗ return m_impl->setTgrnd(Tgrnd);
503 }
504
505 ✗ bool IndexModel::setTgrnd(const std::string& Tgrnd) {
506 ✗ return m_impl->setTgrnd(Tgrnd);
507 }
508
509 ✗ int IndexModel::utg() const {
510 ✗ return m_impl->utg();
511 }
512
513 ✗ void IndexModel::setUtg(const int utg) {
514 ✗ m_impl->setUtg(utg);
515 ✗ }
516
517 ✗ int IndexModel::u_a() const {
518 ✗ return m_impl->u_a();
519 }
520
521 ✗ void IndexModel::setU_a(const int u_a) {
522 ✗ m_impl->setU_a(u_a);
523 ✗ }
524
525 5 RunControl IndexModel::rc() const {
526 5 return m_impl->rc();
527 }
528 ✗ void IndexModel::setRc(const RunControl& rc) {
529 ✗ m_impl->setRc(rc);
530 ✗ }
531
532 6 std::vector<int> IndexModel::contaminants() const {
533 6 return m_impl->contaminants();
534 }
535
536 7 std::vector<Species> IndexModel::species() const {
537 7 return m_impl->species();
538 }
539 ✗ void IndexModel::setSpecies(const std::vector<Species>& species) {
540 ✗ m_impl->setSpecies(species);
541 ✗ }
542 2 void IndexModel::addSpecies(Species& species) {
543 2 m_impl->addSpecies(species);
544 2 }
545 4 bool IndexModel::removeSpecies(const Species& species) {
546 4 return m_impl->removeSpecies(species);
547 }
548
549 58 std::vector<Level> IndexModel::levels() const {
550 58 return m_impl->levels();
551 }
552 6 void IndexModel::setLevels(const std::vector<Level>& levels) {
553 6 m_impl->setLevels(levels);
554 6 }
555 6 void IndexModel::addLevel(Level& level) {
556 6 m_impl->addLevel(level);
557 6 }
558
559 ✗ std::vector<DaySchedule> IndexModel::daySchedules() const {
560 ✗ return m_impl->daySchedules();
561 }
562 ✗ void IndexModel::setDaySchedules(const std::vector<DaySchedule>& daySchedules) {
563 ✗ m_impl->setDaySchedules(daySchedules);
564 ✗ }
565
566 ✗ std::vector<WeekSchedule> IndexModel::weekSchedules() const {
567 ✗ return m_impl->weekSchedules();
568 }
569 ✗ void IndexModel::setWeekSchedules(const std::vector<WeekSchedule>& weekSchedules) {
570 ✗ m_impl->setWeekSchedules(weekSchedules);
571 ✗ }
572
573 ✗ std::vector<WindPressureProfile> IndexModel::windPressureProfiles() const {
574 ✗ return m_impl->windPressureProfiles();
575 }
576 ✗ void IndexModel::setWindPressureProfiles(const std::vector<WindPressureProfile>& windPressureProfiles) {
577 ✗ m_impl->setWindPressureProfiles(windPressureProfiles);
578 ✗ }
579
580 4 std::vector<PlrTest1> IndexModel::getPlrTest1() const {
581 4 return m_impl->getAirflowElements<PlrTest1>();
582 }
583
584 ✗ std::vector<PlrTest2> IndexModel::getPlrTest2() const {
585 ✗ return m_impl->getAirflowElements<PlrTest2>();
586 }
587
588 2 std::vector<PlrLeak2> IndexModel::getPlrLeak2() const {
589 2 return m_impl->getAirflowElements<PlrLeak2>();
590 }
591
592 2 bool IndexModel::addAirflowElement(PlrTest1 element) {
593
2/2
✓ Branch 2 taken 2 times.
✓ Branch 5 taken 2 times.
2 return m_impl->addAirflowElement(element);
594 }
595
596 1 bool IndexModel::addAirflowElement(PlrLeak2 element) {
597
2/2
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
1 return m_impl->addAirflowElement(element);
598 }
599
600 24 int IndexModel::airflowElementNrByName(std::string name) const {
601
2/2
✓ Branch 2 taken 24 times.
✓ Branch 5 taken 24 times.
24 return m_impl->airflowElementNrByName(name);
602 }
603
604 ✗ bool IndexModel::replaceAirflowElement(int nr, PlrTest1 element) {
605 ✗ return m_impl->replaceAirflowElement(nr, element);
606 }
607
608 ✗ std::vector<CvfDat> IndexModel::getCvfDat() const {
609 ✗ return m_impl->getControlNodes<CvfDat>();
610 }
611
612 ✗ bool IndexModel::addControlNode(CvfDat element, bool sequence) {
613 ✗ return m_impl->addControlNode(element, sequence);
614 }
615
616 30 std::vector<Ahs> IndexModel::ahs() const {
617 30 return m_impl->ahs();
618 }
619 ✗ void IndexModel::setAhs(const std::vector<Ahs>& ahs) {
620 ✗ m_impl->setAhs(ahs);
621 ✗ }
622 3 void IndexModel::addAhs(Ahs ahs) {
623 3 m_impl->addAhs(ahs);
624 3 }
625
626 60 std::vector<Zone> IndexModel::zones() const {
627 60 return m_impl->zones();
628 }
629 ✗ void IndexModel::setZones(const std::vector<Zone>& zones) {
630 ✗ m_impl->setZones(zones);
631 ✗ }
632 18 void IndexModel::addZone(Zone zone) {
633 18 m_impl->addZone(zone);
634 18 }
635
636 26 std::vector<AirflowPath> IndexModel::airflowPaths() const {
637 26 return m_impl->airflowPaths();
638 }
639 ✗ void IndexModel::setAirflowPaths(const std::vector<AirflowPath>& paths) {
640 ✗ m_impl->setAirflowPaths(paths);
641 ✗ }
642 69 void IndexModel::addAirflowPath(AirflowPath path) {
643 69 m_impl->addAirflowPath(path);
644 69 }
645
646 6 bool IndexModel::valid() const {
647 6 return m_impl->valid();
648 }
649
650 1 std::vector<std::vector<int>> IndexModel::zoneExteriorFlowPaths() {
651 1 return m_impl->zoneExteriorFlowPaths();
652 }
653
654 ✗ std::vector<TimeSeries> IndexModel::zoneInfiltration(SimFile* sim) {
655 ✗ return m_impl->zoneInfiltration(sim);
656 }
657
658 ✗ std::vector<TimeSeries> IndexModel::pathInfiltration(std::vector<int> pathNrs, SimFile* sim) {
659 ✗ return m_impl->pathInfiltration(pathNrs, sim);
660 }
661
662 } // namespace contam
663 } // namespace openstudio
664