GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 17.1% 259 / 0 / 1517
Functions: 17.2% 108 / 0 / 628
Branches: 13.8% 48 / 0 / 349

src/airflow/contam/PrjObjects.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 "PrjObjects.hpp"
7
8 #include "../../utilities/core/Logger.hpp"
9
10 namespace openstudio {
11 namespace contam {
12
13
2/4
✓ Branch 2 taken 15 times.
✓ Branch 5 taken 15 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
15 Zone::Zone() : m_impl(std::shared_ptr<detail::ZoneImpl>(new detail::ZoneImpl())) {}
14
15
2/4
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
1 Zone::Zone(unsigned flags, std::string Vol, std::string T0, std::string name) : m_impl(std::shared_ptr<detail::ZoneImpl>(new detail::ZoneImpl)) {
16
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setFlags(flags);
17
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setVol(Vol);
18
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setT0(T0);
19
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setName(name);
20 1 }
21
22
2/4
✓ Branch 2 taken 2 times.
✓ Branch 5 taken 2 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
2 Zone::Zone(unsigned flags, double Vol, double T0, std::string name) : m_impl(std::shared_ptr<detail::ZoneImpl>(new detail::ZoneImpl)) {
23
1/1
✓ Branch 2 taken 2 times.
2 m_impl->setFlags(flags);
24
1/1
✓ Branch 2 taken 2 times.
2 m_impl->setVol(Vol);
25
1/1
✓ Branch 2 taken 2 times.
2 m_impl->setT0(T0);
26
1/1
✓ Branch 2 taken 2 times.
2 m_impl->setName(name);
27 2 }
28
29 ✗ Zone::Zone(int nr, unsigned int flags, int ps, int pc, int pk, int pl, std::string relHt, std::string Vol, std::string T0, std::string P0,
30 std::string name, int color, int u_Ht, int u_V, int u_T, int u_P, int cdaxis, int cfd, std::string cfdname, std::string X1,
31 std::string Y1, std::string H1, std::string X2, std::string Y2, std::string H2, std::string celldx, std::string axialD, int u_aD,
32 ✗ int u_L)
33 ✗ : m_impl(std::shared_ptr<detail::ZoneImpl>(new detail::ZoneImpl(nr, flags, ps, pc, pk, pl, relHt, Vol, T0, P0, name, color, u_Ht, u_V, u_T, u_P,
34 ✗ cdaxis, cfd, cfdname, X1, Y1, H1, X2, Y2, H2, celldx, axialD, u_aD, u_L))) {}
35
36 ✗ Zone::Zone(int nr, unsigned int flags, int ps, int pc, int pk, int pl, double relHt, double Vol, double T0, double P0, std::string name, int color,
37 int u_Ht, int u_V, int u_T, int u_P, int cdaxis, int cfd, std::string cfdname, double X1, double Y1, double H1, double X2, double Y2,
38 ✗ double H2, double celldx, double axialD, int u_aD, int u_L)
39 ✗ : m_impl(std::shared_ptr<detail::ZoneImpl>(new detail::ZoneImpl(nr, flags, ps, pc, pk, pl, relHt, Vol, T0, P0, name, color, u_Ht, u_V, u_T, u_P,
40 ✗ cdaxis, cfd, cfdname, X1, Y1, H1, X2, Y2, H2, celldx, axialD, u_aD, u_L))) {}
41
42 310 Zone::Zone(const Zone& other) = default;
43
44 ✗ Zone& Zone::operator=(const Zone& other) = default;
45
46 3 bool Zone::operator==(const Zone& other) const {
47 3 return m_impl == other.m_impl;
48 }
49
50 ✗ bool Zone::operator!=(const Zone& other) const {
51 ✗ return m_impl != other.m_impl;
52 }
53
54 55 int Zone::nr() const {
55 55 return m_impl->nr();
56 }
57
58 33 void Zone::setNr(const int nr) {
59 33 m_impl->setNr(nr);
60 33 }
61
62 ✗ unsigned int Zone::flags() const {
63 ✗ return m_impl->flags();
64 }
65
66 ✗ void Zone::setFlags(const unsigned int flags) {
67 ✗ m_impl->setFlags(flags);
68 ✗ }
69
70 ✗ int Zone::ps() const {
71 ✗ return m_impl->ps();
72 }
73
74 ✗ void Zone::setPs(const int ps) {
75 ✗ m_impl->setPs(ps);
76 ✗ }
77
78 ✗ int Zone::pc() const {
79 ✗ return m_impl->pc();
80 }
81
82 ✗ void Zone::setPc(const int pc) {
83 ✗ m_impl->setPc(pc);
84 ✗ }
85
86 ✗ int Zone::pk() const {
87 ✗ return m_impl->pk();
88 }
89
90 ✗ void Zone::setPk(const int pk) {
91 ✗ m_impl->setPk(pk);
92 ✗ }
93
94 92 int Zone::pl() const {
95 92 return m_impl->pl();
96 }
97
98 15 void Zone::setPl(const int pl) {
99 15 m_impl->setPl(pl);
100 15 }
101
102 ✗ double Zone::relHt() const {
103 ✗ return m_impl->relHt();
104 }
105
106 ✗ bool Zone::setRelHt(const double relHt) {
107 ✗ return m_impl->setRelHt(relHt);
108 }
109
110 ✗ bool Zone::setRelHt(const std::string& relHt) {
111 ✗ return m_impl->setRelHt(relHt);
112 }
113
114 ✗ double Zone::Vol() const {
115 ✗ return m_impl->Vol();
116 }
117
118 ✗ bool Zone::setVol(const double Vol) {
119 ✗ return m_impl->setVol(Vol);
120 }
121
122 9 bool Zone::setVol(const std::string& Vol) {
123 9 return m_impl->setVol(Vol);
124 }
125
126 ✗ double Zone::T0() const {
127 ✗ return m_impl->T0();
128 }
129
130 ✗ bool Zone::setT0(const double T0) {
131 ✗ return m_impl->setT0(T0);
132 }
133
134 15 bool Zone::setT0(const std::string& T0) {
135 15 return m_impl->setT0(T0);
136 }
137
138 ✗ double Zone::P0() const {
139 ✗ return m_impl->P0();
140 }
141
142 ✗ bool Zone::setP0(const double P0) {
143 ✗ return m_impl->setP0(P0);
144 }
145
146 ✗ bool Zone::setP0(const std::string& P0) {
147 ✗ return m_impl->setP0(P0);
148 }
149
150 ✗ std::string Zone::name() const {
151 ✗ return m_impl->name();
152 }
153
154 15 void Zone::setName(const std::string& name) {
155 15 m_impl->setName(name);
156 15 }
157
158 ✗ int Zone::color() const {
159 ✗ return m_impl->color();
160 }
161
162 ✗ void Zone::setColor(const int color) {
163 ✗ m_impl->setColor(color);
164 ✗ }
165
166 ✗ int Zone::u_Ht() const {
167 ✗ return m_impl->u_Ht();
168 }
169
170 ✗ void Zone::setU_Ht(const int u_Ht) {
171 ✗ m_impl->setU_Ht(u_Ht);
172 ✗ }
173
174 ✗ int Zone::u_V() const {
175 ✗ return m_impl->u_V();
176 }
177
178 ✗ void Zone::setU_V(const int u_V) {
179 ✗ m_impl->setU_V(u_V);
180 ✗ }
181
182 ✗ int Zone::u_T() const {
183 ✗ return m_impl->u_T();
184 }
185
186 ✗ void Zone::setU_T(const int u_T) {
187 ✗ m_impl->setU_T(u_T);
188 ✗ }
189
190 ✗ int Zone::u_P() const {
191 ✗ return m_impl->u_P();
192 }
193
194 ✗ void Zone::setU_P(const int u_P) {
195 ✗ m_impl->setU_P(u_P);
196 ✗ }
197
198 ✗ int Zone::cdaxis() const {
199 ✗ return m_impl->cdaxis();
200 }
201
202 ✗ void Zone::setCdaxis(const int cdaxis) {
203 ✗ m_impl->setCdaxis(cdaxis);
204 ✗ }
205
206 ✗ int Zone::cfd() const {
207 ✗ return m_impl->cfd();
208 }
209
210 ✗ void Zone::setCfd(const int cfd) {
211 ✗ m_impl->setCfd(cfd);
212 ✗ }
213
214 ✗ std::string Zone::cfdname() const {
215 ✗ return m_impl->cfdname();
216 }
217
218 ✗ void Zone::setCfdname(const std::string& cfdname) {
219 ✗ m_impl->setCfdname(cfdname);
220 ✗ }
221
222 ✗ double Zone::X1() const {
223 ✗ return m_impl->X1();
224 }
225
226 ✗ bool Zone::setX1(const double X1) {
227 ✗ return m_impl->setX1(X1);
228 }
229
230 ✗ bool Zone::setX1(const std::string& X1) {
231 ✗ return m_impl->setX1(X1);
232 }
233
234 ✗ double Zone::Y1() const {
235 ✗ return m_impl->Y1();
236 }
237
238 ✗ bool Zone::setY1(const double Y1) {
239 ✗ return m_impl->setY1(Y1);
240 }
241
242 ✗ bool Zone::setY1(const std::string& Y1) {
243 ✗ return m_impl->setY1(Y1);
244 }
245
246 ✗ double Zone::H1() const {
247 ✗ return m_impl->H1();
248 }
249
250 ✗ bool Zone::setH1(const double H1) {
251 ✗ return m_impl->setH1(H1);
252 }
253
254 ✗ bool Zone::setH1(const std::string& H1) {
255 ✗ return m_impl->setH1(H1);
256 }
257
258 ✗ double Zone::X2() const {
259 ✗ return m_impl->X2();
260 }
261
262 ✗ bool Zone::setX2(const double X2) {
263 ✗ return m_impl->setX2(X2);
264 }
265
266 ✗ bool Zone::setX2(const std::string& X2) {
267 ✗ return m_impl->setX2(X2);
268 }
269
270 ✗ double Zone::Y2() const {
271 ✗ return m_impl->Y2();
272 }
273
274 ✗ bool Zone::setY2(const double Y2) {
275 ✗ return m_impl->setY2(Y2);
276 }
277
278 ✗ bool Zone::setY2(const std::string& Y2) {
279 ✗ return m_impl->setY2(Y2);
280 }
281
282 ✗ double Zone::H2() const {
283 ✗ return m_impl->H2();
284 }
285
286 ✗ bool Zone::setH2(const double H2) {
287 ✗ return m_impl->setH2(H2);
288 }
289
290 ✗ bool Zone::setH2(const std::string& H2) {
291 ✗ return m_impl->setH2(H2);
292 }
293
294 ✗ double Zone::celldx() const {
295 ✗ return m_impl->celldx();
296 }
297
298 ✗ bool Zone::setCelldx(const double celldx) {
299 ✗ return m_impl->setCelldx(celldx);
300 }
301
302 ✗ bool Zone::setCelldx(const std::string& celldx) {
303 ✗ return m_impl->setCelldx(celldx);
304 }
305
306 ✗ double Zone::axialD() const {
307 ✗ return m_impl->axialD();
308 }
309
310 ✗ bool Zone::setAxialD(const double axialD) {
311 ✗ return m_impl->setAxialD(axialD);
312 }
313
314 ✗ bool Zone::setAxialD(const std::string& axialD) {
315 ✗ return m_impl->setAxialD(axialD);
316 }
317
318 ✗ int Zone::u_aD() const {
319 ✗ return m_impl->u_aD();
320 }
321
322 ✗ void Zone::setU_aD(const int u_aD) {
323 ✗ return m_impl->setU_aD(u_aD);
324 }
325
326 ✗ int Zone::u_L() const {
327 ✗ return m_impl->u_L();
328 }
329
330 ✗ void Zone::setU_L(const int u_L) {
331 ✗ return m_impl->setU_L(u_L);
332 }
333
334 3 std::string Zone::write() {
335 3 return m_impl->write();
336 }
337
338 ✗ void Zone::read(Reader& input) {
339 ✗ m_impl->read(input);
340 ✗ }
341
342 9 void Zone::setVariablePressure(bool b) {
343 9 m_impl->setVariablePressure(b);
344 9 }
345
346 6 bool Zone::variablePressure() const {
347 6 return m_impl->variablePressure();
348 }
349
350 15 void Zone::setVariableContaminants(bool b) {
351 15 m_impl->setVariableContaminants(b);
352 15 }
353
354 6 bool Zone::variableContaminants() const {
355 6 return m_impl->variableContaminants();
356 }
357
358 6 void Zone::setSystem(bool b) {
359 6 m_impl->setSystem(b);
360 6 }
361
362 7 bool Zone::system() const {
363 7 return m_impl->system();
364 }
365
366 ✗ double Zone::ic(const int i) const {
367 ✗ return m_impl->ic(i);
368 }
369
370 ✗ std::vector<double> Zone::ic() const {
371 ✗ return m_impl->ic();
372 }
373
374 ✗ bool Zone::setIc(const int i, const double value) {
375 ✗ return m_impl->setIc(i, value);
376 }
377
378 ✗ bool Zone::setIc(const int i, const std::string& value) {
379 ✗ return m_impl->setIc(i, value);
380 }
381
382 ✗ bool Zone::setIc(std::vector<double>& ic) {
383 ✗ return m_impl->setIc(ic);
384 }
385
386 ✗ bool Zone::setIc(std::vector<std::string>& ic) {
387 ✗ return m_impl->setIc(ic);
388 }
389
390
2/4
✓ Branch 2 taken 12 times.
✓ Branch 5 taken 12 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
12 Species::Species() : m_impl(std::shared_ptr<detail::SpeciesImpl>(new detail::SpeciesImpl)) {}
391
392 1 Species::Species(std::string molwt, std::string Dm, std::string ccdef, std::string /*Cp*/, std::string name, std::string desc)
393
2/4
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
1 : m_impl(std::shared_ptr<detail::SpeciesImpl>(new detail::SpeciesImpl)) {
394
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setMolwt(molwt);
395
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setDm(Dm);
396
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setCcdef(ccdef);
397
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setName(name);
398
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setDesc(desc);
399 1 }
400
401 1 Species::Species(double molwt, double Dm, double ccdef, double /*Cp*/, std::string name, std::string desc)
402
2/4
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
1 : m_impl(std::shared_ptr<detail::SpeciesImpl>(new detail::SpeciesImpl)) {
403
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setMolwt(molwt);
404
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setDm(Dm);
405
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setCcdef(ccdef);
406
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setName(name);
407
1/1
✓ Branch 2 taken 1 time.
1 m_impl->setDesc(desc);
408 1 }
409
410 ✗ Species::Species(int nr, int sflag, int ntflag, std::string molwt, std::string mdiam, std::string edens, std::string decay, std::string Dm,
411 ✗ std::string ccdef, std::string Cp, int ucc, int umd, int ued, int udm, int ucp, std::string name, std::string desc)
412 ✗ : m_impl(std::shared_ptr<detail::SpeciesImpl>(
413 ✗ new detail::SpeciesImpl(nr, sflag, ntflag, molwt, mdiam, edens, decay, Dm, ccdef, Cp, ucc, umd, ued, udm, ucp, name, desc))) {}
414
415 ✗ Species::Species(int nr, int sflag, int ntflag, double molwt, double mdiam, double edens, double decay, double Dm, double ccdef, double Cp, int ucc,
416 ✗ int umd, int ued, int udm, int ucp, std::string name, std::string desc)
417 ✗ : m_impl(std::shared_ptr<detail::SpeciesImpl>(
418 ✗ new detail::SpeciesImpl(nr, sflag, ntflag, molwt, mdiam, edens, decay, Dm, ccdef, Cp, ucc, umd, ued, udm, ucp, name, desc))) {}
419
420 35 Species::Species(const Species& other) = default;
421
422 1 Species& Species::operator=(const Species& other) = default;
423
424 7 bool Species::operator==(const Species& other) const {
425 7 return m_impl == other.m_impl;
426 }
427
428 ✗ bool Species::operator!=(const Species& other) const {
429 ✗ return m_impl != other.m_impl;
430 }
431
432 2 std::string Species::write() {
433 2 return m_impl->write();
434 }
435
436 12 void Species::read(Reader& input) {
437 12 m_impl->read(input);
438 12 }
439
440 3 int Species::nr() const {
441 3 return m_impl->nr();
442 }
443
444 14 void Species::setNr(const int nr) {
445 14 m_impl->setNr(nr);
446 14 }
447
448 11 bool Species::sflag() const {
449 11 return m_impl->sflag();
450 }
451
452 1 void Species::setSflag(const bool sflag) {
453 1 m_impl->setSflag(sflag);
454 1 }
455
456 ✗ bool Species::ntflag() const {
457 ✗ return m_impl->ntflag();
458 }
459
460 ✗ void Species::setNtflag(const bool ntflag) {
461 ✗ m_impl->setNtflag(ntflag);
462 ✗ }
463
464 ✗ double Species::molwt() const {
465 ✗ return m_impl->molwt();
466 }
467
468 ✗ bool Species::setMolwt(const double molwt) {
469 ✗ return m_impl->setMolwt(molwt);
470 }
471
472 ✗ bool Species::setMolwt(const std::string& molwt) {
473 ✗ return m_impl->setMolwt(molwt);
474 }
475
476 ✗ double Species::mdiam() const {
477 ✗ return m_impl->mdiam();
478 }
479
480 ✗ bool Species::setMdiam(const double mdiam) {
481 ✗ return m_impl->setMdiam(mdiam);
482 }
483
484 ✗ bool Species::setMdiam(const std::string& mdiam) {
485 ✗ return m_impl->setMdiam(mdiam);
486 }
487
488 ✗ double Species::edens() const {
489 ✗ return m_impl->edens();
490 }
491
492 ✗ bool Species::setEdens(const double edens) {
493 ✗ return m_impl->setEdens(edens);
494 }
495
496 ✗ bool Species::setEdens(const std::string& edens) {
497 ✗ return m_impl->setEdens(edens);
498 }
499
500 ✗ double Species::decay() const {
501 ✗ return m_impl->decay();
502 }
503
504 ✗ bool Species::setDecay(const double decay) {
505 ✗ return m_impl->setDecay(decay);
506 }
507
508 ✗ bool Species::setDecay(const std::string& decay) {
509 ✗ return m_impl->setDecay(decay);
510 }
511
512 ✗ double Species::Dm() const {
513 ✗ return m_impl->Dm();
514 }
515
516 ✗ bool Species::setDm(const double Dm) {
517 ✗ return m_impl->setDm(Dm);
518 }
519
520 ✗ bool Species::setDm(const std::string& Dm) {
521 ✗ return m_impl->setDm(Dm);
522 }
523
524 ✗ double Species::ccdef() const {
525 ✗ return m_impl->ccdef();
526 }
527
528 ✗ bool Species::setCcdef(const double ccdef) {
529 ✗ return m_impl->setCcdef(ccdef);
530 }
531
532 ✗ bool Species::setCcdef(const std::string& ccdef) {
533 ✗ return m_impl->setCcdef(ccdef);
534 }
535
536 ✗ double Species::Cp() const {
537 ✗ return m_impl->Cp();
538 }
539
540 ✗ bool Species::setCp(const double Cp) {
541 ✗ return m_impl->setCp(Cp);
542 }
543
544 ✗ bool Species::setCp(const std::string& Cp) {
545 ✗ return m_impl->setCp(Cp);
546 }
547
548 ✗ int Species::ucc() const {
549 ✗ return m_impl->ucc();
550 }
551
552 ✗ void Species::setUcc(const int ucc) {
553 ✗ m_impl->setUcc(ucc);
554 ✗ }
555
556 ✗ int Species::umd() const {
557 ✗ return m_impl->umd();
558 }
559
560 ✗ void Species::setUmd(const int umd) {
561 ✗ m_impl->setUmd(umd);
562 ✗ }
563
564 ✗ int Species::ued() const {
565 ✗ return m_impl->ued();
566 }
567
568 ✗ void Species::setUed(const int ued) {
569 ✗ m_impl->setUed(ued);
570 ✗ }
571
572 ✗ int Species::udm() const {
573 ✗ return m_impl->udm();
574 }
575
576 ✗ void Species::setUdm(const int udm) {
577 ✗ m_impl->setUdm(udm);
578 ✗ }
579
580 ✗ int Species::ucp() const {
581 ✗ return m_impl->ucp();
582 }
583
584 ✗ void Species::setUcp(const int ucp) {
585 ✗ m_impl->setUcp(ucp);
586 ✗ }
587
588 ✗ std::string Species::name() const {
589 ✗ return m_impl->name();
590 }
591
592 ✗ void Species::setName(const std::string& name) {
593 ✗ m_impl->setName(name);
594 ✗ }
595
596 ✗ std::string Species::desc() const {
597 ✗ return m_impl->desc();
598 }
599
600 ✗ void Species::setDesc(const std::string& desc) {
601 ✗ m_impl->setDesc(desc);
602 ✗ }
603
604
2/4
✓ Branch 2 taken 3 times.
✓ Branch 5 taken 3 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
3 Ahs::Ahs() : m_impl(std::shared_ptr<detail::AhsImpl>(new detail::AhsImpl)) {}
605
606 ✗ Ahs::Ahs(int nr, int zone_r, int zone_s, int path_r, int path_s, int path_x, std::string name, std::string desc)
607 ✗ : m_impl(std::shared_ptr<detail::AhsImpl>(new detail::AhsImpl(nr, zone_r, zone_s, path_r, path_s, path_x, name, desc))) {}
608
609 37 Ahs::Ahs(const Ahs& other) = default;
610
611 ✗ Ahs& Ahs::operator=(const Ahs& other) = default;
612
613 ✗ bool Ahs::operator==(const Ahs& other) const {
614 ✗ return m_impl == other.m_impl;
615 }
616
617 ✗ bool Ahs::operator!=(const Ahs& other) const {
618 ✗ return m_impl != other.m_impl;
619 }
620
621 1 std::string Ahs::write() {
622 1 return m_impl->write();
623 }
624
625 ✗ void Ahs::read(Reader& input) {
626 ✗ m_impl->read(input);
627 ✗ }
628
629 14 int Ahs::nr() const {
630 14 return m_impl->nr();
631 }
632
633 6 void Ahs::setNr(const int nr) {
634 6 m_impl->setNr(nr);
635 6 }
636
637 13 int Ahs::zone_r() const {
638 13 return m_impl->zone_r();
639 }
640
641 3 void Ahs::setZone_r(const int zone_r) {
642 3 m_impl->setZone_r(zone_r);
643 3 }
644
645 13 int Ahs::zone_s() const {
646 13 return m_impl->zone_s();
647 }
648
649 3 void Ahs::setZone_s(const int zone_s) {
650 3 m_impl->setZone_s(zone_s);
651 3 }
652
653 ✗ int Ahs::path_r() const {
654 ✗ return m_impl->path_r();
655 }
656
657 3 void Ahs::setPath_r(const int path_r) {
658 3 m_impl->setPath_r(path_r);
659 3 }
660
661 ✗ int Ahs::path_s() const {
662 ✗ return m_impl->path_s();
663 }
664
665 3 void Ahs::setPath_s(const int path_s) {
666 3 m_impl->setPath_s(path_s);
667 3 }
668
669 ✗ int Ahs::path_x() const {
670 ✗ return m_impl->path_x();
671 }
672
673 3 void Ahs::setPath_x(const int path_x) {
674 3 m_impl->setPath_x(path_x);
675 3 }
676
677 ✗ std::string Ahs::name() const {
678 ✗ return m_impl->name();
679 }
680
681 3 void Ahs::setName(const std::string& name) {
682 3 m_impl->setName(name);
683 3 }
684
685 ✗ std::string Ahs::desc() const {
686 ✗ return m_impl->desc();
687 }
688
689 ✗ void Ahs::setDesc(const std::string& desc) {
690 ✗ m_impl->setDesc(desc);
691 ✗ }
692
693
2/4
✓ Branch 2 taken 69 times.
✓ Branch 5 taken 69 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
69 AirflowPath::AirflowPath() : m_impl(std::shared_ptr<detail::AirflowPathImpl>(new detail::AirflowPathImpl)) {}
694
695 ✗ AirflowPath::AirflowPath(int flags, int pzn, int pe, int pw, int pld, std::string relHt, std::string mult, std::string wPset, std::string wPmod,
696 ✗ std::string wazm, unsigned int icon)
697 ✗ : m_impl(std::shared_ptr<detail::AirflowPathImpl>(new detail::AirflowPathImpl)) {
698 ✗ m_impl->setFlags(flags);
699 ✗ m_impl->setPzn(pzn);
700 ✗ m_impl->setPzm(-1);
701 ✗ m_impl->setPe(pe);
702 ✗ m_impl->setPw(pw);
703 ✗ m_impl->setPld(pld);
704 ✗ m_impl->setRelHt(relHt);
705 ✗ m_impl->setMult(mult);
706 ✗ m_impl->setWPset(wPset);
707 ✗ m_impl->setWPmod(wPmod);
708 ✗ m_impl->setWazm(wazm);
709 ✗ m_impl->setIcon(icon);
710 ✗ }
711
712 ✗ AirflowPath::AirflowPath(int flags, int pzn, int pe, int pw, int pld, double relHt, double mult, double wPset, double wPmod, double wazm,
713 ✗ unsigned int icon)
714 ✗ : m_impl(std::shared_ptr<detail::AirflowPathImpl>(new detail::AirflowPathImpl)) {
715 ✗ m_impl->setFlags(flags);
716 ✗ m_impl->setPzn(pzn);
717 ✗ m_impl->setPzm(-1);
718 ✗ m_impl->setPe(pe);
719 ✗ m_impl->setPw(pw);
720 ✗ m_impl->setPld(pld);
721 ✗ m_impl->setRelHt(relHt);
722 ✗ m_impl->setMult(mult);
723 ✗ m_impl->setWPset(wPset);
724 ✗ m_impl->setWPmod(wPmod);
725 ✗ m_impl->setWazm(wazm);
726 ✗ m_impl->setIcon(icon);
727 ✗ }
728
729 ✗ AirflowPath::AirflowPath(int flags, int pzn, int pzm, int pe, int pld, std::string relHt, std::string mult, unsigned int icon)
730 ✗ : m_impl(std::shared_ptr<detail::AirflowPathImpl>(new detail::AirflowPathImpl)) {
731 ✗ m_impl->setFlags(flags);
732 ✗ m_impl->setPzn(pzn);
733 ✗ m_impl->setPzm(pzm);
734 ✗ m_impl->setPe(pe);
735 ✗ m_impl->setPld(pld);
736 ✗ m_impl->setRelHt(relHt);
737 ✗ m_impl->setMult(mult);
738 ✗ m_impl->setIcon(icon);
739 ✗ }
740
741 ✗ AirflowPath::AirflowPath(int flags, int pzn, int pzm, int pe, int pld, double relHt, double mult, unsigned int icon)
742 ✗ : m_impl(std::shared_ptr<detail::AirflowPathImpl>(new detail::AirflowPathImpl)) {
743 ✗ m_impl->setFlags(flags);
744 ✗ m_impl->setPzn(pzn);
745 ✗ m_impl->setPzm(pzm);
746 ✗ m_impl->setPe(pe);
747 ✗ m_impl->setPld(pld);
748 ✗ m_impl->setRelHt(relHt);
749 ✗ m_impl->setMult(mult);
750 ✗ m_impl->setIcon(icon);
751 ✗ }
752
753 ✗ AirflowPath::AirflowPath(int nr, int flags, int pzn, int pzm, int pe, int pf, int pw, int pa, int ps, int pc, int pld, std::string X, std::string Y,
754 std::string relHt, std::string mult, std::string wPset, std::string wPmod, std::string wazm, std::string Fahs,
755 std::string Xmax, std::string Xmin, unsigned int icon, unsigned int dir, int u_Ht, int u_XY, int u_dP, int u_F, int cfd,
756 ✗ std::string cfd_name, int cfd_ptype, int cfd_btype, int cfd_capp)
757 ✗ : m_impl(std::shared_ptr<detail::AirflowPathImpl>(new detail::AirflowPathImpl(nr, flags, pzn, pzm, pe, pf, pw, pa, ps, pc, pld, X, Y, relHt, mult,
758 wPset, wPmod, wazm, Fahs, Xmax, Xmin, icon, dir, u_Ht, u_XY, u_dP,
759 ✗ u_F, cfd, cfd_name, cfd_ptype, cfd_btype, cfd_capp))) {}
760
761 ✗ AirflowPath::AirflowPath(int nr, int flags, int pzn, int pzm, int pe, int pf, int pw, int pa, int ps, int pc, int pld, double X, double Y,
762 double relHt, double mult, double wPset, double wPmod, double wazm, double Fahs, double Xmax, double Xmin,
763 unsigned int icon, unsigned int dir, int u_Ht, int u_XY, int u_dP, int u_F, int cfd, std::string cfd_name, int cfd_ptype,
764 ✗ int cfd_btype, int cfd_capp)
765 ✗ : m_impl(std::shared_ptr<detail::AirflowPathImpl>(new detail::AirflowPathImpl(nr, flags, pzn, pzm, pe, pf, pw, pa, ps, pc, pld, X, Y, relHt, mult,
766 wPset, wPmod, wazm, Fahs, Xmax, Xmin, icon, dir, u_Ht, u_XY, u_dP,
767 ✗ u_F, cfd, cfd_name, cfd_ptype, cfd_btype, cfd_capp))) {}
768
769 858 AirflowPath::AirflowPath(const AirflowPath& other) = default;
770
771 ✗ AirflowPath& AirflowPath::operator=(const AirflowPath& other) = default;
772
773 ✗ bool AirflowPath::operator==(const AirflowPath& other) const {
774 ✗ return m_impl == other.m_impl;
775 }
776
777 ✗ bool AirflowPath::operator!=(const AirflowPath& other) const {
778 ✗ return m_impl != other.m_impl;
779 }
780
781 ✗ void AirflowPath::read(Reader& input) {
782 ✗ m_impl->read(input);
783 ✗ }
784
785 17 std::string AirflowPath::write() {
786 17 return m_impl->write();
787 }
788
789 105 int AirflowPath::nr() const {
790 105 return m_impl->nr();
791 }
792
793 92 void AirflowPath::setNr(const int nr) {
794 92 m_impl->setNr(nr);
795 92 }
796
797 ✗ int AirflowPath::flags() const {
798 ✗ return m_impl->flags();
799 }
800
801 ✗ void AirflowPath::setFlags(const int flags) {
802 ✗ m_impl->setFlags(flags);
803 ✗ }
804
805 39 int AirflowPath::pzn() const {
806 39 return m_impl->pzn();
807 }
808
809 69 void AirflowPath::setPzn(const int pzn) {
810 69 m_impl->setPzn(pzn);
811 69 }
812
813 26 int AirflowPath::pzm() const {
814 26 return m_impl->pzm();
815 }
816
817 69 void AirflowPath::setPzm(const int pzm) {
818 69 m_impl->setPzm(pzm);
819 69 }
820
821 12 int AirflowPath::pe() const {
822 12 return m_impl->pe();
823 }
824
825 46 void AirflowPath::setPe(const int pe) {
826 46 m_impl->setPe(pe);
827 46 }
828
829 ✗ int AirflowPath::pf() const {
830 ✗ return m_impl->pf();
831 }
832
833 ✗ void AirflowPath::setPf(const int pf) {
834 ✗ m_impl->setPf(pf);
835 ✗ }
836
837 ✗ int AirflowPath::pw() const {
838 ✗ return m_impl->pw();
839 }
840
841 48 void AirflowPath::setPw(const int pw) {
842 48 m_impl->setPw(pw);
843 48 }
844
845 ✗ int AirflowPath::pa() const {
846 ✗ return m_impl->pa();
847 }
848
849 14 void AirflowPath::setPa(const int pa) {
850 14 m_impl->setPa(pa);
851 14 }
852
853 ✗ int AirflowPath::ps() const {
854 ✗ return m_impl->ps();
855 }
856
857 ✗ void AirflowPath::setPs(const int ps) {
858 ✗ m_impl->setPs(ps);
859 ✗ }
860
861 ✗ int AirflowPath::pc() const {
862 ✗ return m_impl->pc();
863 }
864
865 ✗ void AirflowPath::setPc(const int pc) {
866 ✗ m_impl->setPc(pc);
867 ✗ }
868
869 ✗ int AirflowPath::pld() const {
870 ✗ return m_impl->pld();
871 }
872
873 69 void AirflowPath::setPld(const int pld) {
874 69 m_impl->setPld(pld);
875 69 }
876
877 ✗ double AirflowPath::X() const {
878 ✗ return m_impl->X();
879 }
880
881 ✗ bool AirflowPath::setX(const double X) {
882 ✗ return m_impl->setX(X);
883 }
884
885 ✗ bool AirflowPath::setX(const std::string& X) {
886 ✗ return m_impl->setX(X);
887 }
888
889 ✗ double AirflowPath::Y() const {
890 ✗ return m_impl->Y();
891 }
892
893 ✗ bool AirflowPath::setY(const double Y) {
894 ✗ return m_impl->setY(Y);
895 }
896
897 ✗ bool AirflowPath::setY(const std::string& Y) {
898 ✗ return m_impl->setY(Y);
899 }
900
901 ✗ double AirflowPath::relHt() const {
902 ✗ return m_impl->relHt();
903 }
904
905 ✗ bool AirflowPath::setRelHt(const std::string& relHt) {
906 ✗ return m_impl->setRelHt(relHt);
907 }
908
909 46 bool AirflowPath::setRelHt(const double relHt) {
910 46 return m_impl->setRelHt(relHt);
911 }
912
913 17 double AirflowPath::mult() const {
914 17 return m_impl->mult();
915 }
916
917 46 bool AirflowPath::setMult(const double mult) {
918 46 return m_impl->setMult(mult);
919 }
920
921 ✗ bool AirflowPath::setMult(const std::string& mult) {
922 ✗ return m_impl->setMult(mult);
923 }
924
925 ✗ double AirflowPath::wPset() const {
926 ✗ return m_impl->wPset();
927 }
928
929 ✗ bool AirflowPath::setWPset(const double wPset) {
930 ✗ return m_impl->setWPset(wPset);
931 }
932
933 ✗ bool AirflowPath::setWPset(const std::string& wPset) {
934 ✗ return m_impl->setWPset(wPset);
935 }
936
937 ✗ double AirflowPath::wPmod() const {
938 ✗ return m_impl->wPmod();
939 }
940
941 36 bool AirflowPath::setWPmod(const double wPmod) {
942 36 return m_impl->setWPmod(wPmod);
943 }
944
945 ✗ bool AirflowPath::setWPmod(const std::string& wPmod) {
946 ✗ return m_impl->setWPmod(wPmod);
947 }
948
949 ✗ double AirflowPath::wazm() const {
950 ✗ return m_impl->wazm();
951 }
952
953 36 bool AirflowPath::setWazm(const double wazm) {
954 36 return m_impl->setWazm(wazm);
955 }
956
957 ✗ bool AirflowPath::setWazm(const std::string& wazm) {
958 ✗ return m_impl->setWazm(wazm);
959 }
960
961 ✗ double AirflowPath::Fahs() const {
962 ✗ return m_impl->Fahs();
963 }
964
965 ✗ bool AirflowPath::setFahs(const double Fahs) {
966 ✗ return m_impl->setFahs(Fahs);
967 }
968
969 14 bool AirflowPath::setFahs(const std::string& Fahs) {
970 14 return m_impl->setFahs(Fahs);
971 }
972
973 ✗ double AirflowPath::Xmax() const {
974 ✗ return m_impl->Xmax();
975 }
976
977 ✗ bool AirflowPath::setXmax(const double Xmax) {
978 ✗ return m_impl->setXmax(Xmax);
979 }
980
981 ✗ bool AirflowPath::setXmax(const std::string& Xmax) {
982 ✗ return m_impl->setXmax(Xmax);
983 }
984
985 ✗ double AirflowPath::Xmin() const {
986 ✗ return m_impl->Xmin();
987 }
988
989 ✗ bool AirflowPath::setXmin(const double Xmin) {
990 ✗ return m_impl->setXmin(Xmin);
991 }
992
993 ✗ bool AirflowPath::setXmin(const std::string& Xmin) {
994 ✗ return m_impl->setXmin(Xmin);
995 }
996
997 ✗ unsigned int AirflowPath::icon() const {
998 ✗ return m_impl->icon();
999 }
1000
1001 ✗ void AirflowPath::setIcon(const unsigned int icon) {
1002 ✗ m_impl->setIcon(icon);
1003 ✗ }
1004
1005 ✗ unsigned int AirflowPath::dir() const {
1006 ✗ return m_impl->dir();
1007 }
1008
1009 ✗ void AirflowPath::setDir(const unsigned int dir) {
1010 ✗ m_impl->setDir(dir);
1011 ✗ }
1012
1013 ✗ int AirflowPath::u_Ht() const {
1014 ✗ return m_impl->u_Ht();
1015 }
1016
1017 ✗ void AirflowPath::setU_Ht(const int u_Ht) {
1018 ✗ m_impl->setU_Ht(u_Ht);
1019 ✗ }
1020
1021 ✗ int AirflowPath::u_XY() const {
1022 ✗ return m_impl->u_XY();
1023 }
1024
1025 ✗ void AirflowPath::setU_XY(const int u_XY) {
1026 ✗ m_impl->setU_XY(u_XY);
1027 ✗ }
1028
1029 ✗ int AirflowPath::u_dP() const {
1030 ✗ return m_impl->u_dP();
1031 }
1032
1033 ✗ void AirflowPath::setU_dP(const int u_dP) {
1034 ✗ m_impl->setU_dP(u_dP);
1035 ✗ }
1036
1037 ✗ int AirflowPath::u_F() const {
1038 ✗ return m_impl->u_F();
1039 }
1040
1041 ✗ void AirflowPath::setU_F(const int u_F) {
1042 ✗ m_impl->setU_F(u_F);
1043 ✗ }
1044
1045 ✗ int AirflowPath::cfd() const {
1046 ✗ return m_impl->cfd();
1047 }
1048
1049 ✗ void AirflowPath::setCfd(const int cfd) {
1050 ✗ m_impl->setCfd(cfd);
1051 ✗ }
1052
1053 ✗ std::string AirflowPath::cfd_name() const {
1054 ✗ return m_impl->cfd_name();
1055 }
1056
1057 ✗ void AirflowPath::setCfd_name(const std::string& cfd_name) {
1058 ✗ m_impl->setCfd_name(cfd_name);
1059 ✗ }
1060
1061 ✗ int AirflowPath::cfd_ptype() const {
1062 ✗ return m_impl->cfd_ptype();
1063 }
1064
1065 ✗ void AirflowPath::setCfd_ptype(const int cfd_ptype) {
1066 ✗ m_impl->setCfd_ptype(cfd_ptype);
1067 ✗ }
1068
1069 ✗ int AirflowPath::cfd_btype() const {
1070 ✗ return m_impl->cfd_btype();
1071 }
1072
1073 ✗ void AirflowPath::setCfd_btype(const int cfd_btype) {
1074 ✗ m_impl->setCfd_btype(cfd_btype);
1075 ✗ }
1076
1077 ✗ int AirflowPath::cfd_capp() const {
1078 ✗ return m_impl->cfd_capp();
1079 }
1080
1081 ✗ void AirflowPath::setCfd_capp(const int cfd_capp) {
1082 ✗ m_impl->setCfd_capp(cfd_capp);
1083 ✗ }
1084
1085 36 void AirflowPath::setWindPressure(bool b) {
1086 36 m_impl->setWindPressure(b);
1087 36 }
1088
1089 20 bool AirflowPath::windPressure() {
1090 20 return m_impl->windPressure();
1091 }
1092
1093 14 void AirflowPath::setSystem(bool b) {
1094 14 m_impl->setSystem(b);
1095 14 }
1096
1097 26 bool AirflowPath::system() {
1098 26 return m_impl->system();
1099 }
1100
1101 3 void AirflowPath::setExhaust(bool b) {
1102 3 m_impl->setExhaust(b);
1103 3 }
1104
1105 8 bool AirflowPath::exhaust() {
1106 8 return m_impl->exhaust();
1107 }
1108
1109 3 void AirflowPath::setRecirculation(bool b) {
1110 3 m_impl->setRecirculation(b);
1111 3 }
1112
1113 6 bool AirflowPath::recirculation() {
1114 6 return m_impl->recirculation();
1115 }
1116
1117 3 void AirflowPath::setOutsideAir(bool b) {
1118 3 m_impl->setOutsideAir(b);
1119 3 }
1120
1121 7 bool AirflowPath::outsideAir() {
1122 7 return m_impl->outsideAir();
1123 }
1124
1125
2/4
✓ Branch 2 taken 8 times.
✓ Branch 5 taken 8 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
8 RunControl::RunControl() : m_impl(std::shared_ptr<detail::RunControlImpl>(new detail::RunControlImpl())) {}
1126 /*
1127 RunControl::RunControl(int sim_af,int afcalc,int afmaxi,double afrcnvg,double afacnvg,double afrelax,
1128 int uac2,double Pres,int uPres,int afslae,int afrseq,int aflmaxi,double aflcnvg,
1129 int aflinit,int Tadj,int sim_mf,int ccmaxi,double ccrcnvg,double ccacnvg,
1130 double ccrelax,int uccc,int mfnmthd,int mfnrseq,int mfnmaxi,double mfnrcnvg,
1131 double mfnacnvg,double mfnrelax,double mfngamma,int uccn,int mftmthd,int mftrseq,
1132 int mftmaxi,double mftrcnvg,double mftacnvg,double mftrelax,double mftgamma,int ucct,
1133 int mfvmthd,int mfvrseq,int mfvmaxi,double mfvrcnvg,double mfvacnvg,double mfvrelax,
1134 int uccv,int mf_solver,int sim_1dz,int sim_1dd,double celldx,int sim_vjt,int udx,
1135 int cvode_mth,double cvode_rcnvg,double cvode_acnvg,double cvode_dtmax,int tsdens,
1136 double tsrelax,int tsmaxi,int cnvgSS,int densZP,int stackD,int dodMdt,
1137 std::string date_st,std::string time_st,std::string date_0,std::string time_0,std::string date_1,
1138 std::string time_1,std::string time_step,std::string time_list,std::string time_scrn,int restart,
1139 std::string rstdate,std::string rsttime,int list,int doDlg,int pfsave,int zfsave,
1140 int zcsave,int achvol,int achsave,int abwsave,int cbwsave,int expsave,
1141 int ebwsave,int zaasave,int zbwsave,int rzfsave,int rzmsave,int rz1save,
1142 int csmsave,int srfsave,int logsave,std::vector<int> save,std::vector<double> rvals,
1143 int BldgFlowZ,int BldgFlowD,int BldgFlowC,int cfd_ctype,double cfd_convcpl,
1144 int cfd_var,int cfd_zref,int cfd_imax,int cfd_dtcmo)
1145 {
1146 d = new detail::RunControlImpl(sim_af,afcalc,afmaxi,afrcnvg,afacnvg,afrelax,uac2,Pres,uPres,afslae,afrseq,
1147 aflmaxi,aflcnvg,aflinit,Tadj,sim_mf,ccmaxi,ccrcnvg,ccacnvg,ccrelax,uccc,mfnmthd,
1148 mfnrseq,mfnmaxi,mfnrcnvg,mfnacnvg,mfnrelax,mfngamma,uccn,mftmthd,mftrseq,mftmaxi,
1149 mftrcnvg,mftacnvg,mftrelax,mftgamma,ucct,mfvmthd,mfvrseq,mfvmaxi,mfvrcnvg,
1150 mfvacnvg,mfvrelax,uccv,mf_solver,sim_1dz,sim_1dd,celldx,sim_vjt,udx,cvode_mth,
1151 cvode_rcnvg,cvode_acnvg,cvode_dtmax,tsdens,tsrelax,tsmaxi,cnvgSS,densZP,stackD,
1152 dodMdt,date_st,time_st,date_0,time_0,date_1,time_1,time_step,time_list,time_scrn,
1153 restart,rstdate,rsttime,list,doDlg,pfsave,zfsave,zcsave,achvol,achsave,abwsave,
1154 cbwsave,expsave,ebwsave,zaasave,zbwsave,rzfsave,rzmsave,rz1save,csmsave,srfsave,
1155 logsave,save,rvals,BldgFlowZ,BldgFlowD,BldgFlowC,cfd_ctype,cfd_convcpl,cfd_var,
1156 cfd_zref,cfd_imax,cfd_dtcmo);
1157 }
1158
1159 RunControl::RunControl(int sim_af,int afcalc,int afmaxi,std::string afrcnvg,std::string afacnvg,std::string afrelax,
1160 int uac2,std::string Pres,int uPres,int afslae,int afrseq,int aflmaxi,std::string aflcnvg,
1161 int aflinit,int Tadj,int sim_mf,int ccmaxi,std::string ccrcnvg,std::string ccacnvg,
1162 std::string ccrelax,int uccc,int mfnmthd,int mfnrseq,int mfnmaxi,std::string mfnrcnvg,
1163 std::string mfnacnvg,std::string mfnrelax,std::string mfngamma,int uccn,int mftmthd,int mftrseq,
1164 int mftmaxi,std::string mftrcnvg,std::string mftacnvg,std::string mftrelax,std::string mftgamma,
1165 int ucct,int mfvmthd,int mfvrseq,int mfvmaxi,std::string mfvrcnvg,std::string mfvacnvg,
1166 std::string mfvrelax,int uccv,int mf_solver,int sim_1dz,int sim_1dd,std::string celldx,
1167 int sim_vjt,int udx,int cvode_mth,std::string cvode_rcnvg,std::string cvode_acnvg,
1168 std::string cvode_dtmax,int tsdens,std::string tsrelax,int tsmaxi,int cnvgSS,int densZP,
1169 int stackD,int dodMdt,std::string date_st,std::string time_st,std::string date_0,std::string time_0,
1170 std::string date_1,std::string time_1,std::string time_step,std::string time_list,std::string time_scrn,
1171 int restart,std::string rstdate,std::string rsttime,int list,int doDlg,int pfsave,int zfsave,
1172 int zcsave,int achvol,int achsave,int abwsave,int cbwsave,int expsave,int ebwsave,
1173 int zaasave,int zbwsave,int rzfsave,int rzmsave,int rz1save,int csmsave,int srfsave,
1174 int logsave,std::vector<int> save,std::vector<std::string> rvals,int BldgFlowZ,int BldgFlowD,
1175 int BldgFlowC,int cfd_ctype,std::string cfd_convcpl,int cfd_var,int cfd_zref,
1176 int cfd_imax,int cfd_dtcmo)
1177 {
1178 d = new detail::RunControlImpl(sim_af,afcalc,afmaxi,afrcnvg,afacnvg,afrelax,uac2,Pres,uPres,afslae,afrseq,
1179 aflmaxi,aflcnvg,aflinit,Tadj,sim_mf,ccmaxi,ccrcnvg,ccacnvg,ccrelax,uccc,mfnmthd,
1180 mfnrseq,mfnmaxi,mfnrcnvg,mfnacnvg,mfnrelax,mfngamma,uccn,mftmthd,mftrseq,mftmaxi,
1181 mftrcnvg,mftacnvg,mftrelax,mftgamma,ucct,mfvmthd,mfvrseq,mfvmaxi,mfvrcnvg,
1182 mfvacnvg,mfvrelax,uccv,mf_solver,sim_1dz,sim_1dd,celldx,sim_vjt,udx,cvode_mth,
1183 cvode_rcnvg,cvode_acnvg,cvode_dtmax,tsdens,tsrelax,tsmaxi,cnvgSS,densZP,stackD,
1184 dodMdt,date_st,time_st,date_0,time_0,date_1,time_1,time_step,time_list,time_scrn,
1185 restart,rstdate,rsttime,list,doDlg,pfsave,zfsave,zcsave,achvol,achsave,abwsave,
1186 cbwsave,expsave,ebwsave,zaasave,zbwsave,rzfsave,rzmsave,rz1save,csmsave,srfsave,
1187 logsave,save,rvals,BldgFlowZ,BldgFlowD,BldgFlowC,cfd_ctype,cfd_convcpl,cfd_var,
1188 cfd_zref,cfd_imax,cfd_dtcmo);
1189 }*/
1190
1191 5 RunControl::RunControl(const RunControl& other) = default;
1192
1193 ✗ RunControl& RunControl::operator=(const RunControl& other) = default;
1194
1195 ✗ bool RunControl::operator==(const RunControl& other) const {
1196 ✗ return m_impl == other.m_impl;
1197 }
1198
1199 ✗ bool RunControl::operator!=(const RunControl& other) const {
1200 ✗ return m_impl != other.m_impl;
1201 }
1202
1203 1 std::string RunControl::write() {
1204 1 return m_impl->write();
1205 }
1206
1207 6 void RunControl::read(Reader& input) {
1208 6 m_impl->read(input);
1209 6 }
1210
1211 ✗ int RunControl::sim_af() const {
1212 ✗ return m_impl->sim_af();
1213 }
1214
1215 1 void RunControl::setSim_af(const int sim_af) {
1216 1 m_impl->setSim_af(sim_af);
1217 1 }
1218
1219 ✗ int RunControl::afcalc() const {
1220 ✗ return m_impl->afcalc();
1221 }
1222
1223 ✗ void RunControl::setAfcalc(const int afcalc) {
1224 ✗ m_impl->setAfcalc(afcalc);
1225 ✗ }
1226
1227 ✗ int RunControl::afmaxi() const {
1228 ✗ return m_impl->afmaxi();
1229 }
1230
1231 ✗ void RunControl::setAfmaxi(const int afmaxi) {
1232 ✗ m_impl->setAfmaxi(afmaxi);
1233 ✗ }
1234
1235 ✗ double RunControl::afrcnvg() const {
1236 ✗ return m_impl->afrcnvg();
1237 }
1238
1239 ✗ bool RunControl::setAfrcnvg(const double afrcnvg) {
1240 ✗ return m_impl->setAfrcnvg(afrcnvg);
1241 }
1242
1243 ✗ bool RunControl::setAfrcnvg(const std::string& afrcnvg) {
1244 ✗ return m_impl->setAfrcnvg(afrcnvg);
1245 }
1246
1247 ✗ double RunControl::afacnvg() const {
1248 ✗ return m_impl->afacnvg();
1249 }
1250
1251 ✗ bool RunControl::setAfacnvg(const double afacnvg) {
1252 ✗ return m_impl->setAfacnvg(afacnvg);
1253 }
1254
1255 ✗ bool RunControl::setAfacnvg(const std::string& afacnvg) {
1256 ✗ return m_impl->setAfacnvg(afacnvg);
1257 }
1258
1259 ✗ double RunControl::afrelax() const {
1260 ✗ return m_impl->afrelax();
1261 }
1262
1263 ✗ bool RunControl::setAfrelax(const double afrelax) {
1264 ✗ return m_impl->setAfrelax(afrelax);
1265 }
1266
1267 ✗ bool RunControl::setAfrelax(const std::string& afrelax) {
1268 ✗ return m_impl->setAfrelax(afrelax);
1269 }
1270
1271 ✗ int RunControl::uac2() const {
1272 ✗ return m_impl->uac2();
1273 }
1274
1275 ✗ void RunControl::setUac2(const int uac2) {
1276 ✗ m_impl->setUac2(uac2);
1277 ✗ }
1278
1279 ✗ double RunControl::Pres() const {
1280 ✗ return m_impl->Pres();
1281 }
1282
1283 ✗ bool RunControl::setPres(const double Pres) {
1284 ✗ return m_impl->setPres(Pres);
1285 }
1286
1287 ✗ bool RunControl::setPres(const std::string& Pres) {
1288 ✗ return m_impl->setPres(Pres);
1289 }
1290
1291 ✗ int RunControl::uPres() const {
1292 ✗ return m_impl->uPres();
1293 }
1294
1295 ✗ void RunControl::setUPres(const int uPres) {
1296 ✗ m_impl->setUPres(uPres);
1297 ✗ }
1298
1299 ✗ int RunControl::afslae() const {
1300 ✗ return m_impl->afslae();
1301 }
1302
1303 ✗ void RunControl::setAfslae(const int afslae) {
1304 ✗ m_impl->setAfslae(afslae);
1305 ✗ }
1306
1307 ✗ int RunControl::afrseq() const {
1308 ✗ return m_impl->afrseq();
1309 }
1310
1311 ✗ void RunControl::setAfrseq(const int afrseq) {
1312 ✗ m_impl->setAfrseq(afrseq);
1313 ✗ }
1314
1315 ✗ int RunControl::aflmaxi() const {
1316 ✗ return m_impl->aflmaxi();
1317 }
1318
1319 ✗ void RunControl::setAflmaxi(const int aflmaxi) {
1320 ✗ m_impl->setAflmaxi(aflmaxi);
1321 ✗ }
1322
1323 ✗ double RunControl::aflcnvg() const {
1324 ✗ return m_impl->aflcnvg();
1325 }
1326
1327 ✗ bool RunControl::setAflcnvg(const double aflcnvg) {
1328 ✗ return m_impl->setAflcnvg(aflcnvg);
1329 }
1330
1331 ✗ bool RunControl::setAflcnvg(const std::string& aflcnvg) {
1332 ✗ return m_impl->setAflcnvg(aflcnvg);
1333 }
1334
1335 ✗ int RunControl::aflinit() const {
1336 ✗ return m_impl->aflinit();
1337 }
1338
1339 ✗ void RunControl::setAflinit(const int aflinit) {
1340 ✗ m_impl->setAflinit(aflinit);
1341 ✗ }
1342
1343 ✗ int RunControl::Tadj() const {
1344 ✗ return m_impl->Tadj();
1345 }
1346
1347 ✗ void RunControl::setTadj(const int Tadj) {
1348 ✗ m_impl->setTadj(Tadj);
1349 ✗ }
1350
1351 ✗ int RunControl::sim_mf() const {
1352 ✗ return m_impl->sim_mf();
1353 }
1354
1355 ✗ void RunControl::setSim_mf(const int sim_mf) {
1356 ✗ m_impl->setSim_mf(sim_mf);
1357 ✗ }
1358
1359 ✗ int RunControl::ccmaxi() const {
1360 ✗ return m_impl->ccmaxi();
1361 }
1362
1363 ✗ void RunControl::setCcmaxi(const int ccmaxi) {
1364 ✗ m_impl->setCcmaxi(ccmaxi);
1365 ✗ }
1366
1367 ✗ double RunControl::ccrcnvg() const {
1368 ✗ return m_impl->ccrcnvg();
1369 }
1370
1371 ✗ bool RunControl::setCcrcnvg(const double ccrcnvg) {
1372 ✗ return m_impl->setCcrcnvg(ccrcnvg);
1373 }
1374
1375 ✗ bool RunControl::setCcrcnvg(const std::string& ccrcnvg) {
1376 ✗ return m_impl->setCcrcnvg(ccrcnvg);
1377 }
1378
1379 ✗ double RunControl::ccacnvg() const {
1380 ✗ return m_impl->ccacnvg();
1381 }
1382
1383 ✗ bool RunControl::setCcacnvg(const double ccacnvg) {
1384 ✗ return m_impl->setCcacnvg(ccacnvg);
1385 }
1386
1387 ✗ bool RunControl::setCcacnvg(const std::string& ccacnvg) {
1388 ✗ return m_impl->setCcacnvg(ccacnvg);
1389 }
1390
1391 ✗ double RunControl::ccrelax() const {
1392 ✗ return m_impl->ccrelax();
1393 }
1394
1395 ✗ bool RunControl::setCcrelax(const double ccrelax) {
1396 ✗ return m_impl->setCcrelax(ccrelax);
1397 }
1398
1399 ✗ bool RunControl::setCcrelax(const std::string& ccrelax) {
1400 ✗ return m_impl->setCcrelax(ccrelax);
1401 }
1402
1403 ✗ int RunControl::uccc() const {
1404 ✗ return m_impl->uccc();
1405 }
1406
1407 ✗ void RunControl::setUccc(const int uccc) {
1408 ✗ m_impl->setUccc(uccc);
1409 ✗ }
1410
1411 ✗ int RunControl::mfnmthd() const {
1412 ✗ return m_impl->mfnmthd();
1413 }
1414
1415 ✗ void RunControl::setMfnmthd(const int mfnmthd) {
1416 ✗ m_impl->setMfnmthd(mfnmthd);
1417 ✗ }
1418
1419 ✗ int RunControl::mfnrseq() const {
1420 ✗ return m_impl->mfnrseq();
1421 }
1422
1423 ✗ void RunControl::setMfnrseq(const int mfnrseq) {
1424 ✗ m_impl->setMfnrseq(mfnrseq);
1425 ✗ }
1426
1427 ✗ int RunControl::mfnmaxi() const {
1428 ✗ return m_impl->mfnmaxi();
1429 }
1430
1431 ✗ void RunControl::setMfnmaxi(const int mfnmaxi) {
1432 ✗ m_impl->setMfnmaxi(mfnmaxi);
1433 ✗ }
1434
1435 ✗ double RunControl::mfnrcnvg() const {
1436 ✗ return m_impl->mfnrcnvg();
1437 }
1438
1439 ✗ bool RunControl::setMfnrcnvg(const double mfnrcnvg) {
1440 ✗ return m_impl->setMfnrcnvg(mfnrcnvg);
1441 }
1442
1443 ✗ bool RunControl::setMfnrcnvg(const std::string& mfnrcnvg) {
1444 ✗ return m_impl->setMfnrcnvg(mfnrcnvg);
1445 }
1446
1447 ✗ double RunControl::mfnacnvg() const {
1448 ✗ return m_impl->mfnacnvg();
1449 }
1450
1451 ✗ bool RunControl::setMfnacnvg(const double mfnacnvg) {
1452 ✗ return m_impl->setMfnacnvg(mfnacnvg);
1453 }
1454
1455 ✗ bool RunControl::setMfnacnvg(const std::string& mfnacnvg) {
1456 ✗ return m_impl->setMfnacnvg(mfnacnvg);
1457 }
1458
1459 ✗ double RunControl::mfnrelax() const {
1460 ✗ return m_impl->mfnrelax();
1461 }
1462
1463 ✗ bool RunControl::setMfnrelax(const double mfnrelax) {
1464 ✗ return m_impl->setMfnrelax(mfnrelax);
1465 }
1466
1467 ✗ bool RunControl::setMfnrelax(const std::string& mfnrelax) {
1468 ✗ return m_impl->setMfnrelax(mfnrelax);
1469 }
1470
1471 ✗ double RunControl::mfngamma() const {
1472 ✗ return m_impl->mfngamma();
1473 }
1474
1475 ✗ bool RunControl::setMfngamma(const double mfngamma) {
1476 ✗ return m_impl->setMfngamma(mfngamma);
1477 }
1478
1479 ✗ bool RunControl::setMfngamma(const std::string& mfngamma) {
1480 ✗ return m_impl->setMfngamma(mfngamma);
1481 }
1482
1483 ✗ int RunControl::uccn() const {
1484 ✗ return m_impl->uccn();
1485 }
1486
1487 ✗ void RunControl::setUccn(const int uccn) {
1488 ✗ m_impl->setUccn(uccn);
1489 ✗ }
1490
1491 ✗ int RunControl::mftmthd() const {
1492 ✗ return m_impl->mftmthd();
1493 }
1494
1495 ✗ void RunControl::setMftmthd(const int mftmthd) {
1496 ✗ m_impl->setMftmthd(mftmthd);
1497 ✗ }
1498
1499 ✗ int RunControl::mftrseq() const {
1500 ✗ return m_impl->mftrseq();
1501 }
1502
1503 ✗ void RunControl::setMftrseq(const int mftrseq) {
1504 ✗ m_impl->setMftrseq(mftrseq);
1505 ✗ }
1506
1507 ✗ int RunControl::mftmaxi() const {
1508 ✗ return m_impl->mftmaxi();
1509 }
1510
1511 ✗ void RunControl::setMftmaxi(const int mftmaxi) {
1512 ✗ m_impl->setMftmaxi(mftmaxi);
1513 ✗ }
1514
1515 ✗ double RunControl::mftrcnvg() const {
1516 ✗ return m_impl->mftrcnvg();
1517 }
1518
1519 ✗ bool RunControl::setMftrcnvg(const double mftrcnvg) {
1520 ✗ return m_impl->setMftrcnvg(mftrcnvg);
1521 }
1522
1523 ✗ bool RunControl::setMftrcnvg(const std::string& mftrcnvg) {
1524 ✗ return m_impl->setMftrcnvg(mftrcnvg);
1525 }
1526
1527 ✗ double RunControl::mftacnvg() const {
1528 ✗ return m_impl->mftacnvg();
1529 }
1530
1531 ✗ bool RunControl::setMftacnvg(const double mftacnvg) {
1532 ✗ return m_impl->setMftacnvg(mftacnvg);
1533 }
1534
1535 ✗ bool RunControl::setMftacnvg(const std::string& mftacnvg) {
1536 ✗ return m_impl->setMftacnvg(mftacnvg);
1537 }
1538
1539 ✗ double RunControl::mftrelax() const {
1540 ✗ return m_impl->mftrelax();
1541 }
1542
1543 ✗ bool RunControl::setMftrelax(const double mftrelax) {
1544 ✗ return m_impl->setMftrelax(mftrelax);
1545 }
1546
1547 ✗ bool RunControl::setMftrelax(const std::string& mftrelax) {
1548 ✗ return m_impl->setMftrelax(mftrelax);
1549 }
1550
1551 ✗ double RunControl::mftgamma() const {
1552 ✗ return m_impl->mftgamma();
1553 }
1554
1555 ✗ bool RunControl::setMftgamma(const double mftgamma) {
1556 ✗ return m_impl->setMftgamma(mftgamma);
1557 }
1558
1559 ✗ bool RunControl::setMftgamma(const std::string& mftgamma) {
1560 ✗ return m_impl->setMftgamma(mftgamma);
1561 }
1562
1563 ✗ int RunControl::ucct() const {
1564 ✗ return m_impl->ucct();
1565 }
1566
1567 ✗ void RunControl::setUcct(const int ucct) {
1568 ✗ m_impl->setUcct(ucct);
1569 ✗ }
1570
1571 ✗ int RunControl::mfvmthd() const {
1572 ✗ return m_impl->mfvmthd();
1573 }
1574
1575 ✗ void RunControl::setMfvmthd(const int mfvmthd) {
1576 ✗ m_impl->setMfvmthd(mfvmthd);
1577 ✗ }
1578
1579 ✗ int RunControl::mfvrseq() const {
1580 ✗ return m_impl->mfvrseq();
1581 }
1582
1583 ✗ void RunControl::setMfvrseq(const int mfvrseq) {
1584 ✗ m_impl->setMfvrseq(mfvrseq);
1585 ✗ }
1586
1587 ✗ int RunControl::mfvmaxi() const {
1588 ✗ return m_impl->mfvmaxi();
1589 }
1590
1591 ✗ void RunControl::setMfvmaxi(const int mfvmaxi) {
1592 ✗ m_impl->setMfvmaxi(mfvmaxi);
1593 ✗ }
1594
1595 ✗ double RunControl::mfvrcnvg() const {
1596 ✗ return m_impl->mfvrcnvg();
1597 }
1598
1599 ✗ bool RunControl::setMfvrcnvg(const double mfvrcnvg) {
1600 ✗ return m_impl->setMfvrcnvg(mfvrcnvg);
1601 }
1602
1603 ✗ bool RunControl::setMfvrcnvg(const std::string& mfvrcnvg) {
1604 ✗ return m_impl->setMfvrcnvg(mfvrcnvg);
1605 }
1606
1607 ✗ double RunControl::mfvacnvg() const {
1608 ✗ return m_impl->mfvacnvg();
1609 }
1610
1611 ✗ bool RunControl::setMfvacnvg(const double mfvacnvg) {
1612 ✗ return m_impl->setMfvacnvg(mfvacnvg);
1613 }
1614
1615 ✗ bool RunControl::setMfvacnvg(const std::string& mfvacnvg) {
1616 ✗ return m_impl->setMfvacnvg(mfvacnvg);
1617 }
1618
1619 ✗ double RunControl::mfvrelax() const {
1620 ✗ return m_impl->mfvrelax();
1621 }
1622
1623 ✗ bool RunControl::setMfvrelax(const double mfvrelax) {
1624 ✗ return m_impl->setMfvrelax(mfvrelax);
1625 }
1626
1627 ✗ bool RunControl::setMfvrelax(const std::string& mfvrelax) {
1628 ✗ return m_impl->setMfvrelax(mfvrelax);
1629 }
1630
1631 ✗ int RunControl::uccv() const {
1632 ✗ return m_impl->uccv();
1633 }
1634
1635 ✗ void RunControl::setUccv(const int uccv) {
1636 ✗ m_impl->setUccv(uccv);
1637 ✗ }
1638
1639 ✗ int RunControl::mf_solver() const {
1640 ✗ return m_impl->mf_solver();
1641 }
1642
1643 ✗ void RunControl::setMf_solver(const int mf_solver) {
1644 ✗ m_impl->setMf_solver(mf_solver);
1645 ✗ }
1646
1647 ✗ int RunControl::sim_1dz() const {
1648 ✗ return m_impl->sim_1dz();
1649 }
1650
1651 ✗ void RunControl::setSim_1dz(const int sim_1dz) {
1652 ✗ m_impl->setSim_1dz(sim_1dz);
1653 ✗ }
1654
1655 ✗ int RunControl::sim_1dd() const {
1656 ✗ return m_impl->sim_1dd();
1657 }
1658
1659 ✗ void RunControl::setSim_1dd(const int sim_1dd) {
1660 ✗ m_impl->setSim_1dd(sim_1dd);
1661 ✗ }
1662
1663 ✗ double RunControl::celldx() const {
1664 ✗ return m_impl->celldx();
1665 }
1666
1667 ✗ bool RunControl::setCelldx(const double celldx) {
1668 ✗ return m_impl->setCelldx(celldx);
1669 }
1670
1671 ✗ bool RunControl::setCelldx(const std::string& celldx) {
1672 ✗ return m_impl->setCelldx(celldx);
1673 }
1674
1675 ✗ int RunControl::sim_vjt() const {
1676 ✗ return m_impl->sim_vjt();
1677 }
1678
1679 ✗ void RunControl::setSim_vjt(const int sim_vjt) {
1680 ✗ m_impl->setSim_vjt(sim_vjt);
1681 ✗ }
1682
1683 ✗ int RunControl::udx() const {
1684 ✗ return m_impl->udx();
1685 }
1686
1687 ✗ void RunControl::setUdx(const int udx) {
1688 ✗ m_impl->setUdx(udx);
1689 ✗ }
1690
1691 ✗ int RunControl::cvode_mth() const {
1692 ✗ return m_impl->cvode_mth();
1693 }
1694
1695 ✗ void RunControl::setCvode_mth(const int cvode_mth) {
1696 ✗ m_impl->setCvode_mth(cvode_mth);
1697 ✗ }
1698
1699 ✗ double RunControl::cvode_rcnvg() const {
1700 ✗ return m_impl->cvode_rcnvg();
1701 }
1702
1703 ✗ bool RunControl::setCvode_rcnvg(const double cvode_rcnvg) {
1704 ✗ return m_impl->setCvode_rcnvg(cvode_rcnvg);
1705 }
1706
1707 ✗ bool RunControl::setCvode_rcnvg(const std::string& cvode_rcnvg) {
1708 ✗ return m_impl->setCvode_rcnvg(cvode_rcnvg);
1709 }
1710
1711 ✗ double RunControl::cvode_acnvg() const {
1712 ✗ return m_impl->cvode_acnvg();
1713 }
1714
1715 ✗ bool RunControl::setCvode_acnvg(const double cvode_acnvg) {
1716 ✗ return m_impl->setCvode_acnvg(cvode_acnvg);
1717 }
1718
1719 ✗ bool RunControl::setCvode_acnvg(const std::string& cvode_acnvg) {
1720 ✗ return m_impl->setCvode_acnvg(cvode_acnvg);
1721 }
1722
1723 ✗ double RunControl::cvode_dtmax() const {
1724 ✗ return m_impl->cvode_dtmax();
1725 }
1726
1727 ✗ bool RunControl::setCvode_dtmax(const double cvode_dtmax) {
1728 ✗ return m_impl->setCvode_dtmax(cvode_dtmax);
1729 }
1730
1731 ✗ bool RunControl::setCvode_dtmax(const std::string& cvode_dtmax) {
1732 ✗ return m_impl->setCvode_dtmax(cvode_dtmax);
1733 }
1734
1735 ✗ int RunControl::tsdens() const {
1736 ✗ return m_impl->tsdens();
1737 }
1738
1739 ✗ void RunControl::setTsdens(const int tsdens) {
1740 ✗ m_impl->setTsdens(tsdens);
1741 ✗ }
1742
1743 ✗ double RunControl::tsrelax() const {
1744 ✗ return m_impl->tsrelax();
1745 }
1746
1747 ✗ bool RunControl::setTsrelax(const double tsrelax) {
1748 ✗ return m_impl->setTsrelax(tsrelax);
1749 }
1750
1751 ✗ bool RunControl::setTsrelax(const std::string& tsrelax) {
1752 ✗ return m_impl->setTsrelax(tsrelax);
1753 }
1754
1755 ✗ int RunControl::tsmaxi() const {
1756 ✗ return m_impl->tsmaxi();
1757 }
1758
1759 ✗ void RunControl::setTsmaxi(const int tsmaxi) {
1760 ✗ m_impl->setTsmaxi(tsmaxi);
1761 ✗ }
1762
1763 ✗ int RunControl::cnvgSS() const {
1764 ✗ return m_impl->cnvgSS();
1765 }
1766
1767 ✗ void RunControl::setCnvgSS(const int cnvgSS) {
1768 ✗ m_impl->setCnvgSS(cnvgSS);
1769 ✗ }
1770
1771 ✗ int RunControl::densZP() const {
1772 ✗ return m_impl->densZP();
1773 }
1774
1775 ✗ void RunControl::setDensZP(const int densZP) {
1776 ✗ m_impl->setDensZP(densZP);
1777 ✗ }
1778
1779 ✗ int RunControl::stackD() const {
1780 ✗ return m_impl->stackD();
1781 }
1782
1783 ✗ void RunControl::setStackD(const int stackD) {
1784 ✗ m_impl->setStackD(stackD);
1785 ✗ }
1786
1787 ✗ int RunControl::dodMdt() const {
1788 ✗ return m_impl->dodMdt();
1789 }
1790
1791 ✗ void RunControl::setDodMdt(const int dodMdt) {
1792 ✗ m_impl->setDodMdt(dodMdt);
1793 ✗ }
1794
1795 ✗ std::string RunControl::date_st() const {
1796 ✗ return m_impl->date_st();
1797 }
1798
1799 ✗ void RunControl::setDate_st(const std::string& date_st) {
1800 ✗ m_impl->setDate_st(date_st);
1801 ✗ }
1802
1803 ✗ std::string RunControl::time_st() const {
1804 ✗ return m_impl->time_st();
1805 }
1806
1807 ✗ void RunControl::setTime_st(const std::string& time_st) {
1808 ✗ m_impl->setTime_st(time_st);
1809 ✗ }
1810
1811 ✗ std::string RunControl::date_0() const {
1812 ✗ return m_impl->date_0();
1813 }
1814
1815 1 void RunControl::setDate_0(const std::string& date_0) {
1816 1 m_impl->setDate_0(date_0);
1817 1 }
1818
1819 ✗ std::string RunControl::time_0() const {
1820 ✗ return m_impl->time_0();
1821 }
1822
1823 1 void RunControl::setTime_0(const std::string& time_0) {
1824 1 m_impl->setTime_0(time_0);
1825 1 }
1826
1827 ✗ std::string RunControl::date_1() const {
1828 ✗ return m_impl->date_1();
1829 }
1830
1831 1 void RunControl::setDate_1(const std::string& date_1) {
1832 1 m_impl->setDate_1(date_1);
1833 1 }
1834
1835 ✗ std::string RunControl::time_1() const {
1836 ✗ return m_impl->time_1();
1837 }
1838
1839 1 void RunControl::setTime_1(const std::string& time_1) {
1840 1 m_impl->setTime_1(time_1);
1841 1 }
1842
1843 ✗ std::string RunControl::time_step() const {
1844 ✗ return m_impl->time_step();
1845 }
1846
1847 ✗ void RunControl::setTime_step(const std::string& time_step) {
1848 ✗ m_impl->setTime_step(time_step);
1849 ✗ }
1850
1851 ✗ std::string RunControl::time_list() const {
1852 ✗ return m_impl->time_list();
1853 }
1854
1855 ✗ void RunControl::setTime_list(const std::string& time_list) {
1856 ✗ m_impl->setTime_list(time_list);
1857 ✗ }
1858
1859 ✗ std::string RunControl::time_scrn() const {
1860 ✗ return m_impl->time_scrn();
1861 }
1862
1863 ✗ void RunControl::setTime_scrn(const std::string& time_scrn) {
1864 ✗ m_impl->setTime_scrn(time_scrn);
1865 ✗ }
1866
1867 ✗ int RunControl::restart() const {
1868 ✗ return m_impl->restart();
1869 }
1870
1871 ✗ void RunControl::setRestart(const int restart) {
1872 ✗ m_impl->setRestart(restart);
1873 ✗ }
1874
1875 ✗ std::string RunControl::rstdate() const {
1876 ✗ return m_impl->rstdate();
1877 }
1878
1879 ✗ void RunControl::setRstdate(const std::string& rstdate) {
1880 ✗ m_impl->setRstdate(rstdate);
1881 ✗ }
1882
1883 ✗ std::string RunControl::rsttime() const {
1884 ✗ return m_impl->rsttime();
1885 }
1886
1887 ✗ void RunControl::setRsttime(const std::string& rsttime) {
1888 ✗ m_impl->setRsttime(rsttime);
1889 ✗ }
1890
1891 ✗ int RunControl::list() const {
1892 ✗ return m_impl->list();
1893 }
1894
1895 ✗ void RunControl::setList(const int list) {
1896 ✗ m_impl->setList(list);
1897 ✗ }
1898
1899 ✗ int RunControl::doDlg() const {
1900 ✗ return m_impl->doDlg();
1901 }
1902
1903 ✗ void RunControl::setDoDlg(const int doDlg) {
1904 ✗ m_impl->setDoDlg(doDlg);
1905 ✗ }
1906
1907 ✗ int RunControl::pfsave() const {
1908 ✗ return m_impl->pfsave();
1909 }
1910
1911 ✗ void RunControl::setPfsave(const int pfsave) {
1912 ✗ m_impl->setPfsave(pfsave);
1913 ✗ }
1914
1915 ✗ int RunControl::zfsave() const {
1916 ✗ return m_impl->zfsave();
1917 }
1918
1919 ✗ void RunControl::setZfsave(const int zfsave) {
1920 ✗ m_impl->setZfsave(zfsave);
1921 ✗ }
1922
1923 ✗ int RunControl::zcsave() const {
1924 ✗ return m_impl->zcsave();
1925 }
1926
1927 ✗ void RunControl::setZcsave(const int zcsave) {
1928 ✗ m_impl->setZcsave(zcsave);
1929 ✗ }
1930
1931 ✗ int RunControl::achvol() const {
1932 ✗ return m_impl->achvol();
1933 }
1934
1935 ✗ void RunControl::setAchvol(const int achvol) {
1936 ✗ m_impl->setAchvol(achvol);
1937 ✗ }
1938
1939 ✗ int RunControl::achsave() const {
1940 ✗ return m_impl->achsave();
1941 }
1942
1943 ✗ void RunControl::setAchsave(const int achsave) {
1944 ✗ m_impl->setAchsave(achsave);
1945 ✗ }
1946
1947 ✗ int RunControl::abwsave() const {
1948 ✗ return m_impl->abwsave();
1949 }
1950
1951 ✗ void RunControl::setAbwsave(const int abwsave) {
1952 ✗ m_impl->setAbwsave(abwsave);
1953 ✗ }
1954
1955 ✗ int RunControl::cbwsave() const {
1956 ✗ return m_impl->cbwsave();
1957 }
1958
1959 ✗ void RunControl::setCbwsave(const int cbwsave) {
1960 ✗ m_impl->setCbwsave(cbwsave);
1961 ✗ }
1962
1963 ✗ int RunControl::expsave() const {
1964 ✗ return m_impl->expsave();
1965 }
1966
1967 ✗ void RunControl::setExpsave(const int expsave) {
1968 ✗ m_impl->setExpsave(expsave);
1969 ✗ }
1970
1971 ✗ int RunControl::ebwsave() const {
1972 ✗ return m_impl->ebwsave();
1973 }
1974
1975 ✗ void RunControl::setEbwsave(const int ebwsave) {
1976 ✗ m_impl->setEbwsave(ebwsave);
1977 ✗ }
1978
1979 ✗ int RunControl::zaasave() const {
1980 ✗ return m_impl->zaasave();
1981 }
1982
1983 ✗ void RunControl::setZaasave(const int zaasave) {
1984 ✗ m_impl->setZaasave(zaasave);
1985 ✗ }
1986
1987 ✗ int RunControl::zbwsave() const {
1988 ✗ return m_impl->zbwsave();
1989 }
1990
1991 ✗ void RunControl::setZbwsave(const int zbwsave) {
1992 ✗ m_impl->setZbwsave(zbwsave);
1993 ✗ }
1994
1995 ✗ int RunControl::rzfsave() const {
1996 ✗ return m_impl->rzfsave();
1997 }
1998
1999 ✗ void RunControl::setRzfsave(const int rzfsave) {
2000 ✗ m_impl->setRzfsave(rzfsave);
2001 ✗ }
2002
2003 ✗ int RunControl::rzmsave() const {
2004 ✗ return m_impl->rzmsave();
2005 }
2006
2007 ✗ void RunControl::setRzmsave(const int rzmsave) {
2008 ✗ m_impl->setRzmsave(rzmsave);
2009 ✗ }
2010
2011 ✗ int RunControl::rz1save() const {
2012 ✗ return m_impl->rz1save();
2013 }
2014
2015 ✗ void RunControl::setRz1save(const int rz1save) {
2016 ✗ m_impl->setRz1save(rz1save);
2017 ✗ }
2018
2019 ✗ int RunControl::csmsave() const {
2020 ✗ return m_impl->csmsave();
2021 }
2022
2023 ✗ void RunControl::setCsmsave(const int csmsave) {
2024 ✗ m_impl->setCsmsave(csmsave);
2025 ✗ }
2026
2027 ✗ int RunControl::srfsave() const {
2028 ✗ return m_impl->srfsave();
2029 }
2030
2031 ✗ void RunControl::setSrfsave(const int srfsave) {
2032 ✗ m_impl->setSrfsave(srfsave);
2033 ✗ }
2034
2035 ✗ int RunControl::logsave() const {
2036 ✗ return m_impl->logsave();
2037 }
2038
2039 ✗ void RunControl::setLogsave(const int logsave) {
2040 ✗ m_impl->setLogsave(logsave);
2041 ✗ }
2042
2043 ✗ std::vector<int> RunControl::save() const {
2044 ✗ return m_impl->save();
2045 }
2046
2047 ✗ void RunControl::setSave(const std::vector<int>& save) {
2048 ✗ m_impl->setSave(save);
2049 ✗ }
2050
2051 ✗ std::vector<double> RunControl::rvals() const {
2052 ✗ return m_impl->rvals();
2053 }
2054
2055 ✗ bool RunControl::setRvals(const std::vector<double>& rvals) {
2056 ✗ return m_impl->setRvals(rvals);
2057 }
2058
2059 ✗ bool RunControl::setRvals(const std::vector<std::string>& rvals) {
2060 ✗ return m_impl->setRvals(rvals);
2061 }
2062
2063 ✗ int RunControl::BldgFlowZ() const {
2064 ✗ return m_impl->BldgFlowZ();
2065 }
2066
2067 ✗ void RunControl::setBldgFlowZ(const int BldgFlowZ) {
2068 ✗ m_impl->setBldgFlowZ(BldgFlowZ);
2069 ✗ }
2070
2071 ✗ int RunControl::BldgFlowD() const {
2072 ✗ return m_impl->BldgFlowD();
2073 }
2074
2075 ✗ void RunControl::setBldgFlowD(const int BldgFlowD) {
2076 ✗ m_impl->setBldgFlowD(BldgFlowD);
2077 ✗ }
2078
2079 ✗ int RunControl::BldgFlowC() const {
2080 ✗ return m_impl->BldgFlowC();
2081 }
2082
2083 ✗ void RunControl::setBldgFlowC(const int BldgFlowC) {
2084 ✗ m_impl->setBldgFlowC(BldgFlowC);
2085 ✗ }
2086
2087 ✗ int RunControl::cfd_ctype() const {
2088 ✗ return m_impl->cfd_ctype();
2089 }
2090
2091 ✗ void RunControl::setCfd_ctype(const int cfd_ctype) {
2092 ✗ m_impl->setCfd_ctype(cfd_ctype);
2093 ✗ }
2094
2095 ✗ double RunControl::cfd_convcpl() const {
2096 ✗ return m_impl->cfd_convcpl();
2097 }
2098
2099 ✗ bool RunControl::setCfd_convcpl(const double cfd_convcpl) {
2100 ✗ return m_impl->setCfd_convcpl(cfd_convcpl);
2101 }
2102
2103 ✗ bool RunControl::setCfd_convcpl(const std::string& cfd_convcpl) {
2104 ✗ return m_impl->setCfd_convcpl(cfd_convcpl);
2105 }
2106
2107 ✗ int RunControl::cfd_var() const {
2108 ✗ return m_impl->cfd_var();
2109 }
2110
2111 ✗ void RunControl::setCfd_var(const int cfd_var) {
2112 ✗ m_impl->setCfd_var(cfd_var);
2113 ✗ }
2114
2115 ✗ int RunControl::cfd_zref() const {
2116 ✗ return m_impl->cfd_zref();
2117 }
2118
2119 ✗ void RunControl::setCfd_zref(const int cfd_zref) {
2120 ✗ m_impl->setCfd_zref(cfd_zref);
2121 ✗ }
2122
2123 ✗ int RunControl::cfd_imax() const {
2124 ✗ return m_impl->cfd_imax();
2125 }
2126
2127 ✗ void RunControl::setCfd_imax(const int cfd_imax) {
2128 ✗ m_impl->setCfd_imax(cfd_imax);
2129 ✗ }
2130
2131 ✗ int RunControl::cfd_dtcmo() const {
2132 ✗ return m_impl->cfd_dtcmo();
2133 }
2134
2135 ✗ void RunControl::setCfd_dtcmo(const int cfd_dtcmo) {
2136 ✗ m_impl->setCfd_dtcmo(cfd_dtcmo);
2137 ✗ }
2138
2139
2/4
✓ Branch 2 taken 9 times.
✓ Branch 5 taken 9 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
9 Level::Level() : m_impl(std::shared_ptr<detail::LevelImpl>(new detail::LevelImpl)) {}
2140
2141
2/4
✓ Branch 2 taken 3 times.
✓ Branch 5 taken 3 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
3 Level::Level(double delht, std::string name) : m_impl(std::shared_ptr<detail::LevelImpl>(new detail::LevelImpl)) {
2142
1/1
✓ Branch 2 taken 3 times.
3 m_impl->setDelht(delht);
2143
1/1
✓ Branch 2 taken 3 times.
3 m_impl->setName(name);
2144 3 }
2145
2146 ✗ Level::Level(std::string delht, std::string name) : m_impl(std::shared_ptr<detail::LevelImpl>(new detail::LevelImpl)) {
2147 ✗ m_impl->setDelht(delht);
2148 ✗ m_impl->setName(name);
2149 ✗ }
2150
2151 ✗ Level::Level(int nr, double refht, double delht, int u_rfht, int u_dlht, std::string name, std::vector<Icon> icons)
2152 ✗ : m_impl(std::shared_ptr<detail::LevelImpl>(new detail::LevelImpl(nr, refht, delht, u_rfht, u_dlht, name, icons))) {}
2153
2154 ✗ Level::Level(int nr, std::string refht, std::string delht, int u_rfht, int u_dlht, std::string name, std::vector<Icon> icons)
2155 ✗ : m_impl(std::shared_ptr<detail::LevelImpl>(new detail::LevelImpl(nr, refht, delht, u_rfht, u_dlht, name, icons))) {}
2156
2157 86 Level::Level(const Level& other) = default;
2158
2159 ✗ Level& Level::operator=(const Level& other) = default;
2160
2161 3 bool Level::operator==(const Level& other) const {
2162 3 return m_impl == other.m_impl;
2163 }
2164
2165 ✗ bool Level::operator!=(const Level& other) const {
2166 ✗ return m_impl != other.m_impl;
2167 }
2168
2169 1 std::string Level::write() {
2170 1 return m_impl->write();
2171 }
2172
2173 6 void Level::read(Reader& input) {
2174 6 m_impl->read(input);
2175 6 }
2176
2177 ✗ int Level::nr() const {
2178 ✗ return m_impl->nr();
2179 }
2180
2181 9 void Level::setNr(const int nr) {
2182 9 m_impl->setNr(nr);
2183 9 }
2184
2185 51 double Level::refht() const {
2186 51 return m_impl->refht();
2187 }
2188
2189 6 bool Level::setRefht(const double refht) {
2190 6 return m_impl->setRefht(refht);
2191 }
2192
2193 3 bool Level::setRefht(const std::string& refht) {
2194 3 return m_impl->setRefht(refht);
2195 }
2196
2197 2 double Level::delht() const {
2198 2 return m_impl->delht();
2199 }
2200
2201 ✗ bool Level::setDelht(const double delht) {
2202 ✗ return m_impl->setDelht(delht);
2203 }
2204
2205 3 bool Level::setDelht(const std::string& delht) {
2206 3 return m_impl->setDelht(delht);
2207 }
2208
2209 ✗ int Level::u_rfht() const {
2210 ✗ return m_impl->u_rfht();
2211 }
2212
2213 ✗ void Level::setU_rfht(const int u_rfht) {
2214 ✗ m_impl->setU_rfht(u_rfht);
2215 ✗ }
2216
2217 ✗ int Level::u_dlht() const {
2218 ✗ return m_impl->u_dlht();
2219 }
2220
2221 ✗ void Level::setU_dlht(const int u_dlht) {
2222 ✗ m_impl->setU_dlht(u_dlht);
2223 ✗ }
2224
2225 ✗ std::string Level::name() const {
2226 ✗ return m_impl->name();
2227 }
2228
2229 3 void Level::setName(const std::string& name) {
2230 3 m_impl->setName(name);
2231 3 }
2232
2233 ✗ std::vector<Icon> Level::icons() const {
2234 ✗ return m_impl->icons();
2235 }
2236
2237 ✗ void Level::setIcons(const std::vector<Icon>& icons) {
2238 ✗ m_impl->setIcons(icons);
2239 ✗ }
2240
2241
2/4
✓ Branch 2 taken 126 times.
✓ Branch 5 taken 126 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
126 DaySchedule::DaySchedule() : m_impl(std::shared_ptr<detail::DayScheduleImpl>(new detail::DayScheduleImpl())) {}
2242
2243 ✗ DaySchedule::DaySchedule(int nr, int shape, int utyp, int ucnv, std::string name, std::string desc, std::vector<SchedulePoint> points)
2244 ✗ : m_impl(std::shared_ptr<detail::DayScheduleImpl>(new detail::DayScheduleImpl(nr, shape, utyp, ucnv, name, desc, points))) {}
2245
2246 333 DaySchedule::DaySchedule(const DaySchedule& other) = default;
2247
2248 ✗ DaySchedule& DaySchedule::operator=(const DaySchedule& other) = default;
2249
2250 ✗ bool DaySchedule::operator==(const DaySchedule& other) const {
2251 ✗ return m_impl == other.m_impl;
2252 }
2253
2254 ✗ bool DaySchedule::operator!=(const DaySchedule& other) const {
2255 ✗ return m_impl != other.m_impl;
2256 }
2257
2258 21 std::string DaySchedule::write() {
2259 21 return m_impl->write();
2260 }
2261
2262 126 void DaySchedule::read(Reader& input) {
2263 126 m_impl->read(input);
2264 126 }
2265
2266 ✗ int DaySchedule::nr() const {
2267 ✗ return m_impl->nr();
2268 }
2269
2270 ✗ void DaySchedule::setNr(const int nr) {
2271 ✗ m_impl->setNr(nr);
2272 ✗ }
2273
2274 ✗ int DaySchedule::shape() const {
2275 ✗ return m_impl->shape();
2276 }
2277
2278 ✗ void DaySchedule::setShape(const int shape) {
2279 ✗ m_impl->setShape(shape);
2280 ✗ }
2281
2282 ✗ int DaySchedule::utyp() const {
2283 ✗ return m_impl->utyp();
2284 }
2285
2286 ✗ void DaySchedule::setUtyp(const int utyp) {
2287 ✗ m_impl->setUtyp(utyp);
2288 ✗ }
2289
2290 ✗ int DaySchedule::ucnv() const {
2291 ✗ return m_impl->ucnv();
2292 }
2293
2294 ✗ void DaySchedule::setUcnv(const int ucnv) {
2295 ✗ m_impl->setUcnv(ucnv);
2296 ✗ }
2297
2298 ✗ std::string DaySchedule::name() const {
2299 ✗ return m_impl->name();
2300 }
2301
2302 ✗ void DaySchedule::setName(const std::string& name) {
2303 ✗ m_impl->setName(name);
2304 ✗ }
2305
2306 ✗ std::string DaySchedule::desc() const {
2307 ✗ return m_impl->desc();
2308 }
2309
2310 ✗ void DaySchedule::setDesc(const std::string& desc) {
2311 ✗ m_impl->setDesc(desc);
2312 ✗ }
2313
2314 ✗ std::vector<SchedulePoint> DaySchedule::points() const {
2315 ✗ return m_impl->points();
2316 }
2317
2318 ✗ void DaySchedule::setPoints(const std::vector<SchedulePoint>& points) {
2319 ✗ m_impl->setPoints(points);
2320 ✗ }
2321
2322
2/4
✓ Branch 2 taken 126 times.
✓ Branch 5 taken 126 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
126 WeekSchedule::WeekSchedule() : m_impl(std::shared_ptr<detail::WeekScheduleImpl>(new detail::WeekScheduleImpl())) {}
2323
2324 ✗ WeekSchedule::WeekSchedule(int nr, int utyp, int ucnv, std::string name, std::string desc, std::vector<int> j)
2325 ✗ : m_impl(std::shared_ptr<detail::WeekScheduleImpl>(new detail::WeekScheduleImpl(nr, utyp, ucnv, name, desc, j))) {}
2326
2327 333 WeekSchedule::WeekSchedule(const WeekSchedule& other) = default;
2328
2329 ✗ WeekSchedule& WeekSchedule::operator=(const WeekSchedule& other) = default;
2330
2331 ✗ bool WeekSchedule::operator==(const WeekSchedule& other) const {
2332 ✗ return m_impl == other.m_impl;
2333 }
2334
2335 ✗ bool WeekSchedule::operator!=(const WeekSchedule& other) const {
2336 ✗ return m_impl != other.m_impl;
2337 }
2338
2339 21 std::string WeekSchedule::write() {
2340 21 return m_impl->write();
2341 }
2342
2343 126 void WeekSchedule::read(Reader& input) {
2344 126 m_impl->read(input);
2345 126 }
2346
2347 ✗ int WeekSchedule::nr() const {
2348 ✗ return m_impl->nr();
2349 }
2350
2351 ✗ void WeekSchedule::setNr(const int nr) {
2352 ✗ m_impl->setNr(nr);
2353 ✗ }
2354
2355 ✗ int WeekSchedule::utyp() const {
2356 ✗ return m_impl->utyp();
2357 }
2358
2359 ✗ void WeekSchedule::setUtyp(const int utyp) {
2360 ✗ m_impl->setUtyp(utyp);
2361 ✗ }
2362
2363 ✗ int WeekSchedule::ucnv() const {
2364 ✗ return m_impl->ucnv();
2365 }
2366
2367 ✗ void WeekSchedule::setUcnv(const int ucnv) {
2368 ✗ m_impl->setUcnv(ucnv);
2369 ✗ }
2370
2371 ✗ std::string WeekSchedule::name() const {
2372 ✗ return m_impl->name();
2373 }
2374
2375 ✗ void WeekSchedule::setName(const std::string& name) {
2376 ✗ m_impl->setName(name);
2377 ✗ }
2378
2379 ✗ std::string WeekSchedule::desc() const {
2380 ✗ return m_impl->desc();
2381 }
2382
2383 ✗ void WeekSchedule::setDesc(const std::string& desc) {
2384 ✗ m_impl->setDesc(desc);
2385 ✗ }
2386
2387 ✗ std::vector<int> WeekSchedule::j() const {
2388 ✗ return m_impl->j();
2389 }
2390
2391 ✗ void WeekSchedule::setJ(const std::vector<int>& j) {
2392 ✗ m_impl->setJ(j);
2393 ✗ }
2394
2395
2/4
✓ Branch 2 taken 30 times.
✓ Branch 5 taken 30 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
30 WindPressureProfile::WindPressureProfile() : m_impl(std::shared_ptr<detail::WindPressureProfileImpl>(new detail::WindPressureProfileImpl())) {}
2396
2397 ✗ WindPressureProfile::WindPressureProfile(int nr, int type, std::string name, std::string desc, std::vector<PressureCoefficientPoint> coeffs)
2398 ✗ : m_impl(std::shared_ptr<detail::WindPressureProfileImpl>(new detail::WindPressureProfileImpl(nr, type, name, desc, coeffs))) {}
2399
2400 77 WindPressureProfile::WindPressureProfile(const WindPressureProfile& other) = default;
2401
2402 ✗ WindPressureProfile& WindPressureProfile::operator=(const WindPressureProfile& other) = default;
2403
2404 ✗ bool WindPressureProfile::operator==(const WindPressureProfile& other) const {
2405 ✗ return m_impl == other.m_impl;
2406 }
2407
2408 ✗ bool WindPressureProfile::operator!=(const WindPressureProfile& other) const {
2409 ✗ return m_impl != other.m_impl;
2410 }
2411
2412 5 std::string WindPressureProfile::write() {
2413 5 return m_impl->write();
2414 }
2415
2416 30 void WindPressureProfile::read(Reader& input) {
2417 30 m_impl->read(input);
2418 30 }
2419
2420 ✗ int WindPressureProfile::nr() const {
2421 ✗ return m_impl->nr();
2422 }
2423
2424 ✗ void WindPressureProfile::setNr(const int nr) {
2425 ✗ m_impl->setNr(nr);
2426 ✗ }
2427
2428 ✗ int WindPressureProfile::type() const {
2429 ✗ return m_impl->type();
2430 }
2431
2432 ✗ void WindPressureProfile::setType(const int type) {
2433 ✗ m_impl->setType(type);
2434 ✗ }
2435
2436 ✗ std::string WindPressureProfile::name() const {
2437 ✗ return m_impl->name();
2438 }
2439
2440 ✗ void WindPressureProfile::setName(const std::string& name) {
2441 ✗ m_impl->setName(name);
2442 ✗ }
2443
2444 ✗ std::string WindPressureProfile::desc() const {
2445 ✗ return m_impl->desc();
2446 }
2447
2448 ✗ void WindPressureProfile::setDesc(const std::string& desc) {
2449 ✗ m_impl->setDesc(desc);
2450 ✗ }
2451
2452 ✗ std::vector<PressureCoefficientPoint> WindPressureProfile::coeffs() const {
2453 ✗ return m_impl->coeffs();
2454 }
2455
2456 ✗ void WindPressureProfile::setCoeffs(const std::vector<PressureCoefficientPoint>& coeffs) {
2457 ✗ m_impl->setCoeffs(coeffs);
2458 ✗ }
2459
2460 ✗ ControlNodeType ControlNode::convertTag(const std::string& tag) {
2461 try {
2462 ✗ return {tag};
2463 ✗ } catch (...) {
2464 ✗ return ControlNodeType::UNKNOWN;
2465 ✗ }
2466 }
2467
2468 ✗ ControlNode* ControlNode::readElement(Reader& input) {
2469 ✗ ControlNode* out = nullptr;
2470 ✗ int nr = input.read<int>();
2471 ✗ std::string dataType = input.readString();
2472 ✗ int seqnr = input.read<int>();
2473 ✗ auto flags = input.read<unsigned int>();
2474 ✗ int inreq = input.read<int>();
2475 ✗ int n1 = input.read<int>();
2476 ✗ int n2 = input.read<int>();
2477 ✗ std::string name = input.readString();
2478 ✗ std::string desc = input.readLine();
2479
2480 ✗ const ControlNodeType kind = convertTag(dataType);
2481 ✗ if (kind == ControlNodeType::UNKNOWN) {
2482 ✗ LOG_FREE_AND_THROW("openstudio.contam.Reader", "Unknown control node type '" << dataType << "' at line " << input.lineNumber());
2483 ✗ } else if (kind == ControlNodeType::CT_CVF) {
2484 ✗ auto* obj = new CvfDat(nr, seqnr, flags, inreq, n1, n2, name, desc);
2485 ✗ obj->readDetails(input);
2486 ✗ out = static_cast<ControlNode*>(obj);
2487 ✗ } else if (kind == ControlNodeType::CT_DVF) {
2488 ✗ auto* obj = new DvfDat(nr, seqnr, flags, inreq, n1, n2, name, desc);
2489 ✗ obj->readDetails(input);
2490 ✗ out = static_cast<ControlNode*>(obj);
2491 } else {
2492 ✗ LOG_FREE_AND_THROW("openstudio.contam.Reader", "Control node type '" << dataType << "' is not supported.");
2493 }
2494
2495 ✗ return out;
2496 ✗ }
2497
2498 ✗ CdvDat::CdvDat() : m_impl(std::shared_ptr<detail::CdvDatImpl>(new detail::CdvDatImpl())) {}
2499
2500 ✗ CdvDat::CdvDat(int nr, int seqnr, unsigned int flags, int inreq, int n1, int n2, std::string name, std::string desc)
2501 ✗ : m_impl(std::shared_ptr<detail::CdvDatImpl>(new detail::CdvDatImpl(nr, seqnr, flags, inreq, n1, n2, name, desc))) {}
2502
2503 ✗ CdvDat::CdvDat(int nr, int seqnr, unsigned int flags, int inreq, int n1, int n2, std::string name, std::string desc, std::string valuename)
2504 ✗ : m_impl(std::shared_ptr<detail::CdvDatImpl>(new detail::CdvDatImpl(nr, seqnr, flags, inreq, n1, n2, name, desc, valuename))) {}
2505
2506 ✗ CdvDat::CdvDat(const CdvDat& other) : m_impl(other.m_impl) {}
2507
2508 ✗ CdvDat& CdvDat::operator=(const CdvDat& other) {
2509 ✗ m_impl = other.m_impl;
2510 ✗ return *this;
2511 }
2512
2513 ✗ bool CdvDat::operator==(const CdvDat& other) const {
2514 ✗ return m_impl == other.m_impl;
2515 }
2516
2517 ✗ bool CdvDat::operator!=(const CdvDat& other) const {
2518 ✗ return m_impl != other.m_impl;
2519 }
2520
2521 ✗ std::string CdvDat::write() {
2522 ✗ return m_impl->write(dataType());
2523 }
2524
2525 ✗ void CdvDat::read(Reader& input) {
2526 ✗ m_impl->read(input);
2527 ✗ }
2528
2529 ✗ void CdvDat::readDetails(Reader& input) {
2530 ✗ m_impl->readDetails(input);
2531 ✗ }
2532
2533 ✗ int CdvDat::nr() const {
2534 ✗ return m_impl->nr();
2535 }
2536
2537 ✗ void CdvDat::setNr(const int nr) {
2538 ✗ m_impl->setNr(nr);
2539 ✗ }
2540
2541 ✗ int CdvDat::seqnr() const {
2542 ✗ return m_impl->seqnr();
2543 }
2544
2545 ✗ void CdvDat::setSeqnr(const int seqnr) {
2546 ✗ m_impl->setSeqnr(seqnr);
2547 ✗ }
2548
2549 ✗ unsigned int CdvDat::flags() const {
2550 ✗ return m_impl->flags();
2551 }
2552
2553 ✗ void CdvDat::setFlags(const unsigned int flags) {
2554 ✗ m_impl->setFlags(flags);
2555 ✗ }
2556
2557 ✗ int CdvDat::inreq() const {
2558 ✗ return m_impl->inreq();
2559 }
2560
2561 ✗ void CdvDat::setInreq(const int inreq) {
2562 ✗ m_impl->setInreq(inreq);
2563 ✗ }
2564
2565 ✗ int CdvDat::n1() const {
2566 ✗ return m_impl->n1();
2567 }
2568
2569 ✗ void CdvDat::setN1(const int n1) {
2570 ✗ m_impl->setN1(n1);
2571 ✗ }
2572
2573 ✗ int CdvDat::n2() const {
2574 ✗ return m_impl->n2();
2575 }
2576
2577 ✗ void CdvDat::setN2(const int n2) {
2578 ✗ m_impl->setN2(n2);
2579 ✗ }
2580
2581 ✗ std::string CdvDat::name() const {
2582 ✗ return m_impl->name();
2583 }
2584
2585 ✗ void CdvDat::setName(const std::string& name) {
2586 ✗ m_impl->setName(name);
2587 ✗ }
2588
2589 ✗ std::string CdvDat::desc() const {
2590 ✗ return m_impl->desc();
2591 }
2592
2593 ✗ void CdvDat::setDesc(const std::string& desc) {
2594 ✗ m_impl->setDesc(desc);
2595 ✗ }
2596
2597 ✗ std::string CdvDat::valuename() const {
2598 ✗ return m_impl->valuename();
2599 }
2600
2601 ✗ void CdvDat::setValuename(const std::string& valuename) {
2602 ✗ m_impl->setValuename(valuename);
2603 ✗ }
2604
2605 ✗ CvfDat::CvfDat() : CdvDat() {}
2606
2607 ✗ CvfDat::CvfDat(int nr, int seqnr, unsigned int flags, int inreq, int n1, int n2, std::string name, std::string desc)
2608 ✗ : CdvDat(nr, seqnr, flags, inreq, n1, n2, name, desc) {}
2609
2610 ✗ CvfDat::CvfDat(int nr, int seqnr, unsigned int flags, int inreq, int n1, int n2, std::string name, std::string desc, std::string valuename)
2611 ✗ : CdvDat(nr, seqnr, flags, inreq, n1, n2, name, desc, valuename) {}
2612
2613 ✗ DvfDat::DvfDat() : CdvDat() {}
2614
2615 ✗ DvfDat::DvfDat(int nr, int seqnr, unsigned int flags, int inreq, int n1, int n2, std::string name, std::string desc)
2616 ✗ : CdvDat(nr, seqnr, flags, inreq, n1, n2, name, desc) {}
2617
2618 ✗ DvfDat::DvfDat(int nr, int seqnr, unsigned int flags, int inreq, int n1, int n2, std::string name, std::string desc, std::string valuename)
2619 ✗ : CdvDat(nr, seqnr, flags, inreq, n1, n2, name, desc, valuename) {}
2620
2621 } // namespace contam
2622 } // namespace openstudio
2623