GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 87.9% 116 / 0 / 132
Functions: 88.1% 37 / 0 / 42
Branches: 62.9% 66 / 0 / 105

src/model/SetpointManagerFollowSystemNodeTemperature.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 "SetpointManagerFollowSystemNodeTemperature.hpp"
7 #include "SetpointManagerFollowSystemNodeTemperature_Impl.hpp"
8
9 #include "Node.hpp"
10 #include "Node_Impl.hpp"
11 #include "PlantLoop.hpp"
12 #include "Model.hpp"
13
14 #include <utilities/idd/IddFactory.hxx>
15 #include <utilities/idd/OS_SetpointManager_FollowSystemNodeTemperature_FieldEnums.hxx>
16 #include <utilities/idd/IddEnums.hxx>
17 #include "../utilities/core/Assert.hpp"
18
19 namespace openstudio {
20 namespace model {
21
22 namespace detail {
23
24 9 SetpointManagerFollowSystemNodeTemperature_Impl::SetpointManagerFollowSystemNodeTemperature_Impl(const IdfObject& idfObject, Model_Impl* model,
25 9 bool keepHandle)
26 9 : SetpointManager_Impl(idfObject, model, keepHandle) {
27
4/6
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
✓ Branch 7 taken 9 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 9 times.
✗ Branch 13 not taken.
9 OS_ASSERT(idfObject.iddObject().type() == SetpointManagerFollowSystemNodeTemperature::iddObjectType());
28 9 }
29
30 ✗ SetpointManagerFollowSystemNodeTemperature_Impl::SetpointManagerFollowSystemNodeTemperature_Impl(
31 ✗ const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
32 ✗ : SetpointManager_Impl(other, model, keepHandle) {
33 ✗ OS_ASSERT(other.iddObject().type() == SetpointManagerFollowSystemNodeTemperature::iddObjectType());
34 ✗ }
35
36 4 SetpointManagerFollowSystemNodeTemperature_Impl::SetpointManagerFollowSystemNodeTemperature_Impl(
37 4 const SetpointManagerFollowSystemNodeTemperature_Impl& other, Model_Impl* model, bool keepHandle)
38 4 : SetpointManager_Impl(other, model, keepHandle) {}
39
40 ✗ const std::vector<std::string>& SetpointManagerFollowSystemNodeTemperature_Impl::outputVariableNames() const {
41 ✗ static const std::vector<std::string> result;
42 ✗ return result;
43 }
44
45 ✗ IddObjectType SetpointManagerFollowSystemNodeTemperature_Impl::iddObjectType() const {
46 ✗ return SetpointManagerFollowSystemNodeTemperature::iddObjectType();
47 }
48
49 /** This SPM is allowed on a PlantLoop */
50 1 bool SetpointManagerFollowSystemNodeTemperature_Impl::isAllowedOnPlantLoop() const {
51 1 return true;
52 }
53
54 2 ModelObject SetpointManagerFollowSystemNodeTemperature_Impl::clone(Model model) const {
55
3/3
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
2 auto clonedObject = SetpointManager_Impl::clone(model).cast<SetpointManagerFollowSystemNodeTemperature>();
56
1/1
✓ Branch 1 taken 2 times.
2 clonedObject.resetReferenceNode();
57 4 return std::move(clonedObject);
58 2 }
59
60 17 std::string SetpointManagerFollowSystemNodeTemperature_Impl::controlVariable() const {
61
1/1
✓ Branch 1 taken 17 times.
17 boost::optional<std::string> value = getString(OS_SetpointManager_FollowSystemNodeTemperatureFields::ControlVariable, true);
62
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✗ Branch 4 not taken.
17 OS_ASSERT(value);
63
2/2
✓ Branch 1 taken 17 times.
✓ Branch 4 taken 17 times.
34 return value.get();
64 17 }
65
66 4 boost::optional<Node> SetpointManagerFollowSystemNodeTemperature_Impl::referenceNode() const {
67
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_FollowSystemNodeTemperatureFields::ReferenceNodeName);
68 }
69
70 6 std::string SetpointManagerFollowSystemNodeTemperature_Impl::referenceTemperatureType() const {
71
1/1
✓ Branch 1 taken 6 times.
6 boost::optional<std::string> value = getString(OS_SetpointManager_FollowSystemNodeTemperatureFields::ReferenceTemperatureType, true);
72
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 4 not taken.
6 OS_ASSERT(value);
73
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
12 return value.get();
74 6 }
75
76 6 double SetpointManagerFollowSystemNodeTemperature_Impl::offsetTemperatureDifference() const {
77
1/1
✓ Branch 1 taken 6 times.
6 boost::optional<double> value = getDouble(OS_SetpointManager_FollowSystemNodeTemperatureFields::OffsetTemperatureDifference, true);
78
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 4 not taken.
6 OS_ASSERT(value);
79
1/1
✓ Branch 1 taken 6 times.
12 return value.get();
80 }
81
82 6 double SetpointManagerFollowSystemNodeTemperature_Impl::maximumLimitSetpointTemperature() const {
83
1/1
✓ Branch 1 taken 6 times.
6 boost::optional<double> value = getDouble(OS_SetpointManager_FollowSystemNodeTemperatureFields::MaximumLimitSetpointTemperature, true);
84
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 4 not taken.
6 OS_ASSERT(value);
85
1/1
✓ Branch 1 taken 6 times.
12 return value.get();
86 }
87
88 6 double SetpointManagerFollowSystemNodeTemperature_Impl::minimumLimitSetpointTemperature() const {
89
1/1
✓ Branch 1 taken 6 times.
6 boost::optional<double> value = getDouble(OS_SetpointManager_FollowSystemNodeTemperatureFields::MinimumLimitSetpointTemperature, true);
90
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 4 not taken.
6 OS_ASSERT(value);
91
1/1
✓ Branch 1 taken 6 times.
12 return value.get();
92 }
93
94 21 boost::optional<Node> SetpointManagerFollowSystemNodeTemperature_Impl::setpointNode() const {
95
2/2
✓ Branch 1 taken 21 times.
✓ Branch 4 taken 21 times.
21 return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_FollowSystemNodeTemperatureFields::SetpointNodeorNodeListName);
96 }
97
98 17 bool SetpointManagerFollowSystemNodeTemperature_Impl::setControlVariable(const std::string& controlVariable) {
99 17 bool result = setString(OS_SetpointManager_FollowSystemNodeTemperatureFields::ControlVariable, controlVariable);
100 17 return result;
101 }
102
103 2 bool SetpointManagerFollowSystemNodeTemperature_Impl::setReferenceNode(const Node& node) {
104
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 bool result = setPointer(OS_SetpointManager_FollowSystemNodeTemperatureFields::ReferenceNodeName, node.handle());
105 2 return result;
106 }
107
108 2 void SetpointManagerFollowSystemNodeTemperature_Impl::resetReferenceNode() {
109
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 bool result = setString(OS_SetpointManager_FollowSystemNodeTemperatureFields::ReferenceNodeName, "");
110
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
111 2 }
112
113 10 bool SetpointManagerFollowSystemNodeTemperature_Impl::setReferenceTemperatureType(const std::string& referenceTemperatureType) {
114 10 bool result = setString(OS_SetpointManager_FollowSystemNodeTemperatureFields::ReferenceTemperatureType, referenceTemperatureType);
115 10 return result;
116 }
117
118 10 bool SetpointManagerFollowSystemNodeTemperature_Impl::setOffsetTemperatureDifference(double offsetTemperatureDifference) {
119 10 bool result = setDouble(OS_SetpointManager_FollowSystemNodeTemperatureFields::OffsetTemperatureDifference, offsetTemperatureDifference);
120
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 OS_ASSERT(result);
121 10 return result;
122 }
123
124 10 bool SetpointManagerFollowSystemNodeTemperature_Impl::setMaximumLimitSetpointTemperature(double maximumLimitSetpointTemperature) {
125 10 bool result = setDouble(OS_SetpointManager_FollowSystemNodeTemperatureFields::MaximumLimitSetpointTemperature, maximumLimitSetpointTemperature);
126
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 OS_ASSERT(result);
127 10 return result;
128 }
129
130 10 bool SetpointManagerFollowSystemNodeTemperature_Impl::setMinimumLimitSetpointTemperature(double minimumLimitSetpointTemperature) {
131 10 bool result = setDouble(OS_SetpointManager_FollowSystemNodeTemperatureFields::MinimumLimitSetpointTemperature, minimumLimitSetpointTemperature);
132
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 OS_ASSERT(result);
133 10 return result;
134 }
135
136 8 bool SetpointManagerFollowSystemNodeTemperature_Impl::setSetpointNode(const Node& node) {
137
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
8 bool result = setPointer(OS_SetpointManager_FollowSystemNodeTemperatureFields::SetpointNodeorNodeListName, node.handle());
138 8 return result;
139 }
140
141 2 void SetpointManagerFollowSystemNodeTemperature_Impl::resetSetpointNode() {
142
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 bool result = setString(OS_SetpointManager_FollowSystemNodeTemperatureFields::SetpointNodeorNodeListName, "");
143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
144 2 }
145
146 } // namespace detail
147
148 9 SetpointManagerFollowSystemNodeTemperature::SetpointManagerFollowSystemNodeTemperature(const Model& model)
149 9 : SetpointManager(SetpointManagerFollowSystemNodeTemperature::iddObjectType(), model) {
150
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
✗ Branch 5 not taken.
9 OS_ASSERT(getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>());
151
152
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
18 setReferenceTemperatureType("NodeDryBulb");
153
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
9 setControlVariable("Temperature");
154
1/1
✓ Branch 1 taken 9 times.
9 setOffsetTemperatureDifference(0);
155
1/1
✓ Branch 1 taken 9 times.
9 setMaximumLimitSetpointTemperature(100);
156
1/1
✓ Branch 1 taken 9 times.
9 setMinimumLimitSetpointTemperature(0);
157 9 }
158
159 7620 IddObjectType SetpointManagerFollowSystemNodeTemperature::iddObjectType() {
160
1/1
✓ Branch 1 taken 7620 times.
7620 return {IddObjectType::OS_SetpointManager_FollowSystemNodeTemperature};
161 }
162
163 ✗ std::vector<std::string> SetpointManagerFollowSystemNodeTemperature::controlVariableValues() {
164 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
165 ✗ OS_SetpointManager_FollowSystemNodeTemperatureFields::ControlVariable);
166 }
167
168 ✗ std::vector<std::string> SetpointManagerFollowSystemNodeTemperature::referenceTemperatureTypeValues() {
169 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
170 ✗ OS_SetpointManager_FollowSystemNodeTemperatureFields::ReferenceTemperatureType);
171 }
172
173 5 std::string SetpointManagerFollowSystemNodeTemperature::controlVariable() const {
174
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->controlVariable();
175 }
176
177 4 boost::optional<Node> SetpointManagerFollowSystemNodeTemperature::referenceNode() const {
178
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->referenceNode();
179 }
180
181 6 std::string SetpointManagerFollowSystemNodeTemperature::referenceTemperatureType() const {
182
1/1
✓ Branch 3 taken 6 times.
6 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->referenceTemperatureType();
183 }
184
185 6 double SetpointManagerFollowSystemNodeTemperature::offsetTemperatureDifference() const {
186
1/1
✓ Branch 3 taken 6 times.
6 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->offsetTemperatureDifference();
187 }
188
189 6 double SetpointManagerFollowSystemNodeTemperature::maximumLimitSetpointTemperature() const {
190
1/1
✓ Branch 3 taken 6 times.
6 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->maximumLimitSetpointTemperature();
191 }
192
193 6 double SetpointManagerFollowSystemNodeTemperature::minimumLimitSetpointTemperature() const {
194
1/1
✓ Branch 3 taken 6 times.
6 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->minimumLimitSetpointTemperature();
195 }
196
197 8 boost::optional<Node> SetpointManagerFollowSystemNodeTemperature::setpointNode() const {
198
1/1
✓ Branch 3 taken 8 times.
8 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->setpointNode();
199 }
200
201 17 bool SetpointManagerFollowSystemNodeTemperature::setControlVariable(const std::string& controlVariable) {
202
1/1
✓ Branch 3 taken 17 times.
17 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->setControlVariable(controlVariable);
203 }
204
205 2 bool SetpointManagerFollowSystemNodeTemperature::setReferenceNode(const Node& node) {
206
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->setReferenceNode(node);
207 }
208
209 2 void SetpointManagerFollowSystemNodeTemperature::resetReferenceNode() {
210
1/1
✓ Branch 3 taken 2 times.
2 getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->resetReferenceNode();
211 2 }
212
213 10 bool SetpointManagerFollowSystemNodeTemperature::setReferenceTemperatureType(const std::string& referenceTemperatureType) {
214
1/1
✓ Branch 3 taken 10 times.
10 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->setReferenceTemperatureType(referenceTemperatureType);
215 }
216
217 10 bool SetpointManagerFollowSystemNodeTemperature::setOffsetTemperatureDifference(double offsetTemperatureDifference) {
218
1/1
✓ Branch 3 taken 10 times.
10 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->setOffsetTemperatureDifference(offsetTemperatureDifference);
219 }
220
221 10 bool SetpointManagerFollowSystemNodeTemperature::setMaximumLimitSetpointTemperature(double maximumLimitSetpointTemperature) {
222
1/1
✓ Branch 3 taken 10 times.
10 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->setMaximumLimitSetpointTemperature(maximumLimitSetpointTemperature);
223 }
224
225 10 bool SetpointManagerFollowSystemNodeTemperature::setMinimumLimitSetpointTemperature(double minimumLimitSetpointTemperature) {
226
1/1
✓ Branch 3 taken 10 times.
10 return getImpl<detail::SetpointManagerFollowSystemNodeTemperature_Impl>()->setMinimumLimitSetpointTemperature(minimumLimitSetpointTemperature);
227 }
228
229 /// @cond
230 14 SetpointManagerFollowSystemNodeTemperature::SetpointManagerFollowSystemNodeTemperature(
231 14 std::shared_ptr<detail::SetpointManagerFollowSystemNodeTemperature_Impl> impl)
232
1/1
✓ Branch 3 taken 14 times.
14 : SetpointManager(std::move(impl)) {}
233 /// @endcond
234
235 } // namespace model
236 } // namespace openstudio
237