GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 43.7% 87 / 0 / 199
Functions: 43.1% 25 / 0 / 58
Branches: 20.2% 38 / 0 / 188

src/model/AvailabilityManagerOptimumStart.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 "AvailabilityManagerOptimumStart.hpp"
7 #include "AvailabilityManagerOptimumStart_Impl.hpp"
8 #include "Model.hpp"
9 #include "Model_Impl.hpp"
10 #include "Schedule.hpp"
11 #include "Schedule_Impl.hpp"
12 #include "ThermalZone.hpp"
13 #include "ThermalZone_Impl.hpp"
14 #include "ScheduleTypeLimits.hpp"
15 #include "ScheduleTypeRegistry.hpp"
16 #include <utilities/idd/IddFactory.hxx>
17 #include <utilities/idd/OS_AvailabilityManager_OptimumStart_FieldEnums.hxx>
18 #include "../utilities/units/Unit.hpp"
19 #include "../utilities/core/Assert.hpp"
20
21 namespace openstudio {
22 namespace model {
23
24 namespace detail {
25
26 3 AvailabilityManagerOptimumStart_Impl::AvailabilityManagerOptimumStart_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
27 3 : AvailabilityManager_Impl(idfObject, model, keepHandle) {
28
4/6
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 3 times.
✗ Branch 13 not taken.
3 OS_ASSERT(idfObject.iddObject().type() == AvailabilityManagerOptimumStart::iddObjectType());
29 3 }
30
31 ✗ AvailabilityManagerOptimumStart_Impl::AvailabilityManagerOptimumStart_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
32 ✗ Model_Impl* model, bool keepHandle)
33 ✗ : AvailabilityManager_Impl(other, model, keepHandle) {
34 ✗ OS_ASSERT(other.iddObject().type() == AvailabilityManagerOptimumStart::iddObjectType());
35 ✗ }
36
37 8 AvailabilityManagerOptimumStart_Impl::AvailabilityManagerOptimumStart_Impl(const AvailabilityManagerOptimumStart_Impl& other, Model_Impl* model,
38 8 bool keepHandle)
39 8 : AvailabilityManager_Impl(other, model, keepHandle) {}
40
41 ✗ const std::vector<std::string>& AvailabilityManagerOptimumStart_Impl::outputVariableNames() const {
42 static const std::vector<std::string> result{"Availability Manager Optimum Start Control Status",
43 ✗ "Availability Manager Optimum Start Time Before Occupancy"};
44 ✗ return result;
45 ✗ }
46
47 1 IddObjectType AvailabilityManagerOptimumStart_Impl::iddObjectType() const {
48 1 return AvailabilityManagerOptimumStart::iddObjectType();
49 }
50
51 ✗ std::vector<ScheduleTypeKey> AvailabilityManagerOptimumStart_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
52 ✗ std::vector<ScheduleTypeKey> result;
53 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
54 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
55 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
56 ✗ if (std::find(b, e, OS_AvailabilityManager_OptimumStartFields::ApplicabilitySchedule) != e) {
57 ✗ result.push_back(ScheduleTypeKey("AvailabilityManagerOptimumStart", "Applicability Schedule"));
58 }
59 ✗ if (std::find(b, e, OS_AvailabilityManager_OptimumStartFields::FanSchedule) != e) {
60 ✗ result.push_back(ScheduleTypeKey("AvailabilityManagerOptimumStart", "Fan Schedule"));
61 }
62 ✗ return result;
63 ✗ }
64
65 ✗ Schedule AvailabilityManagerOptimumStart_Impl::applicabilitySchedule() const {
66 ✗ boost::optional<Schedule> value = optionalApplicabilitySchedule();
67 ✗ if (!value) {
68 ✗ LOG_AND_THROW(briefDescription() << " does not have an Applicability Schedule attached.");
69 }
70 ✗ return value.get();
71 ✗ }
72
73 ✗ std::string AvailabilityManagerOptimumStart_Impl::controlType() const {
74 ✗ boost::optional<std::string> value = getString(OS_AvailabilityManager_OptimumStartFields::ControlType, true);
75 ✗ OS_ASSERT(value);
76 ✗ return value.get();
77 ✗ }
78
79 ✗ boost::optional<ThermalZone> AvailabilityManagerOptimumStart_Impl::controlZone() const {
80 ✗ return getObject<ModelObject>().getModelObjectTarget<ThermalZone>(OS_AvailabilityManager_OptimumStartFields::ControlZone);
81 }
82
83 ✗ double AvailabilityManagerOptimumStart_Impl::maximumValueforOptimumStartTime() const {
84 ✗ boost::optional<double> value = getDouble(OS_AvailabilityManager_OptimumStartFields::MaximumValueforOptimumStartTime, true);
85 ✗ OS_ASSERT(value);
86 ✗ return value.get();
87 }
88
89 ✗ std::string AvailabilityManagerOptimumStart_Impl::controlAlgorithm() const {
90 ✗ boost::optional<std::string> value = getString(OS_AvailabilityManager_OptimumStartFields::ControlAlgorithm, true);
91 ✗ OS_ASSERT(value);
92 ✗ return value.get();
93 ✗ }
94
95 ✗ double AvailabilityManagerOptimumStart_Impl::constantTemperatureGradientduringCooling() const {
96 ✗ boost::optional<double> value = getDouble(OS_AvailabilityManager_OptimumStartFields::ConstantTemperatureGradientduringCooling, true);
97 ✗ OS_ASSERT(value);
98 ✗ return value.get();
99 }
100
101 ✗ double AvailabilityManagerOptimumStart_Impl::constantTemperatureGradientduringHeating() const {
102 ✗ boost::optional<double> value = getDouble(OS_AvailabilityManager_OptimumStartFields::ConstantTemperatureGradientduringHeating, true);
103 ✗ OS_ASSERT(value);
104 ✗ return value.get();
105 }
106
107 ✗ double AvailabilityManagerOptimumStart_Impl::initialTemperatureGradientduringCooling() const {
108 ✗ boost::optional<double> value = getDouble(OS_AvailabilityManager_OptimumStartFields::InitialTemperatureGradientduringCooling, true);
109 ✗ OS_ASSERT(value);
110 ✗ return value.get();
111 }
112
113 ✗ double AvailabilityManagerOptimumStart_Impl::initialTemperatureGradientduringHeating() const {
114 ✗ boost::optional<double> value = getDouble(OS_AvailabilityManager_OptimumStartFields::InitialTemperatureGradientduringHeating, true);
115 ✗ OS_ASSERT(value);
116 ✗ return value.get();
117 }
118
119 ✗ double AvailabilityManagerOptimumStart_Impl::constantStartTime() const {
120 ✗ boost::optional<double> value = getDouble(OS_AvailabilityManager_OptimumStartFields::ConstantStartTime, true);
121 ✗ OS_ASSERT(value);
122 ✗ return value.get();
123 }
124
125 ✗ int AvailabilityManagerOptimumStart_Impl::numberofPreviousDays() const {
126 ✗ boost::optional<int> value = getInt(OS_AvailabilityManager_OptimumStartFields::NumberofPreviousDays, true);
127 ✗ OS_ASSERT(value);
128 ✗ return value.get();
129 }
130
131 3 bool AvailabilityManagerOptimumStart_Impl::setApplicabilitySchedule(Schedule& schedule) {
132
3/3
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
12 bool result = setSchedule(OS_AvailabilityManager_OptimumStartFields::ApplicabilitySchedule, "AvailabilityManagerOptimumStart",
133 "Applicability Schedule", schedule);
134 3 return result;
135 }
136
137 3 bool AvailabilityManagerOptimumStart_Impl::setControlType(const std::string& controlType) {
138 3 bool result = setString(OS_AvailabilityManager_OptimumStartFields::ControlType, controlType);
139 3 return result;
140 }
141
142 ✗ bool AvailabilityManagerOptimumStart_Impl::setControlZone(const boost::optional<ThermalZone>& thermalZone) {
143 ✗ bool result(false);
144 ✗ if (thermalZone) {
145 ✗ result = setPointer(OS_AvailabilityManager_OptimumStartFields::ControlZone, thermalZone.get().handle());
146 } else {
147 ✗ resetControlZone();
148 ✗ result = true;
149 }
150 ✗ return result;
151 }
152
153 ✗ void AvailabilityManagerOptimumStart_Impl::resetControlZone() {
154 ✗ bool result = setString(OS_AvailabilityManager_OptimumStartFields::ControlZone, "");
155 ✗ OS_ASSERT(result);
156 ✗ }
157
158 3 bool AvailabilityManagerOptimumStart_Impl::setMaximumValueforOptimumStartTime(double maximumValueforOptimumStartTime) {
159 3 bool result = setDouble(OS_AvailabilityManager_OptimumStartFields::MaximumValueforOptimumStartTime, maximumValueforOptimumStartTime);
160
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 OS_ASSERT(result);
161 3 return result;
162 }
163
164 3 bool AvailabilityManagerOptimumStart_Impl::setControlAlgorithm(const std::string& controlAlgorithm) {
165 3 bool result = setString(OS_AvailabilityManager_OptimumStartFields::ControlAlgorithm, controlAlgorithm);
166 3 return result;
167 }
168
169 3 bool AvailabilityManagerOptimumStart_Impl::setConstantTemperatureGradientduringCooling(double constantTemperatureGradientduringCooling) {
170 bool result =
171 3 setDouble(OS_AvailabilityManager_OptimumStartFields::ConstantTemperatureGradientduringCooling, constantTemperatureGradientduringCooling);
172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 OS_ASSERT(result);
173 3 return result;
174 }
175
176 3 bool AvailabilityManagerOptimumStart_Impl::setConstantTemperatureGradientduringHeating(double constantTemperatureGradientduringHeating) {
177 bool result =
178 3 setDouble(OS_AvailabilityManager_OptimumStartFields::ConstantTemperatureGradientduringHeating, constantTemperatureGradientduringHeating);
179
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 OS_ASSERT(result);
180 3 return result;
181 }
182
183 3 bool AvailabilityManagerOptimumStart_Impl::setInitialTemperatureGradientduringCooling(double initialTemperatureGradientduringCooling) {
184 bool result =
185 3 setDouble(OS_AvailabilityManager_OptimumStartFields::InitialTemperatureGradientduringCooling, initialTemperatureGradientduringCooling);
186
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 OS_ASSERT(result);
187 3 return result;
188 }
189
190 3 bool AvailabilityManagerOptimumStart_Impl::setInitialTemperatureGradientduringHeating(double initialTemperatureGradientduringHeating) {
191 bool result =
192 3 setDouble(OS_AvailabilityManager_OptimumStartFields::InitialTemperatureGradientduringHeating, initialTemperatureGradientduringHeating);
193
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 OS_ASSERT(result);
194 3 return result;
195 }
196
197 3 bool AvailabilityManagerOptimumStart_Impl::setConstantStartTime(double constantStartTime) {
198 3 bool result = setDouble(OS_AvailabilityManager_OptimumStartFields::ConstantStartTime, constantStartTime);
199
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 OS_ASSERT(result);
200 3 return result;
201 }
202
203 3 bool AvailabilityManagerOptimumStart_Impl::setNumberofPreviousDays(int numberofPreviousDays) {
204 3 bool result = setInt(OS_AvailabilityManager_OptimumStartFields::NumberofPreviousDays, numberofPreviousDays);
205 3 return result;
206 }
207
208 ✗ boost::optional<Schedule> AvailabilityManagerOptimumStart_Impl::optionalApplicabilitySchedule() const {
209 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_AvailabilityManager_OptimumStartFields::ApplicabilitySchedule);
210 }
211
212 } // namespace detail
213
214 3 AvailabilityManagerOptimumStart::AvailabilityManagerOptimumStart(const Model& model)
215 3 : AvailabilityManager(AvailabilityManagerOptimumStart::iddObjectType(), model) {
216
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
✗ Branch 5 not taken.
3 OS_ASSERT(getImpl<detail::AvailabilityManagerOptimumStart_Impl>());
217
218 {
219
1/1
✓ Branch 1 taken 3 times.
3 auto schedule = model.alwaysOnDiscreteSchedule();
220
1/1
✓ Branch 1 taken 3 times.
3 setApplicabilitySchedule(schedule);
221 3 }
222
223
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
3 setControlType("MaximumofZoneList");
224
1/1
✓ Branch 1 taken 3 times.
3 setMaximumValueforOptimumStartTime(6.0);
225
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
3 setControlAlgorithm("AdaptiveTemperatureGradient");
226
1/1
✓ Branch 1 taken 3 times.
3 setConstantTemperatureGradientduringCooling(3.0);
227
1/1
✓ Branch 1 taken 3 times.
3 setConstantTemperatureGradientduringHeating(3.0);
228
1/1
✓ Branch 1 taken 3 times.
3 setInitialTemperatureGradientduringCooling(2.0);
229
1/1
✓ Branch 1 taken 3 times.
3 setInitialTemperatureGradientduringHeating(2.0);
230
1/1
✓ Branch 1 taken 3 times.
3 setConstantStartTime(2.0);
231
1/1
✓ Branch 1 taken 3 times.
3 setNumberofPreviousDays(3);
232 3 }
233
234 7605 IddObjectType AvailabilityManagerOptimumStart::iddObjectType() {
235
1/1
✓ Branch 1 taken 7605 times.
7605 return {IddObjectType::OS_AvailabilityManager_OptimumStart};
236 }
237
238 ✗ std::vector<std::string> AvailabilityManagerOptimumStart::controlTypeValues() {
239 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AvailabilityManager_OptimumStartFields::ControlType);
240 }
241
242 ✗ std::vector<std::string> AvailabilityManagerOptimumStart::controlAlgorithmValues() {
243 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AvailabilityManager_OptimumStartFields::ControlAlgorithm);
244 }
245
246 ✗ Schedule AvailabilityManagerOptimumStart::applicabilitySchedule() const {
247 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->applicabilitySchedule();
248 }
249
250 ✗ std::string AvailabilityManagerOptimumStart::controlType() const {
251 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->controlType();
252 }
253
254 ✗ boost::optional<ThermalZone> AvailabilityManagerOptimumStart::controlZone() const {
255 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->controlZone();
256 }
257
258 ✗ double AvailabilityManagerOptimumStart::maximumValueforOptimumStartTime() const {
259 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->maximumValueforOptimumStartTime();
260 }
261
262 ✗ std::string AvailabilityManagerOptimumStart::controlAlgorithm() const {
263 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->controlAlgorithm();
264 }
265
266 ✗ double AvailabilityManagerOptimumStart::constantTemperatureGradientduringCooling() const {
267 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->constantTemperatureGradientduringCooling();
268 }
269
270 ✗ double AvailabilityManagerOptimumStart::constantTemperatureGradientduringHeating() const {
271 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->constantTemperatureGradientduringHeating();
272 }
273
274 ✗ double AvailabilityManagerOptimumStart::initialTemperatureGradientduringCooling() const {
275 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->initialTemperatureGradientduringCooling();
276 }
277
278 ✗ double AvailabilityManagerOptimumStart::initialTemperatureGradientduringHeating() const {
279 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->initialTemperatureGradientduringHeating();
280 }
281
282 ✗ double AvailabilityManagerOptimumStart::constantStartTime() const {
283 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->constantStartTime();
284 }
285
286 ✗ int AvailabilityManagerOptimumStart::numberofPreviousDays() const {
287 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->numberofPreviousDays();
288 }
289
290 3 bool AvailabilityManagerOptimumStart::setApplicabilitySchedule(Schedule& schedule) {
291
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setApplicabilitySchedule(schedule);
292 }
293
294 3 bool AvailabilityManagerOptimumStart::setControlType(const std::string& controlType) {
295
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setControlType(controlType);
296 }
297
298 ✗ bool AvailabilityManagerOptimumStart::setControlZone(const ThermalZone& thermalZone) {
299 ✗ return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setControlZone(thermalZone);
300 }
301
302 ✗ void AvailabilityManagerOptimumStart::resetControlZone() {
303 ✗ getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->resetControlZone();
304 ✗ }
305
306 3 bool AvailabilityManagerOptimumStart::setMaximumValueforOptimumStartTime(double maximumValueforOptimumStartTime) {
307
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setMaximumValueforOptimumStartTime(maximumValueforOptimumStartTime);
308 }
309
310 3 bool AvailabilityManagerOptimumStart::setControlAlgorithm(const std::string& controlAlgorithm) {
311
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setControlAlgorithm(controlAlgorithm);
312 }
313
314 3 bool AvailabilityManagerOptimumStart::setConstantTemperatureGradientduringCooling(double constantTemperatureGradientduringCooling) {
315
1/1
✓ Branch 3 taken 3 times.
6 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setConstantTemperatureGradientduringCooling(
316 6 constantTemperatureGradientduringCooling);
317 }
318
319 3 bool AvailabilityManagerOptimumStart::setConstantTemperatureGradientduringHeating(double constantTemperatureGradientduringHeating) {
320
1/1
✓ Branch 3 taken 3 times.
6 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setConstantTemperatureGradientduringHeating(
321 6 constantTemperatureGradientduringHeating);
322 }
323
324 3 bool AvailabilityManagerOptimumStart::setInitialTemperatureGradientduringCooling(double initialTemperatureGradientduringCooling) {
325
1/1
✓ Branch 3 taken 3 times.
6 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setInitialTemperatureGradientduringCooling(
326 6 initialTemperatureGradientduringCooling);
327 }
328
329 3 bool AvailabilityManagerOptimumStart::setInitialTemperatureGradientduringHeating(double initialTemperatureGradientduringHeating) {
330
1/1
✓ Branch 3 taken 3 times.
6 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setInitialTemperatureGradientduringHeating(
331 6 initialTemperatureGradientduringHeating);
332 }
333
334 3 bool AvailabilityManagerOptimumStart::setConstantStartTime(double constantStartTime) {
335
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setConstantStartTime(constantStartTime);
336 }
337
338 3 bool AvailabilityManagerOptimumStart::setNumberofPreviousDays(int numberofPreviousDays) {
339
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AvailabilityManagerOptimumStart_Impl>()->setNumberofPreviousDays(numberofPreviousDays);
340 }
341
342 /// @cond
343 ✗ AvailabilityManagerOptimumStart::AvailabilityManagerOptimumStart(std::shared_ptr<detail::AvailabilityManagerOptimumStart_Impl> impl)
344 ✗ : AvailabilityManager(std::move(impl)) {}
345 /// @endcond
346
347 } // namespace model
348 } // namespace openstudio
349