GCC Code Coverage Report


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

src/energyplus/ReverseTranslator/ReverseTranslateEvaporativeFluidCoolerSingleSpeed.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 "../ReverseTranslator.hpp"
7 #include "../../model/EvaporativeFluidCoolerSingleSpeed.hpp"
8 #include "../../model/EvaporativeFluidCoolerSingleSpeed_Impl.hpp"
9 #include "../../model/Schedule.hpp"
10 #include "../../model/Schedule_Impl.hpp"
11 #include <utilities/idd/EvaporativeFluidCooler_SingleSpeed_FieldEnums.hxx>
12 #include "../../utilities/idd/IddEnums.hpp"
13 #include <utilities/idd/IddEnums.hxx>
14
15 using namespace openstudio::model;
16
17 namespace openstudio {
18
19 namespace energyplus {
20
21 ✗ OptionalModelObject ReverseTranslator::translateEvaporativeFluidCoolerSingleSpeed(const WorkspaceObject& workspaceObject) {
22 ✗ if (workspaceObject.iddObject().type() != IddObjectType::EvaporativeFluidCooler_SingleSpeed) {
23 ✗ LOG(Error, "WorkspaceObject is not IddObjectType: EvaporativeFluidCooler_SingleSpeed");
24 ✗ return boost::none;
25 }
26
27 ✗ boost::optional<EvaporativeFluidCoolerSingleSpeed> evapCooler;
28
29 ✗ evapCooler = EvaporativeFluidCoolerSingleSpeed(m_model);
30
31 ✗ if (evapCooler) {
32 ✗ boost::optional<double> value;
33 ✗ boost::optional<std::string> s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::Name);
34
35 ✗ if (s) {
36 ✗ evapCooler->setName(s.get());
37 }
38
39 // DesignAirFlowRate
40 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRate);
41 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRate);
42 ✗ if (value) {
43 ✗ evapCooler->setDesignAirFlowRate(value.get());
44 ✗ } else if (s && istringEqual(s.get(), "Autosize")) {
45 ✗ evapCooler->autosizeDesignAirFlowRate();
46 ✗ } else if (s && istringEqual(s.get(), "Autocalculate")) {
47 ✗ evapCooler->autosizeDesignAirFlowRate();
48 }
49
50 // FanPoweratDesignAirFlowRate
51 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateFanPower);
52 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateFanPower);
53 ✗ if (value) {
54 ✗ evapCooler->setFanPoweratDesignAirFlowRate(value.get());
55 ✗ } else if (s && istringEqual(s.get(), "Autosize")) {
56 ✗ evapCooler->autosizeFanPoweratDesignAirFlowRate();
57 ✗ } else if (s && istringEqual(s.get(), "Autocalculate")) {
58 ✗ evapCooler->autosizeFanPoweratDesignAirFlowRate();
59 }
60
61 // DesignSprayWaterFlowRate
62 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignSprayWaterFlowRate);
63 ✗ if (value) {
64 ✗ evapCooler->setDesignSprayWaterFlowRate(value.get());
65 }
66
67 // PerformanceInputMethod
68 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::PerformanceInputMethod);
69 ✗ if (s) {
70 ✗ evapCooler->setPerformanceInputMethod(s.get());
71 }
72
73 // HeatRejectionCapacityandNominalCapacitySizingRatio
74 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::HeatRejectionCapacityandNominalCapacitySizingRatio);
75 ✗ if (value) {
76 ✗ evapCooler->setHeatRejectionCapacityandNominalCapacitySizingRatio(value.get());
77 }
78
79 // StandardDesignCapacity
80 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::StandardDesignCapacity);
81 ✗ if (value) {
82 ✗ evapCooler->setStandardDesignCapacity(value.get());
83 }
84
85 // UfactorTimesAreaValueatDesignAirFlowRate
86 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateUfactorTimesAreaValue);
87 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignAirFlowRateUfactorTimesAreaValue);
88 ✗ if (value) {
89 ✗ evapCooler->setUfactorTimesAreaValueatDesignAirFlowRate(value.get());
90 ✗ } else if (s && istringEqual(s.get(), "Autosize")) {
91 ✗ evapCooler->autosizeUfactorTimesAreaValueatDesignAirFlowRate();
92 ✗ } else if (s && istringEqual(s.get(), "Autocalculate")) {
93 ✗ evapCooler->autosizeUfactorTimesAreaValueatDesignAirFlowRate();
94 }
95
96 // DesignWaterFlowRate
97 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignWaterFlowRate);
98 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignWaterFlowRate);
99 ✗ if (value) {
100 ✗ evapCooler->setDesignWaterFlowRate(value.get());
101 ✗ } else if (s && istringEqual(s.get(), "Autosize")) {
102 ✗ evapCooler->autosizeDesignWaterFlowRate();
103 ✗ } else if (s && istringEqual(s.get(), "Autocalculate")) {
104 ✗ evapCooler->autosizeDesignWaterFlowRate();
105 }
106
107 // UserSpecifiedDesignCapacity
108 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::UserSpecifiedDesignCapacity);
109 ✗ if (value) {
110 ✗ evapCooler->setUserSpecifiedDesignCapacity(value.get());
111 }
112
113 // DesignEnteringWaterTemperature
114 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringWaterTemperature);
115 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringWaterTemperature);
116 ✗ if (value) {
117 ✗ evapCooler->setDesignEnteringWaterTemperature(value.get());
118 ✗ } else if (s && istringEqual(s.get(), "Autosize")) {
119 ✗ evapCooler->autosizeDesignEnteringWaterTemperature();
120 ✗ } else if (s && istringEqual(s.get(), "Autocalculate")) {
121 ✗ evapCooler->autosizeDesignEnteringWaterTemperature();
122 }
123
124 // DesignEnteringAirTemperature
125 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringAirTemperature);
126 ✗ if (value) {
127 ✗ evapCooler->setDesignEnteringAirTemperature(value.get());
128 }
129
130 // DesignEnteringAirWetbulbTemperature
131 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringAirWetbulbTemperature);
132 ✗ if (value) {
133 ✗ evapCooler->setDesignEnteringAirWetbulbTemperature(value.get());
134 }
135
136 // CapacityControl
137 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::CapacityControl);
138 ✗ if (s) {
139 ✗ evapCooler->setCapacityControl(s.get());
140 }
141
142 // SizingFactor
143 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::SizingFactor);
144 ✗ if (value) {
145 ✗ evapCooler->setSizingFactor(value.get());
146 }
147
148 // EvaporationLossMode
149 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossMode);
150 ✗ if (s) {
151 ✗ evapCooler->setEvaporationLossMode(s.get());
152 }
153
154 // EvaporationLossFactor
155 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossFactor);
156 ✗ if (value) {
157 ✗ evapCooler->setEvaporationLossFactor(value.get());
158 }
159
160 // DriftLossPercent
161 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::DriftLossPercent);
162 ✗ if (value) {
163 ✗ evapCooler->setDriftLossPercent(value.get());
164 }
165
166 // BlowdownCalculationMode
167 ✗ s = workspaceObject.getString(EvaporativeFluidCooler_SingleSpeedFields::BlowdownCalculationMode);
168 ✗ if (s) {
169 ✗ evapCooler->setBlowdownCalculationMode(s.get());
170 }
171
172 // BlowdownConcentrationRatio
173 ✗ value = workspaceObject.getDouble(EvaporativeFluidCooler_SingleSpeedFields::BlowdownConcentrationRatio);
174 ✗ if (value) {
175 ✗ evapCooler->setBlowdownConcentrationRatio(value.get());
176 }
177
178 ✗ boost::optional<WorkspaceObject> _schedule;
179
180 // BlowdownMakeupWaterUsageScheduleName
181 ✗ _schedule = workspaceObject.getTarget(EvaporativeFluidCooler_SingleSpeedFields::BlowdownMakeupWaterUsageScheduleName);
182 ✗ if (_schedule) {
183 ✗ boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(_schedule.get());
184 ✗ if (mo) {
185 ✗ if (boost::optional<Schedule> schedule = mo->optionalCast<Schedule>()) {
186 ✗ evapCooler->setBlowdownMakeupWaterUsageSchedule(schedule.get());
187 ✗ }
188 }
189 ✗ }
190
191 ✗ return evapCooler.get();
192 ✗ } else {
193 ✗ LOG(Error, "Unknown error translating " << workspaceObject.briefDescription());
194
195 ✗ return boost::none;
196 }
197 ✗ }
198
199 } // namespace energyplus
200
201 } // namespace openstudio
202