GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 0.9% 2 / 0 / 216
Functions: 1.4% 1 / 0 / 69
Branches: 0.6% 1 / 0 / 157

src/model/ZoneControlThermostatStagedDualSetpoint.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 "ZoneControlThermostatStagedDualSetpoint.hpp"
7 #include "ZoneControlThermostatStagedDualSetpoint_Impl.hpp"
8 #include "Schedule.hpp"
9 #include "Schedule_Impl.hpp"
10 #include "ScheduleTypeLimits.hpp"
11 #include "ScheduleTypeRegistry.hpp"
12 #include <utilities/idd/OS_ZoneControl_Thermostat_StagedDualSetpoint_FieldEnums.hxx>
13 #include <utilities/idd/IddEnums.hxx>
14 #include "../utilities/units/Unit.hpp"
15 #include "../utilities/core/Assert.hpp"
16
17 namespace openstudio {
18 namespace model {
19
20 namespace detail {
21
22 ✗ ZoneControlThermostatStagedDualSetpoint_Impl::ZoneControlThermostatStagedDualSetpoint_Impl(const IdfObject& idfObject, Model_Impl* model,
23 ✗ bool keepHandle)
24 ✗ : Thermostat_Impl(idfObject, model, keepHandle) {
25 ✗ OS_ASSERT(idfObject.iddObject().type() == ZoneControlThermostatStagedDualSetpoint::iddObjectType());
26 ✗ }
27
28 ✗ ZoneControlThermostatStagedDualSetpoint_Impl::ZoneControlThermostatStagedDualSetpoint_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
29 ✗ Model_Impl* model, bool keepHandle)
30 ✗ : Thermostat_Impl(other, model, keepHandle) {
31 ✗ OS_ASSERT(other.iddObject().type() == ZoneControlThermostatStagedDualSetpoint::iddObjectType());
32 ✗ }
33
34 ✗ ZoneControlThermostatStagedDualSetpoint_Impl::ZoneControlThermostatStagedDualSetpoint_Impl(
35 ✗ const ZoneControlThermostatStagedDualSetpoint_Impl& other, Model_Impl* model, bool keepHandle)
36 ✗ : Thermostat_Impl(other, model, keepHandle) {}
37
38 ✗ const std::vector<std::string>& ZoneControlThermostatStagedDualSetpoint_Impl::outputVariableNames() const {
39 ✗ static const std::vector<std::string> result;
40 ✗ return result;
41 }
42
43 ✗ IddObjectType ZoneControlThermostatStagedDualSetpoint_Impl::iddObjectType() const {
44 ✗ return ZoneControlThermostatStagedDualSetpoint::iddObjectType();
45 }
46
47 ✗ std::vector<ScheduleTypeKey> ZoneControlThermostatStagedDualSetpoint_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
48 ✗ std::vector<ScheduleTypeKey> result;
49 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
50 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
51 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
52 ✗ if (std::find(b, e, OS_ZoneControl_Thermostat_StagedDualSetpointFields::HeatingTemperatureSetpointSchedule) != e) {
53 ✗ result.push_back(ScheduleTypeKey("ZoneControlThermostatStagedDualSetpoint", "Heating Temperature Setpoint Schedule"));
54 }
55 ✗ if (std::find(b, e, OS_ZoneControl_Thermostat_StagedDualSetpointFields::CoolingTemperatureSetpointBaseSchedule) != e) {
56 ✗ result.push_back(ScheduleTypeKey("ZoneControlThermostatStagedDualSetpoint", "Cooling Temperature Setpoint Base Schedule"));
57 }
58 ✗ return result;
59 ✗ }
60
61 ✗ int ZoneControlThermostatStagedDualSetpoint_Impl::numberofHeatingStages() const {
62 ✗ boost::optional<int> value = getInt(OS_ZoneControl_Thermostat_StagedDualSetpointFields::NumberofHeatingStages, true);
63 ✗ OS_ASSERT(value);
64 ✗ return value.get();
65 }
66
67 ✗ boost::optional<Schedule> ZoneControlThermostatStagedDualSetpoint_Impl::heatingTemperatureSetpointSchedule() const {
68 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(
69 ✗ OS_ZoneControl_Thermostat_StagedDualSetpointFields::HeatingTemperatureSetpointSchedule);
70 }
71
72 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::heatingThrottlingTemperatureRange() const {
73 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::HeatingThrottlingTemperatureRange, true);
74 ✗ OS_ASSERT(value);
75 ✗ return value.get();
76 }
77
78 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage1HeatingTemperatureOffset() const {
79 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage1HeatingTemperatureOffset, true);
80 ✗ OS_ASSERT(value);
81 ✗ return value.get();
82 }
83
84 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage2HeatingTemperatureOffset() const {
85 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage2HeatingTemperatureOffset, true);
86 ✗ OS_ASSERT(value);
87 ✗ return value.get();
88 }
89
90 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage3HeatingTemperatureOffset() const {
91 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage3HeatingTemperatureOffset, true);
92 ✗ OS_ASSERT(value);
93 ✗ return value.get();
94 }
95
96 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage4HeatingTemperatureOffset() const {
97 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage4HeatingTemperatureOffset, true);
98 ✗ OS_ASSERT(value);
99 ✗ return value.get();
100 }
101
102 ✗ int ZoneControlThermostatStagedDualSetpoint_Impl::numberofCoolingStages() const {
103 ✗ boost::optional<int> value = getInt(OS_ZoneControl_Thermostat_StagedDualSetpointFields::NumberofCoolingStages, true);
104 ✗ OS_ASSERT(value);
105 ✗ return value.get();
106 }
107
108 ✗ boost::optional<Schedule> ZoneControlThermostatStagedDualSetpoint_Impl::coolingTemperatureSetpointBaseSchedule() const {
109 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(
110 ✗ OS_ZoneControl_Thermostat_StagedDualSetpointFields::CoolingTemperatureSetpointBaseSchedule);
111 }
112
113 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::coolingThrottlingTemperatureRange() const {
114 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::CoolingThrottlingTemperatureRange, true);
115 ✗ OS_ASSERT(value);
116 ✗ return value.get();
117 }
118
119 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage1CoolingTemperatureOffset() const {
120 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage1CoolingTemperatureOffset, true);
121 ✗ OS_ASSERT(value);
122 ✗ return value.get();
123 }
124
125 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage2CoolingTemperatureOffset() const {
126 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage2CoolingTemperatureOffset, true);
127 ✗ OS_ASSERT(value);
128 ✗ return value.get();
129 }
130
131 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage3CoolingTemperatureOffset() const {
132 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage3CoolingTemperatureOffset, true);
133 ✗ OS_ASSERT(value);
134 ✗ return value.get();
135 }
136
137 ✗ double ZoneControlThermostatStagedDualSetpoint_Impl::stage4CoolingTemperatureOffset() const {
138 ✗ boost::optional<double> value = getDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage4CoolingTemperatureOffset, true);
139 ✗ OS_ASSERT(value);
140 ✗ return value.get();
141 }
142
143 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setNumberofHeatingStages(int numberofHeatingStages) {
144 ✗ bool result = setInt(OS_ZoneControl_Thermostat_StagedDualSetpointFields::NumberofHeatingStages, numberofHeatingStages);
145 ✗ return result;
146 }
147
148 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setHeatingTemperatureSetpointSchedule(Schedule& schedule) {
149 ✗ bool result = setSchedule(OS_ZoneControl_Thermostat_StagedDualSetpointFields::HeatingTemperatureSetpointSchedule,
150 "ZoneControlThermostatStagedDualSetpoint", "Heating Temperature Setpoint Schedule", schedule);
151 ✗ return result;
152 }
153
154 ✗ void ZoneControlThermostatStagedDualSetpoint_Impl::resetHeatingTemperatureSetpointSchedule() {
155 ✗ bool result = setString(OS_ZoneControl_Thermostat_StagedDualSetpointFields::HeatingTemperatureSetpointSchedule, "");
156 ✗ OS_ASSERT(result);
157 ✗ }
158
159 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setHeatingThrottlingTemperatureRange(double heatingThrottlingTemperatureRange) {
160 bool result =
161 ✗ setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::HeatingThrottlingTemperatureRange, heatingThrottlingTemperatureRange);
162 ✗ return result;
163 }
164
165 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage1HeatingTemperatureOffset(double stage1HeatingTemperatureOffset) {
166 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage1HeatingTemperatureOffset, stage1HeatingTemperatureOffset);
167 ✗ return result;
168 }
169
170 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage2HeatingTemperatureOffset(double stage2HeatingTemperatureOffset) {
171 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage2HeatingTemperatureOffset, stage2HeatingTemperatureOffset);
172 ✗ return result;
173 }
174
175 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage3HeatingTemperatureOffset(double stage3HeatingTemperatureOffset) {
176 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage3HeatingTemperatureOffset, stage3HeatingTemperatureOffset);
177 ✗ return result;
178 }
179
180 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage4HeatingTemperatureOffset(double stage4HeatingTemperatureOffset) {
181 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage4HeatingTemperatureOffset, stage4HeatingTemperatureOffset);
182 ✗ return result;
183 }
184
185 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setNumberofCoolingStages(int numberofCoolingStages) {
186 ✗ bool result = setInt(OS_ZoneControl_Thermostat_StagedDualSetpointFields::NumberofCoolingStages, numberofCoolingStages);
187 ✗ return result;
188 }
189
190 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setCoolingTemperatureSetpointBaseSchedule(Schedule& schedule) {
191 ✗ bool result = setSchedule(OS_ZoneControl_Thermostat_StagedDualSetpointFields::CoolingTemperatureSetpointBaseSchedule,
192 "ZoneControlThermostatStagedDualSetpoint", "Cooling Temperature Setpoint Base Schedule", schedule);
193 ✗ return result;
194 }
195
196 ✗ void ZoneControlThermostatStagedDualSetpoint_Impl::resetCoolingTemperatureSetpointBaseSchedule() {
197 ✗ bool result = setString(OS_ZoneControl_Thermostat_StagedDualSetpointFields::CoolingTemperatureSetpointBaseSchedule, "");
198 ✗ OS_ASSERT(result);
199 ✗ }
200
201 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setCoolingThrottlingTemperatureRange(double coolingThrottlingTemperatureRange) {
202 bool result =
203 ✗ setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::CoolingThrottlingTemperatureRange, coolingThrottlingTemperatureRange);
204 ✗ return result;
205 }
206
207 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage1CoolingTemperatureOffset(double stage1CoolingTemperatureOffset) {
208 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage1CoolingTemperatureOffset, stage1CoolingTemperatureOffset);
209 ✗ return result;
210 }
211
212 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage2CoolingTemperatureOffset(double stage2CoolingTemperatureOffset) {
213 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage2CoolingTemperatureOffset, stage2CoolingTemperatureOffset);
214 ✗ return result;
215 }
216
217 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage3CoolingTemperatureOffset(double stage3CoolingTemperatureOffset) {
218 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage3CoolingTemperatureOffset, stage3CoolingTemperatureOffset);
219 ✗ return result;
220 }
221
222 ✗ bool ZoneControlThermostatStagedDualSetpoint_Impl::setStage4CoolingTemperatureOffset(double stage4CoolingTemperatureOffset) {
223 ✗ bool result = setDouble(OS_ZoneControl_Thermostat_StagedDualSetpointFields::Stage4CoolingTemperatureOffset, stage4CoolingTemperatureOffset);
224 ✗ return result;
225 }
226
227 } // namespace detail
228
229 ✗ ZoneControlThermostatStagedDualSetpoint::ZoneControlThermostatStagedDualSetpoint(const Model& model)
230 ✗ : Thermostat(ZoneControlThermostatStagedDualSetpoint::iddObjectType(), model) {
231 ✗ OS_ASSERT(getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>());
232
233 ✗ setNumberofHeatingStages(2);
234 ✗ setHeatingThrottlingTemperatureRange(1.1);
235 ✗ setStage1HeatingTemperatureOffset(0.0);
236 ✗ setStage2HeatingTemperatureOffset(-0.5);
237 ✗ setStage3HeatingTemperatureOffset(-1.0);
238 ✗ setStage4HeatingTemperatureOffset(-1.5);
239 ✗ setNumberofCoolingStages(4);
240 ✗ setCoolingThrottlingTemperatureRange(1.1);
241 ✗ setStage1CoolingTemperatureOffset(0.0);
242 ✗ setStage2CoolingTemperatureOffset(1.0);
243 ✗ setStage3CoolingTemperatureOffset(2.0);
244 ✗ setStage4CoolingTemperatureOffset(3.0);
245 ✗ }
246
247 7775 IddObjectType ZoneControlThermostatStagedDualSetpoint::iddObjectType() {
248
1/1
✓ Branch 1 taken 7775 times.
7775 return {IddObjectType::OS_ZoneControl_Thermostat_StagedDualSetpoint};
249 }
250
251 ✗ int ZoneControlThermostatStagedDualSetpoint::numberofHeatingStages() const {
252 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->numberofHeatingStages();
253 }
254
255 ✗ boost::optional<Schedule> ZoneControlThermostatStagedDualSetpoint::heatingTemperatureSetpointSchedule() const {
256 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->heatingTemperatureSetpointSchedule();
257 }
258
259 ✗ double ZoneControlThermostatStagedDualSetpoint::heatingThrottlingTemperatureRange() const {
260 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->heatingThrottlingTemperatureRange();
261 }
262
263 ✗ double ZoneControlThermostatStagedDualSetpoint::stage1HeatingTemperatureOffset() const {
264 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage1HeatingTemperatureOffset();
265 }
266
267 ✗ double ZoneControlThermostatStagedDualSetpoint::stage2HeatingTemperatureOffset() const {
268 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage2HeatingTemperatureOffset();
269 }
270
271 ✗ double ZoneControlThermostatStagedDualSetpoint::stage3HeatingTemperatureOffset() const {
272 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage3HeatingTemperatureOffset();
273 }
274
275 ✗ double ZoneControlThermostatStagedDualSetpoint::stage4HeatingTemperatureOffset() const {
276 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage4HeatingTemperatureOffset();
277 }
278
279 ✗ int ZoneControlThermostatStagedDualSetpoint::numberofCoolingStages() const {
280 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->numberofCoolingStages();
281 }
282
283 ✗ boost::optional<Schedule> ZoneControlThermostatStagedDualSetpoint::coolingTemperatureSetpointBaseSchedule() const {
284 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->coolingTemperatureSetpointBaseSchedule();
285 }
286
287 ✗ double ZoneControlThermostatStagedDualSetpoint::coolingThrottlingTemperatureRange() const {
288 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->coolingThrottlingTemperatureRange();
289 }
290
291 ✗ double ZoneControlThermostatStagedDualSetpoint::stage1CoolingTemperatureOffset() const {
292 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage1CoolingTemperatureOffset();
293 }
294
295 ✗ double ZoneControlThermostatStagedDualSetpoint::stage2CoolingTemperatureOffset() const {
296 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage2CoolingTemperatureOffset();
297 }
298
299 ✗ double ZoneControlThermostatStagedDualSetpoint::stage3CoolingTemperatureOffset() const {
300 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage3CoolingTemperatureOffset();
301 }
302
303 ✗ double ZoneControlThermostatStagedDualSetpoint::stage4CoolingTemperatureOffset() const {
304 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->stage4CoolingTemperatureOffset();
305 }
306
307 ✗ bool ZoneControlThermostatStagedDualSetpoint::setNumberofHeatingStages(int numberofHeatingStages) {
308 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setNumberofHeatingStages(numberofHeatingStages);
309 }
310
311 ✗ bool ZoneControlThermostatStagedDualSetpoint::setHeatingTemperatureSetpointSchedule(Schedule& schedule) {
312 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setHeatingTemperatureSetpointSchedule(schedule);
313 }
314
315 ✗ void ZoneControlThermostatStagedDualSetpoint::resetHeatingTemperatureSetpointSchedule() {
316 ✗ getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->resetHeatingTemperatureSetpointSchedule();
317 ✗ }
318
319 ✗ bool ZoneControlThermostatStagedDualSetpoint::setHeatingThrottlingTemperatureRange(double heatingThrottlingTemperatureRange) {
320 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setHeatingThrottlingTemperatureRange(heatingThrottlingTemperatureRange);
321 }
322
323 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage1HeatingTemperatureOffset(double stage1HeatingTemperatureOffset) {
324 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage1HeatingTemperatureOffset(stage1HeatingTemperatureOffset);
325 }
326
327 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage2HeatingTemperatureOffset(double stage2HeatingTemperatureOffset) {
328 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage2HeatingTemperatureOffset(stage2HeatingTemperatureOffset);
329 }
330
331 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage3HeatingTemperatureOffset(double stage3HeatingTemperatureOffset) {
332 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage3HeatingTemperatureOffset(stage3HeatingTemperatureOffset);
333 }
334
335 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage4HeatingTemperatureOffset(double stage4HeatingTemperatureOffset) {
336 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage4HeatingTemperatureOffset(stage4HeatingTemperatureOffset);
337 }
338
339 ✗ bool ZoneControlThermostatStagedDualSetpoint::setNumberofCoolingStages(int numberofCoolingStages) {
340 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setNumberofCoolingStages(numberofCoolingStages);
341 }
342
343 ✗ bool ZoneControlThermostatStagedDualSetpoint::setCoolingTemperatureSetpointBaseSchedule(Schedule& schedule) {
344 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setCoolingTemperatureSetpointBaseSchedule(schedule);
345 }
346
347 ✗ void ZoneControlThermostatStagedDualSetpoint::resetCoolingTemperatureSetpointBaseSchedule() {
348 ✗ getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->resetCoolingTemperatureSetpointBaseSchedule();
349 ✗ }
350
351 ✗ bool ZoneControlThermostatStagedDualSetpoint::setCoolingThrottlingTemperatureRange(double coolingThrottlingTemperatureRange) {
352 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setCoolingThrottlingTemperatureRange(coolingThrottlingTemperatureRange);
353 }
354
355 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage1CoolingTemperatureOffset(double stage1CoolingTemperatureOffset) {
356 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage1CoolingTemperatureOffset(stage1CoolingTemperatureOffset);
357 }
358
359 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage2CoolingTemperatureOffset(double stage2CoolingTemperatureOffset) {
360 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage2CoolingTemperatureOffset(stage2CoolingTemperatureOffset);
361 }
362
363 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage3CoolingTemperatureOffset(double stage3CoolingTemperatureOffset) {
364 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage3CoolingTemperatureOffset(stage3CoolingTemperatureOffset);
365 }
366
367 ✗ bool ZoneControlThermostatStagedDualSetpoint::setStage4CoolingTemperatureOffset(double stage4CoolingTemperatureOffset) {
368 ✗ return getImpl<detail::ZoneControlThermostatStagedDualSetpoint_Impl>()->setStage4CoolingTemperatureOffset(stage4CoolingTemperatureOffset);
369 }
370
371 /// @cond
372 ✗ ZoneControlThermostatStagedDualSetpoint::ZoneControlThermostatStagedDualSetpoint(
373 ✗ std::shared_ptr<detail::ZoneControlThermostatStagedDualSetpoint_Impl> impl)
374 ✗ : Thermostat(std::move(impl)) {}
375 /// @endcond
376
377 } // namespace model
378 } // namespace openstudio
379