GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 0.0% 0 / 0 / 205
Functions: 0.0% 0 / 0 / 1
Branches: 0.0% 0 / 0 / 515

src/energyplus/ForwardTranslator/ForwardTranslateRefrigerationCase.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 "../ForwardTranslator.hpp"
7 #include "../../model/Model.hpp"
8 #include "../../model/RefrigerationCase.hpp"
9 #include "../../model/RefrigerationCase_Impl.hpp"
10 #include "../../model/CurveCubic.hpp"
11 #include "../../model/ThermalZone.hpp"
12 #include "../../model/Schedule.hpp"
13 #include "../../utilities/time/Time.hpp"
14
15 #include <utilities/idd/Refrigeration_Case_FieldEnums.hxx>
16 #include "../../utilities/idd/IddEnums.hpp"
17 #include <utilities/idd/IddEnums.hxx>
18 #include <utilities/idd/IddFactory.hxx>
19
20 using namespace openstudio::model;
21
22 namespace openstudio {
23
24 namespace energyplus {
25
26 ✗ boost::optional<IdfObject> ForwardTranslator::translateRefrigerationCase(RefrigerationCase& modelObject) {
27 ✗ OptionalModelObject temp;
28 ✗ OptionalString optS;
29 ✗ boost::optional<std::string> s;
30 ✗ boost::optional<double> d;
31
32 // Name
33 ✗ IdfObject object = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_Case, modelObject);
34
35 // AvailabilityScheduleName
36 ✗ boost::optional<Schedule> availabilitySchedule = modelObject.availabilitySchedule();
37
38 ✗ if (availabilitySchedule) {
39 ✗ boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule.get());
40
41 ✗ if (_availabilitySchedule && _availabilitySchedule->name()) {
42 ✗ object.setString(Refrigeration_CaseFields::AvailabilityScheduleName, _availabilitySchedule->name().get());
43 }
44 ✗ }
45
46 //Zone Name
47 ✗ boost::optional<ThermalZone> thermalZone = modelObject.thermalZone();
48
49 ✗ if (thermalZone) {
50 ✗ boost::optional<IdfObject> _thermalZone = translateAndMapModelObject(thermalZone.get());
51
52 ✗ if (_thermalZone && _thermalZone->name()) {
53 ✗ object.setString(Refrigeration_CaseFields::ZoneName, _thermalZone->name().get());
54 }
55 ✗ }
56
57 //RatedAmbientTemperature
58 ✗ d = modelObject.ratedAmbientTemperature();
59 ✗ if (d) {
60 ✗ object.setDouble(Refrigeration_CaseFields::RatedAmbientTemperature, d.get());
61 }
62
63 //RatedAmbientRelativeHumidity
64 ✗ d = modelObject.ratedAmbientRelativeHumidity();
65 ✗ if (d) {
66 ✗ object.setDouble(Refrigeration_CaseFields::RatedAmbientRelativeHumidity, d.get());
67 }
68
69 //RatedLatentHeatRatio
70 ✗ d = modelObject.ratedLatentHeatRatio();
71 ✗ if (d) {
72 ✗ object.setDouble(Refrigeration_CaseFields::RatedLatentHeatRatio, d.get());
73 }
74
75 //RatedRuntimeFraction
76 ✗ d = modelObject.ratedRuntimeFraction();
77 ✗ if (d) {
78 ✗ object.setDouble(Refrigeration_CaseFields::RatedRuntimeFraction, d.get());
79 }
80
81 //CaseLength
82 ✗ d = modelObject.caseLength();
83 ✗ if (d) {
84 ✗ object.setDouble(Refrigeration_CaseFields::CaseLength, d.get());
85 }
86
87 //CaseOperatingTemperature
88 ✗ d = modelObject.caseOperatingTemperature();
89 ✗ if (d) {
90 ✗ object.setDouble(Refrigeration_CaseFields::CaseOperatingTemperature, d.get());
91 }
92
93 //LatentCaseCreditCurveType
94 ✗ s = modelObject.latentCaseCreditCurveType();
95 ✗ if (s) {
96 ✗ object.setString(Refrigeration_CaseFields::LatentCaseCreditCurveType, s.get());
97 }
98
99 //LatentCaseCreditCurveName
100 ✗ boost::optional<CurveCubic> latentCaseCreditCurve = modelObject.latentCaseCreditCurve();
101
102 ✗ if (latentCaseCreditCurve) {
103 ✗ boost::optional<IdfObject> _latentCaseCreditCurve = translateAndMapModelObject(latentCaseCreditCurve.get());
104
105 ✗ if (_latentCaseCreditCurve && _latentCaseCreditCurve->name()) {
106 ✗ object.setString(Refrigeration_CaseFields::LatentCaseCreditCurveName, _latentCaseCreditCurve->name().get());
107 }
108 ✗ }
109
110 //CaseLightingScheduleName
111 ✗ boost::optional<Schedule> caseLightingSchedule = modelObject.caseLightingSchedule();
112
113 ✗ if (caseLightingSchedule) {
114 ✗ boost::optional<IdfObject> _caseLightingSchedule = translateAndMapModelObject(caseLightingSchedule.get());
115
116 ✗ if (_caseLightingSchedule && _caseLightingSchedule->name()) {
117 ✗ object.setString(Refrigeration_CaseFields::CaseLightingScheduleName, _caseLightingSchedule->name().get());
118 }
119 ✗ }
120
121 //FractionofLightingEnergytoCase
122 ✗ d = modelObject.fractionofLightingEnergytoCase();
123 ✗ if (d) {
124 ✗ object.setDouble(Refrigeration_CaseFields::FractionofLightingEnergytoCase, d.get());
125 }
126
127 //AntiSweatHeaterControlType
128 ✗ s = modelObject.antiSweatHeaterControlType();
129 ✗ if (s) {
130 ✗ object.setString(Refrigeration_CaseFields::AntiSweatHeaterControlType, s.get());
131 }
132
133 //HumidityatZeroAntiSweatHeaterEnergy
134 ✗ d = modelObject.humidityatZeroAntiSweatHeaterEnergy();
135 ✗ if (d) {
136 ✗ object.setDouble(Refrigeration_CaseFields::HumidityatZeroAntiSweatHeaterEnergy, d.get());
137 }
138
139 //CaseHeight
140 ✗ d = modelObject.caseHeight();
141 ✗ if (d) {
142 ✗ object.setDouble(Refrigeration_CaseFields::CaseHeight, d.get());
143 }
144
145 //FractionofAntiSweatHeaterEnergytoCase
146 ✗ d = modelObject.fractionofAntiSweatHeaterEnergytoCase();
147 ✗ if (d) {
148 ✗ object.setDouble(Refrigeration_CaseFields::FractionofAntiSweatHeaterEnergytoCase, d.get());
149 }
150
151 //CaseDefrostType
152 ✗ s = modelObject.caseDefrostType();
153 ✗ if (s) {
154 ✗ object.setString(Refrigeration_CaseFields::CaseDefrostType, s.get());
155 }
156
157 //DefrostCycleParameters
158 ✗ boost::optional<int> durationofDefrostCycle = modelObject.durationofDefrostCycle();
159 ✗ boost::optional<int> dripDownTime = modelObject.dripDownTime();
160 ✗ std::vector<openstudio::Time> defrostStartTimes = modelObject.getImpl<model::detail::RefrigerationCase_Impl>()->defrostStartTimes();
161
162 ✗ if (durationofDefrostCycle && dripDownTime && !defrostStartTimes.empty()) {
163 ✗ int defrostTimeHour = *durationofDefrostCycle / 60;
164 ✗ int defrostTimeMin = *durationofDefrostCycle % 60;
165 ✗ int dripDownTimeHour = *dripDownTime / 60;
166 ✗ int dripDownTimeMin = *dripDownTime % 60;
167
168 ✗ std::vector<std::pair<openstudio::Time, double>> defrostDefaultDay;
169 ✗ std::vector<std::pair<openstudio::Time, double>> dripDownDefaultDay;
170 ✗ for (auto _defrostStartTime = defrostStartTimes.begin(); _defrostStartTime != defrostStartTimes.end(); ++_defrostStartTime) {
171 ✗ defrostDefaultDay.push_back(std::make_pair(*_defrostStartTime, 0)); // defrost off
172 ✗ openstudio::Time defrostEndTime(0, _defrostStartTime->hours() + defrostTimeHour, _defrostStartTime->minutes() + defrostTimeMin);
173 ✗ defrostDefaultDay.push_back(std::make_pair(defrostEndTime, 1)); // defrost on
174
175 ✗ dripDownDefaultDay.push_back(std::make_pair(*_defrostStartTime, 0)); // drip down off
176 ✗ openstudio::Time dripDownEndTime(0, _defrostStartTime->hours() + defrostTimeHour + dripDownTimeHour,
177 ✗ _defrostStartTime->minutes() + defrostTimeMin + dripDownTimeMin);
178 ✗ dripDownDefaultDay.push_back(std::make_pair(dripDownEndTime, 1)); // drip down on
179 }
180
181 ✗ if ((defrostStartTimes.front().hours() != 0 && defrostStartTimes.front().minutes() != 0) || defrostStartTimes.back().hours() < 24) {
182 ✗ openstudio::Time defrostDayEnd(0, 24, 0);
183 ✗ defrostDefaultDay.push_back(std::make_pair(defrostDayEnd, 0)); // defrost off
184 ✗ dripDownDefaultDay.push_back(std::make_pair(defrostDayEnd, 0)); // drip down off
185 }
186
187 //CaseDefrostScheduleName
188 ✗ std::string defrostName(modelObject.name().get() + " Defrost Schedule");
189 ✗ boost::optional<IdfObject> defrostSchedule = this->createSimpleSchedule(defrostName, defrostDefaultDay);
190 ✗ if (defrostSchedule) {
191 ✗ object.setString(Refrigeration_CaseFields::CaseDefrostScheduleName, defrostName);
192 }
193
194 //CaseDefrostDripDownScheduleName
195 ✗ std::string dripDownName(modelObject.name().get() + " Defrost Drip Down Schedule");
196 ✗ boost::optional<IdfObject> defrostDripDownSchedule = this->createSimpleSchedule(dripDownName, dripDownDefaultDay);
197 ✗ if (defrostDripDownSchedule) {
198 ✗ object.setString(Refrigeration_CaseFields::CaseDefrostDripDownScheduleName, dripDownName);
199 }
200 ✗ } else {
201 //CaseDefrostScheduleName
202 ✗ boost::optional<Schedule> caseDefrostSchedule = modelObject.caseDefrostSchedule();
203
204 ✗ if (caseDefrostSchedule) {
205 ✗ boost::optional<IdfObject> _caseDefrostSchedule = translateAndMapModelObject(caseDefrostSchedule.get());
206
207 ✗ if (_caseDefrostSchedule && _caseDefrostSchedule->name()) {
208 ✗ object.setString(Refrigeration_CaseFields::CaseDefrostScheduleName, _caseDefrostSchedule->name().get());
209 }
210 ✗ }
211
212 //CaseDefrostDripDownScheduleName
213 ✗ boost::optional<Schedule> caseDefrostDripDownSchedule = modelObject.caseDefrostDripDownSchedule();
214
215 ✗ if (caseDefrostDripDownSchedule) {
216 ✗ boost::optional<IdfObject> _caseDefrostDripDownSchedule = translateAndMapModelObject(caseDefrostDripDownSchedule.get());
217
218 ✗ if (_caseDefrostDripDownSchedule && _caseDefrostDripDownSchedule->name()) {
219 ✗ object.setString(Refrigeration_CaseFields::CaseDefrostDripDownScheduleName, _caseDefrostDripDownSchedule->name().get());
220 }
221 ✗ }
222 ✗ }
223
224 //DefrostEnergyCorrectionCurveType
225 {
226 ✗ auto value = modelObject.defrostEnergyCorrectionCurveType();
227 ✗ object.setString(Refrigeration_CaseFields::DefrostEnergyCorrectionCurveType, value);
228 ✗ }
229
230 //DefrostEnergyCorrectionCurveName
231 ✗ if (auto defrostEnergyCorrectionCurve = modelObject.defrostEnergyCorrectionCurve()) {
232 ✗ auto type = modelObject.caseDefrostType();
233 // Only for these types or E+ will halt.
234 ✗ if (istringEqual(type, "HotGasWithTemperatureTermination") || istringEqual(type, "ElectricWithTemperatureTermination")
235 ✗ || istringEqual(type, "HotFluidWithTemperatureTermination")) {
236 ✗ boost::optional<IdfObject> _defrostEnergyCorrectionCurve = translateAndMapModelObject(defrostEnergyCorrectionCurve.get());
237
238 ✗ if (_defrostEnergyCorrectionCurve && _defrostEnergyCorrectionCurve->name()) {
239 ✗ object.setString(Refrigeration_CaseFields::DefrostEnergyCorrectionCurveName, _defrostEnergyCorrectionCurve->name().get());
240 }
241 ✗ }
242 ✗ }
243
244 //UnderCaseHVACReturnAirFraction
245 ✗ d = modelObject.underCaseHVACReturnAirFraction();
246 ✗ if (d) {
247 ✗ object.setDouble(Refrigeration_CaseFields::UnderCaseHVACReturnAirFraction, d.get());
248 }
249
250 //RefrigeratedCaseRestockingScheduleName
251 ✗ boost::optional<Schedule> refrigeratedCaseRestockingSchedule = modelObject.refrigeratedCaseRestockingSchedule();
252
253 ✗ if (refrigeratedCaseRestockingSchedule) {
254 ✗ boost::optional<IdfObject> _refrigeratedCaseRestockingSchedule = translateAndMapModelObject(refrigeratedCaseRestockingSchedule.get());
255
256 ✗ if (_refrigeratedCaseRestockingSchedule && _refrigeratedCaseRestockingSchedule->name()) {
257 ✗ object.setString(Refrigeration_CaseFields::RefrigeratedCaseRestockingScheduleName, _refrigeratedCaseRestockingSchedule->name().get());
258 }
259 ✗ }
260
261 //CaseCreditFractionScheduleName
262 ✗ boost::optional<Schedule> caseCreditFractionSchedule = modelObject.caseCreditFractionSchedule();
263
264 ✗ if (caseCreditFractionSchedule) {
265 ✗ boost::optional<IdfObject> _caseCreditFractionSchedule = translateAndMapModelObject(caseCreditFractionSchedule.get());
266
267 ✗ if (_caseCreditFractionSchedule && _caseCreditFractionSchedule->name()) {
268 ✗ object.setString(Refrigeration_CaseFields::CaseCreditFractionScheduleName, _caseCreditFractionSchedule->name().get());
269 }
270 ✗ }
271
272 //DesignEvaporatorTemperatureorBrineInletTemperature
273 ✗ d = modelObject.designEvaporatorTemperatureorBrineInletTemperature();
274 ✗ if (d) {
275 ✗ object.setDouble(Refrigeration_CaseFields::DesignEvaporatorTemperatureorBrineInletTemperature, d.get());
276 }
277
278 //AverageRefrigerantChargeInventory
279 ✗ d = modelObject.averageRefrigerantChargeInventory();
280 ✗ if (d) {
281 ✗ object.setDouble(Refrigeration_CaseFields::AverageRefrigerantChargeInventory, d.get());
282 }
283
284 ✗ boost::optional<double> ratedTotalCoolingCapacity;
285 ✗ boost::optional<double> standardCaseFanPower;
286 ✗ boost::optional<double> operatingCaseFanPower;
287 ✗ boost::optional<double> standardCaseLightingPower;
288 ✗ boost::optional<double> installedCaseLightingPower;
289 ✗ boost::optional<double> caseAntiSweatHeaterPower;
290 ✗ boost::optional<double> minimumAntiSweatHeaterPower;
291 ✗ boost::optional<double> caseDefrostPower;
292
293 ✗ std::string const unitType = modelObject.unitType();
294 ✗ if (istringEqual("UnitLength", unitType)) {
295 ✗ ratedTotalCoolingCapacity = modelObject.ratedTotalCoolingCapacityperUnitLength();
296 ✗ standardCaseFanPower = modelObject.standardCaseFanPowerperUnitLength();
297 ✗ operatingCaseFanPower = modelObject.operatingCaseFanPowerperUnitLength();
298 ✗ standardCaseLightingPower = modelObject.standardCaseLightingPowerperUnitLength();
299 ✗ installedCaseLightingPower = modelObject.installedCaseLightingPowerperUnitLength();
300 ✗ caseAntiSweatHeaterPower = modelObject.caseAntiSweatHeaterPowerperUnitLength();
301 ✗ minimumAntiSweatHeaterPower = modelObject.minimumAntiSweatHeaterPowerperUnitLength();
302 ✗ caseDefrostPower = modelObject.caseDefrostPowerperUnitLength();
303 } else { // NumberOfDoors
304 ✗ boost::optional<int> numberOfDoors = modelObject.numberOfDoors();
305 ✗ boost::optional<double> caseLength = modelObject.caseLength();
306 ✗ if (!numberOfDoors) {
307 ✗ LOG(Error, "Missing required input 'NumberOfDoors' for Refrigeration:Case named '" << modelObject.name().get() << "'");
308 }
309 ✗ if (!caseLength) {
310 ✗ LOG(Error, "Missing required input 'CaseLength' for Refrigeration:Case named '" << modelObject.name().get() << "'");
311 }
312 ✗ double conversion = numberOfDoors.get() / caseLength.get();
313
314 ✗ if ((ratedTotalCoolingCapacity = modelObject.ratedTotalCoolingCapacityperDoor())) {
315 ✗ ratedTotalCoolingCapacity = ratedTotalCoolingCapacity.get() * conversion;
316 }
317 ✗ if ((standardCaseFanPower = modelObject.standardCaseFanPowerperDoor())) {
318 ✗ standardCaseFanPower = standardCaseFanPower.get() * conversion;
319 }
320 ✗ if ((operatingCaseFanPower = modelObject.operatingCaseFanPowerperDoor())) {
321 ✗ operatingCaseFanPower = operatingCaseFanPower.get() * conversion;
322 }
323 ✗ if ((standardCaseLightingPower = modelObject.standardCaseLightingPowerperDoor())) {
324 ✗ standardCaseLightingPower = standardCaseLightingPower.get() * conversion;
325 }
326 ✗ if ((installedCaseLightingPower = modelObject.installedCaseLightingPowerperDoor())) {
327 ✗ installedCaseLightingPower = installedCaseLightingPower.get() * conversion;
328 }
329 ✗ if ((caseAntiSweatHeaterPower = modelObject.caseAntiSweatHeaterPowerperDoor())) {
330 ✗ caseAntiSweatHeaterPower = caseAntiSweatHeaterPower.get() * conversion;
331 }
332 ✗ if ((minimumAntiSweatHeaterPower = modelObject.minimumAntiSweatHeaterPowerperDoor())) {
333 ✗ minimumAntiSweatHeaterPower = minimumAntiSweatHeaterPower.get() * conversion;
334 }
335 ✗ if ((caseDefrostPower = modelObject.caseDefrostPowerperDoor())) {
336 ✗ caseDefrostPower = caseDefrostPower.get() * conversion;
337 }
338 }
339
340 //RatedTotalCoolingCapacityperUnitLength
341 ✗ if (ratedTotalCoolingCapacity) {
342 ✗ object.setDouble(Refrigeration_CaseFields::RatedTotalCoolingCapacityperUnitLength, ratedTotalCoolingCapacity.get());
343 }
344
345 //StandardCaseFanPowerperUnitLength
346 ✗ if (standardCaseFanPower) {
347 ✗ object.setDouble(Refrigeration_CaseFields::StandardCaseFanPowerperUnitLength, standardCaseFanPower.get());
348 }
349
350 //OperatingCaseFanPowerperUnitLength
351 ✗ if (operatingCaseFanPower) {
352 ✗ object.setDouble(Refrigeration_CaseFields::OperatingCaseFanPowerperUnitLength, operatingCaseFanPower.get());
353 }
354
355 //StandardCaseLightingPowerperUnitLength
356 ✗ if (standardCaseLightingPower) {
357 ✗ object.setDouble(Refrigeration_CaseFields::StandardCaseLightingPowerperUnitLength, standardCaseLightingPower.get());
358 }
359
360 //InstalledCaseLightingPowerperUnitLength
361 ✗ if (installedCaseLightingPower) {
362 ✗ object.setDouble(Refrigeration_CaseFields::InstalledCaseLightingPowerperUnitLength, installedCaseLightingPower.get());
363 }
364
365 //CaseAntiSweatHeaterPowerperUnitLength
366 ✗ if (caseAntiSweatHeaterPower) {
367 ✗ object.setDouble(Refrigeration_CaseFields::CaseAntiSweatHeaterPowerperUnitLength, caseAntiSweatHeaterPower.get());
368 }
369
370 //MinimumAntiSweatHeaterPowerperUnitLength
371 ✗ if (minimumAntiSweatHeaterPower) {
372 ✗ object.setDouble(Refrigeration_CaseFields::MinimumAntiSweatHeaterPowerperUnitLength, minimumAntiSweatHeaterPower.get());
373 }
374
375 //CaseDefrostPowerperUnitLength
376 ✗ if (caseDefrostPower) {
377 ✗ object.setDouble(Refrigeration_CaseFields::CaseDefrostPowerperUnitLength, caseDefrostPower.get());
378 }
379
380 ✗ return object;
381 ✗ }
382 } // namespace energyplus
383 } // namespace openstudio
384