GCC Code Coverage Report


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

src/energyplus/ReverseTranslator/ReverseTranslateControllerOutdoorAir.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/ControllerOutdoorAir.hpp"
8 #include "../../model/ControllerOutdoorAir_Impl.hpp"
9 #include "../../model/ThermalZone.hpp"
10 #include "../../model/ThermalZone_Impl.hpp"
11 #include "../../model/Space.hpp"
12 #include "../../model/Space_Impl.hpp"
13 #include "../../model/Curve.hpp"
14 #include "../../model/Curve_Impl.hpp"
15 #include "../../model/Schedule.hpp"
16 #include "../../model/Schedule_Impl.hpp"
17 #include <utilities/idd/Controller_OutdoorAir_FieldEnums.hxx>
18 #include "../../utilities/idd/IddEnums.hpp"
19 #include <utilities/idd/IddEnums.hxx>
20
21 using namespace openstudio::model;
22
23 namespace openstudio {
24
25 namespace energyplus {
26
27 ✗ OptionalModelObject ReverseTranslator::translateControllerOutdoorAir(const WorkspaceObject& workspaceObject) {
28 ✗ if (workspaceObject.iddObject().type() != IddObjectType::Controller_OutdoorAir) {
29 ✗ LOG(Error, "WorkspaceObject is not IddObjectType: Controller_OutdoorAir");
30 ✗ return boost::none;
31 }
32
33 ✗ boost::optional<WorkspaceObject> _wo;
34 ✗ boost::optional<ModelObject> _mo;
35
36 ✗ ControllerOutdoorAir mo(m_model);
37
38 ✗ boost::optional<std::string> s = workspaceObject.getString(Controller_OutdoorAirFields::Name);
39 ✗ if (s) {
40 ✗ mo.setName(s.get());
41 }
42
43 ✗ boost::optional<double> value = workspaceObject.getDouble(Controller_OutdoorAirFields::MinimumOutdoorAirFlowRate);
44 ✗ if (value) {
45 ✗ mo.setMinimumOutdoorAirFlowRate(value.get());
46 }
47
48 ✗ value = workspaceObject.getDouble(Controller_OutdoorAirFields::MaximumOutdoorAirFlowRate);
49 ✗ if (value) {
50 ✗ mo.setMaximumOutdoorAirFlowRate(value.get());
51 }
52
53 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::EconomizerControlType);
54 ✗ if (s) {
55 ✗ mo.setEconomizerControlType(s.get());
56 }
57
58 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::EconomizerControlActionType);
59 ✗ if (s) {
60 ✗ mo.setEconomizerControlActionType(s.get());
61 }
62
63 ✗ value = workspaceObject.getDouble(Controller_OutdoorAirFields::EconomizerMinimumLimitDryBulbTemperature);
64 ✗ if (value) {
65 ✗ mo.setEconomizerMaximumLimitDryBulbTemperature(value.get());
66 }
67
68 ✗ value = workspaceObject.getDouble(Controller_OutdoorAirFields::EconomizerMaximumLimitEnthalpy);
69 ✗ if (value) {
70 ✗ mo.setEconomizerMaximumLimitEnthalpy(value.get());
71 }
72
73 ✗ value = workspaceObject.getDouble(Controller_OutdoorAirFields::EconomizerMaximumLimitDewpointTemperature);
74 ✗ if (value) {
75 ✗ mo.setEconomizerMaximumLimitDewpointTemperature(value.get());
76 }
77
78 ✗ if ((_wo = workspaceObject.getTarget(Controller_OutdoorAirFields::ElectronicEnthalpyLimitCurveName))) {
79 ✗ if ((_mo = translateAndMapWorkspaceObject(_wo.get()))) {
80 ✗ if (boost::optional<Curve> _curve = _mo->optionalCast<Curve>()) {
81 ✗ mo.setElectronicEnthalpyLimitCurve(_curve.get());
82 } else {
83 ✗ LOG(Warn, workspaceObject.briefDescription() << " has a wrong type for 'Electronic Enthalpy Limit Curve Name'");
84 ✗ }
85 }
86 }
87
88 ✗ value = workspaceObject.getDouble(Controller_OutdoorAirFields::EconomizerMinimumLimitDryBulbTemperature);
89 ✗ if (value) {
90 ✗ mo.setEconomizerMinimumLimitDryBulbTemperature(value.get());
91 }
92
93 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::LockoutType);
94 ✗ if (s) {
95 ✗ mo.setLockoutType(s.get());
96 }
97
98 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::MinimumLimitType);
99 ✗ if (s) {
100 ✗ mo.setMinimumLimitType(s.get());
101 }
102
103 ✗ if ((_wo = workspaceObject.getTarget(Controller_OutdoorAirFields::MinimumOutdoorAirScheduleName))) {
104 ✗ if ((_mo = translateAndMapWorkspaceObject(_wo.get()))) {
105 ✗ if (boost::optional<Schedule> _schedule = _mo->optionalCast<Schedule>()) {
106 ✗ mo.setMinimumOutdoorAirSchedule(_schedule.get());
107 } else {
108 ✗ LOG(Warn, workspaceObject.briefDescription() << " has a wrong type for 'Minimum Outdoor Air Schedule Name'");
109 ✗ }
110 }
111 }
112
113 ✗ if ((_wo = workspaceObject.getTarget(Controller_OutdoorAirFields::MinimumFractionofOutdoorAirScheduleName))) {
114 ✗ if ((_mo = translateAndMapWorkspaceObject(_wo.get()))) {
115 ✗ if (boost::optional<Schedule> _schedule = _mo->optionalCast<Schedule>()) {
116 ✗ mo.setMinimumFractionofOutdoorAirSchedule(_schedule.get());
117 } else {
118 ✗ LOG(Warn, workspaceObject.briefDescription() << " has a wrong type for 'Minimum Fraction of Outdoor Air Schedule Name'");
119 ✗ }
120 }
121 }
122
123 ✗ if ((_wo = workspaceObject.getTarget(Controller_OutdoorAirFields::MaximumFractionofOutdoorAirScheduleName))) {
124 ✗ if ((_mo = translateAndMapWorkspaceObject(_wo.get()))) {
125 ✗ if (boost::optional<Schedule> _schedule = _mo->optionalCast<Schedule>()) {
126 ✗ mo.setMaximumFractionofOutdoorAirSchedule(_schedule.get());
127 } else {
128 ✗ LOG(Warn, workspaceObject.briefDescription() << " has a wrong type for 'Maximum Fraction of Outdoor Air Schedule Name'");
129 ✗ }
130 }
131 }
132
133 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::MechanicalVentilationControllerName);
134 ✗ if (s) {
135 ✗ LOG(Warn,
136 "ControllerOutdoorAir " << workspaceObject.briefDescription() << " references a mechanical ventilation controller, which is not supported");
137 }
138
139 ✗ if ((_wo = workspaceObject.getTarget(Controller_OutdoorAirFields::TimeofDayEconomizerControlScheduleName))) {
140 ✗ if ((_mo = translateAndMapWorkspaceObject(_wo.get()))) {
141 ✗ if (boost::optional<Schedule> _schedule = _mo->optionalCast<Schedule>()) {
142 ✗ mo.setTimeofDayEconomizerControlSchedule(_schedule.get());
143 } else {
144 ✗ LOG(Warn, workspaceObject.briefDescription() << " has a wrong type for 'Time of Day Economizer Control Schedule Name'");
145 ✗ }
146 }
147 }
148
149 ✗ if ((_wo = workspaceObject.getTarget(Controller_OutdoorAirFields::HumidistatControlZoneName))) {
150 ✗ if ((_mo = translateAndMapWorkspaceObject(_wo.get()))) {
151 // Zone is translated, and a Space is returned instead
152 ✗ if (boost::optional<Space> space_ = _mo->optionalCast<Space>()) {
153 ✗ if (auto z_ = space_->thermalZone()) {
154 ✗ mo.setHumidistatControlZone(z_.get());
155 ✗ }
156 } else {
157 ✗ LOG(Warn, workspaceObject.briefDescription() << " has a wrong type for 'Humidistat Control Zone Name'");
158 ✗ }
159 }
160 }
161
162 ✗ value = workspaceObject.getDouble(Controller_OutdoorAirFields::HighHumidityOutdoorAirFlowRatio);
163 ✗ if (value) {
164 ✗ mo.setHighHumidityOutdoorAirFlowRatio(value.get());
165 }
166
167 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::ControlHighIndoorHumidityBasedonOutdoorHumidityRatio);
168 ✗ if (s) {
169 ✗ if (istringEqual("Yes", s.get())) {
170 ✗ mo.setControlHighIndoorHumidityBasedOnOutdoorHumidityRatio(true);
171 } else {
172 ✗ mo.setControlHighIndoorHumidityBasedOnOutdoorHumidityRatio(false);
173 }
174 }
175
176 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::HeatRecoveryBypassControlType);
177 ✗ if (s) {
178 ✗ mo.setHeatRecoveryBypassControlType(s.get());
179 }
180
181 ✗ s = workspaceObject.getString(Controller_OutdoorAirFields::EconomizerOperationStaging);
182 ✗ if (s) {
183 ✗ mo.setEconomizerOperationStaging(s.get());
184 }
185
186 ✗ return mo;
187 ✗ }
188
189 } // namespace energyplus
190
191 } // namespace openstudio
192