GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 6.0% 11 / 0 / 184
Functions: 6.2% 4 / 0 / 64
Branches: 5.7% 7 / 0 / 122

src/model/LuminaireDefinition.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 "LuminaireDefinition.hpp"
7 #include "LuminaireDefinition_Impl.hpp"
8
9 #include <utilities/idd/OS_Luminaire_Definition_FieldEnums.hxx>
10 #include <utilities/idd/IddEnums.hxx>
11
12 #include "../utilities/math/FloatCompare.hpp"
13 #include "../utilities/core/Compare.hpp"
14 #include "../utilities/core/Assert.hpp"
15
16 namespace openstudio {
17 namespace model {
18
19 namespace detail {
20
21 2 LuminaireDefinition_Impl::LuminaireDefinition_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
22 2 : SpaceLoadDefinition_Impl(idfObject, model, keepHandle) {
23
4/6
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
✗ Branch 13 not taken.
2 OS_ASSERT(idfObject.iddObject().type() == LuminaireDefinition::iddObjectType());
24 2 }
25
26 ✗ LuminaireDefinition_Impl::LuminaireDefinition_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
27 ✗ : SpaceLoadDefinition_Impl(other, model, keepHandle) {
28 ✗ OS_ASSERT(other.iddObject().type() == LuminaireDefinition::iddObjectType());
29 ✗ }
30
31 ✗ LuminaireDefinition_Impl::LuminaireDefinition_Impl(const LuminaireDefinition_Impl& other, Model_Impl* model, bool keepHandle)
32 ✗ : SpaceLoadDefinition_Impl(other, model, keepHandle) {}
33
34 ✗ const std::vector<std::string>& LuminaireDefinition_Impl::outputVariableNames() const {
35 ✗ static const std::vector<std::string> result;
36 ✗ return result;
37 }
38
39 ✗ IddObjectType LuminaireDefinition_Impl::iddObjectType() const {
40 ✗ return LuminaireDefinition::iddObjectType();
41 }
42
43 ✗ double LuminaireDefinition_Impl::lightingPower() const {
44 ✗ boost::optional<double> value = getDouble(OS_Luminaire_DefinitionFields::LightingPower, true);
45 ✗ OS_ASSERT(value);
46 ✗ return value.get();
47 }
48
49 ✗ bool LuminaireDefinition_Impl::isLightingPowerDefaulted() const {
50 ✗ return isEmpty(OS_Luminaire_DefinitionFields::LightingPower);
51 }
52
53 ✗ double LuminaireDefinition_Impl::fractionRadiant() const {
54 ✗ boost::optional<double> value = getDouble(OS_Luminaire_DefinitionFields::FractionRadiant, true);
55 ✗ OS_ASSERT(value);
56 ✗ return value.get();
57 }
58
59 ✗ bool LuminaireDefinition_Impl::isFractionRadiantDefaulted() const {
60 ✗ return isEmpty(OS_Luminaire_DefinitionFields::FractionRadiant);
61 }
62
63 ✗ double LuminaireDefinition_Impl::fractionVisible() const {
64 ✗ boost::optional<double> value = getDouble(OS_Luminaire_DefinitionFields::FractionVisible, true);
65 ✗ OS_ASSERT(value);
66 ✗ return value.get();
67 }
68
69 ✗ bool LuminaireDefinition_Impl::isFractionVisibleDefaulted() const {
70 ✗ return isEmpty(OS_Luminaire_DefinitionFields::FractionVisible);
71 }
72
73 ✗ double LuminaireDefinition_Impl::returnAirFraction() const {
74 ✗ boost::optional<double> value = getDouble(OS_Luminaire_DefinitionFields::ReturnAirFraction, true);
75 ✗ OS_ASSERT(value);
76 ✗ return value.get();
77 }
78
79 ✗ bool LuminaireDefinition_Impl::isReturnAirFractionDefaulted() const {
80 ✗ return isEmpty(OS_Luminaire_DefinitionFields::ReturnAirFraction);
81 }
82
83 ✗ bool LuminaireDefinition_Impl::returnAirFractionCalculatedfromPlenumTemperature() const {
84 ✗ boost::optional<std::string> value = getString(OS_Luminaire_DefinitionFields::ReturnAirFractionCalculatedfromPlenumTemperature, true);
85 ✗ OS_ASSERT(value);
86 ✗ return openstudio::istringEqual(value.get(), "Yes");
87 ✗ }
88
89 ✗ bool LuminaireDefinition_Impl::isReturnAirFractionCalculatedfromPlenumTemperatureDefaulted() const {
90 ✗ return isEmpty(OS_Luminaire_DefinitionFields::ReturnAirFractionCalculatedfromPlenumTemperature);
91 }
92
93 ✗ double LuminaireDefinition_Impl::returnAirFractionFunctionofPlenumTemperatureCoefficient1() const {
94 ✗ boost::optional<double> value = getDouble(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient1, true);
95 ✗ OS_ASSERT(value);
96 ✗ return value.get();
97 }
98
99 ✗ bool LuminaireDefinition_Impl::isReturnAirFractionFunctionofPlenumTemperatureCoefficient1Defaulted() const {
100 ✗ return isEmpty(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient1);
101 }
102
103 ✗ double LuminaireDefinition_Impl::returnAirFractionFunctionofPlenumTemperatureCoefficient2() const {
104 ✗ boost::optional<double> value = getDouble(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient2, true);
105 ✗ OS_ASSERT(value);
106 ✗ return value.get();
107 }
108
109 ✗ bool LuminaireDefinition_Impl::isReturnAirFractionFunctionofPlenumTemperatureCoefficient2Defaulted() const {
110 ✗ return isEmpty(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient2);
111 }
112
113 ✗ bool LuminaireDefinition_Impl::setLightingPower(double lightingPower) {
114 ✗ bool result = setDouble(OS_Luminaire_DefinitionFields::LightingPower, lightingPower);
115 ✗ return result;
116 }
117
118 ✗ void LuminaireDefinition_Impl::resetLightingPower() {
119 ✗ bool result = setString(OS_Luminaire_DefinitionFields::LightingPower, "");
120 ✗ OS_ASSERT(result);
121 ✗ }
122
123 ✗ bool LuminaireDefinition_Impl::setFractionRadiant(double fractionRadiant) {
124 ✗ bool result = setDouble(OS_Luminaire_DefinitionFields::FractionRadiant, fractionRadiant);
125 ✗ return result;
126 }
127
128 ✗ void LuminaireDefinition_Impl::resetFractionRadiant() {
129 ✗ bool result = setString(OS_Luminaire_DefinitionFields::FractionRadiant, "");
130 ✗ OS_ASSERT(result);
131 ✗ }
132
133 ✗ bool LuminaireDefinition_Impl::setFractionVisible(double fractionVisible) {
134 ✗ bool result = setDouble(OS_Luminaire_DefinitionFields::FractionVisible, fractionVisible);
135 ✗ return result;
136 }
137
138 ✗ void LuminaireDefinition_Impl::resetFractionVisible() {
139 ✗ bool result = setString(OS_Luminaire_DefinitionFields::FractionVisible, "");
140 ✗ OS_ASSERT(result);
141 ✗ }
142
143 ✗ bool LuminaireDefinition_Impl::setReturnAirFraction(double returnAirFraction) {
144 ✗ bool result = setDouble(OS_Luminaire_DefinitionFields::ReturnAirFraction, returnAirFraction);
145 ✗ return result;
146 }
147
148 ✗ void LuminaireDefinition_Impl::resetReturnAirFraction() {
149 ✗ bool result = setString(OS_Luminaire_DefinitionFields::ReturnAirFraction, "");
150 ✗ OS_ASSERT(result);
151 ✗ }
152
153 ✗ bool LuminaireDefinition_Impl::setReturnAirFractionCalculatedfromPlenumTemperature(bool returnAirFractionCalculatedfromPlenumTemperature) {
154 ✗ bool result = false;
155 ✗ if (returnAirFractionCalculatedfromPlenumTemperature) {
156 ✗ result = setString(OS_Luminaire_DefinitionFields::ReturnAirFractionCalculatedfromPlenumTemperature, "Yes");
157 } else {
158 ✗ result = setString(OS_Luminaire_DefinitionFields::ReturnAirFractionCalculatedfromPlenumTemperature, "No");
159 }
160 ✗ OS_ASSERT(result);
161 ✗ return result;
162 }
163
164 ✗ void LuminaireDefinition_Impl::resetReturnAirFractionCalculatedfromPlenumTemperature() {
165 ✗ bool result = setString(OS_Luminaire_DefinitionFields::ReturnAirFractionCalculatedfromPlenumTemperature, "");
166 ✗ OS_ASSERT(result);
167 ✗ }
168
169 ✗ bool LuminaireDefinition_Impl::setReturnAirFractionFunctionofPlenumTemperatureCoefficient1(
170 double returnAirFractionFunctionofPlenumTemperatureCoefficient1) {
171 ✗ bool result = setDouble(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient1,
172 returnAirFractionFunctionofPlenumTemperatureCoefficient1);
173 ✗ return result;
174 }
175
176 ✗ void LuminaireDefinition_Impl::resetReturnAirFractionFunctionofPlenumTemperatureCoefficient1() {
177 ✗ bool result = setString(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient1, "");
178 ✗ OS_ASSERT(result);
179 ✗ }
180
181 ✗ bool LuminaireDefinition_Impl::setReturnAirFractionFunctionofPlenumTemperatureCoefficient2(
182 double returnAirFractionFunctionofPlenumTemperatureCoefficient2) {
183 ✗ bool result = setDouble(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient2,
184 returnAirFractionFunctionofPlenumTemperatureCoefficient2);
185 ✗ return result;
186 }
187
188 ✗ void LuminaireDefinition_Impl::resetReturnAirFractionFunctionofPlenumTemperatureCoefficient2() {
189 ✗ bool result = setString(OS_Luminaire_DefinitionFields::ReturnAirFractionFunctionofPlenumTemperatureCoefficient2, "");
190 ✗ OS_ASSERT(result);
191 ✗ }
192
193 } // namespace detail
194
195 2 LuminaireDefinition::LuminaireDefinition(const Model& model) : SpaceLoadDefinition(LuminaireDefinition::iddObjectType(), model) {
196
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✗ Branch 5 not taken.
2 OS_ASSERT(getImpl<detail::LuminaireDefinition_Impl>());
197 2 }
198
199 7732 IddObjectType LuminaireDefinition::iddObjectType() {
200
1/1
✓ Branch 1 taken 7732 times.
7732 IddObjectType result(IddObjectType::OS_Luminaire_Definition);
201 7732 return result;
202 }
203
204 ✗ double LuminaireDefinition::lightingPower() const {
205 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->lightingPower();
206 }
207
208 ✗ bool LuminaireDefinition::isLightingPowerDefaulted() const {
209 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->isLightingPowerDefaulted();
210 }
211
212 ✗ double LuminaireDefinition::fractionRadiant() const {
213 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->fractionRadiant();
214 }
215
216 ✗ bool LuminaireDefinition::isFractionRadiantDefaulted() const {
217 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->isFractionRadiantDefaulted();
218 }
219
220 ✗ double LuminaireDefinition::fractionVisible() const {
221 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->fractionVisible();
222 }
223
224 ✗ bool LuminaireDefinition::isFractionVisibleDefaulted() const {
225 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->isFractionVisibleDefaulted();
226 }
227
228 ✗ double LuminaireDefinition::returnAirFraction() const {
229 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->returnAirFraction();
230 }
231
232 ✗ bool LuminaireDefinition::isReturnAirFractionDefaulted() const {
233 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->isReturnAirFractionDefaulted();
234 }
235
236 ✗ bool LuminaireDefinition::returnAirFractionCalculatedfromPlenumTemperature() const {
237 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->returnAirFractionCalculatedfromPlenumTemperature();
238 }
239
240 ✗ bool LuminaireDefinition::isReturnAirFractionCalculatedfromPlenumTemperatureDefaulted() const {
241 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->isReturnAirFractionCalculatedfromPlenumTemperatureDefaulted();
242 }
243
244 ✗ double LuminaireDefinition::returnAirFractionFunctionofPlenumTemperatureCoefficient1() const {
245 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->returnAirFractionFunctionofPlenumTemperatureCoefficient1();
246 }
247
248 ✗ bool LuminaireDefinition::isReturnAirFractionFunctionofPlenumTemperatureCoefficient1Defaulted() const {
249 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->isReturnAirFractionFunctionofPlenumTemperatureCoefficient1Defaulted();
250 }
251
252 ✗ double LuminaireDefinition::returnAirFractionFunctionofPlenumTemperatureCoefficient2() const {
253 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->returnAirFractionFunctionofPlenumTemperatureCoefficient2();
254 }
255
256 ✗ bool LuminaireDefinition::isReturnAirFractionFunctionofPlenumTemperatureCoefficient2Defaulted() const {
257 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->isReturnAirFractionFunctionofPlenumTemperatureCoefficient2Defaulted();
258 }
259
260 ✗ bool LuminaireDefinition::setLightingPower(double lightingPower) {
261 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->setLightingPower(lightingPower);
262 }
263
264 ✗ void LuminaireDefinition::resetLightingPower() {
265 ✗ getImpl<detail::LuminaireDefinition_Impl>()->resetLightingPower();
266 ✗ }
267
268 ✗ bool LuminaireDefinition::setFractionRadiant(double fractionRadiant) {
269 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->setFractionRadiant(fractionRadiant);
270 }
271
272 ✗ void LuminaireDefinition::resetFractionRadiant() {
273 ✗ getImpl<detail::LuminaireDefinition_Impl>()->resetFractionRadiant();
274 ✗ }
275
276 ✗ bool LuminaireDefinition::setFractionVisible(double fractionVisible) {
277 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->setFractionVisible(fractionVisible);
278 }
279
280 ✗ void LuminaireDefinition::resetFractionVisible() {
281 ✗ getImpl<detail::LuminaireDefinition_Impl>()->resetFractionVisible();
282 ✗ }
283
284 ✗ bool LuminaireDefinition::setReturnAirFraction(double returnAirFraction) {
285 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->setReturnAirFraction(returnAirFraction);
286 }
287
288 ✗ void LuminaireDefinition::resetReturnAirFraction() {
289 ✗ getImpl<detail::LuminaireDefinition_Impl>()->resetReturnAirFraction();
290 ✗ }
291
292 ✗ bool LuminaireDefinition::setReturnAirFractionCalculatedfromPlenumTemperature(bool returnAirFractionCalculatedfromPlenumTemperature) {
293 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->setReturnAirFractionCalculatedfromPlenumTemperature(
294 ✗ returnAirFractionCalculatedfromPlenumTemperature);
295 }
296
297 ✗ void LuminaireDefinition::resetReturnAirFractionCalculatedfromPlenumTemperature() {
298 ✗ getImpl<detail::LuminaireDefinition_Impl>()->resetReturnAirFractionCalculatedfromPlenumTemperature();
299 ✗ }
300
301 ✗ bool LuminaireDefinition::setReturnAirFractionFunctionofPlenumTemperatureCoefficient1(
302 double returnAirFractionFunctionofPlenumTemperatureCoefficient1) {
303 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->setReturnAirFractionFunctionofPlenumTemperatureCoefficient1(
304 ✗ returnAirFractionFunctionofPlenumTemperatureCoefficient1);
305 }
306
307 ✗ void LuminaireDefinition::resetReturnAirFractionFunctionofPlenumTemperatureCoefficient1() {
308 ✗ getImpl<detail::LuminaireDefinition_Impl>()->resetReturnAirFractionFunctionofPlenumTemperatureCoefficient1();
309 ✗ }
310
311 ✗ bool LuminaireDefinition::setReturnAirFractionFunctionofPlenumTemperatureCoefficient2(
312 double returnAirFractionFunctionofPlenumTemperatureCoefficient2) {
313 ✗ return getImpl<detail::LuminaireDefinition_Impl>()->setReturnAirFractionFunctionofPlenumTemperatureCoefficient2(
314 ✗ returnAirFractionFunctionofPlenumTemperatureCoefficient2);
315 }
316
317 ✗ void LuminaireDefinition::resetReturnAirFractionFunctionofPlenumTemperatureCoefficient2() {
318 ✗ getImpl<detail::LuminaireDefinition_Impl>()->resetReturnAirFractionFunctionofPlenumTemperatureCoefficient2();
319 ✗ }
320
321 /// @cond
322
1/1
✓ Branch 3 taken 2 times.
2 LuminaireDefinition::LuminaireDefinition(std::shared_ptr<detail::LuminaireDefinition_Impl> impl) : SpaceLoadDefinition(std::move(impl)) {}
323 /// @endcond
324
325 } // namespace model
326 } // namespace openstudio
327