GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 85.4% 88 / 0 / 103
Functions: 84.4% 27 / 0 / 32
Branches: 55.3% 47 / 0 / 85

src/model/SetpointManagerFollowGroundTemperature.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 "SetpointManagerFollowGroundTemperature.hpp"
7 #include "SetpointManagerFollowGroundTemperature_Impl.hpp"
8 #include "Node.hpp"
9 #include "Node_Impl.hpp"
10 #include "PlantLoop.hpp"
11
12 #include <utilities/idd/IddFactory.hxx>
13 #include <utilities/idd/OS_SetpointManager_FollowGroundTemperature_FieldEnums.hxx>
14 #include <utilities/idd/IddEnums.hxx>
15 #include "../utilities/core/Assert.hpp"
16
17 namespace openstudio {
18 namespace model {
19
20 namespace detail {
21
22 11 SetpointManagerFollowGroundTemperature_Impl::SetpointManagerFollowGroundTemperature_Impl(const IdfObject& idfObject, Model_Impl* model,
23 11 bool keepHandle)
24 11 : SetpointManager_Impl(idfObject, model, keepHandle) {
25
4/6
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 11 times.
✗ Branch 13 not taken.
11 OS_ASSERT(idfObject.iddObject().type() == SetpointManagerFollowGroundTemperature::iddObjectType());
26 11 }
27
28 ✗ SetpointManagerFollowGroundTemperature_Impl::SetpointManagerFollowGroundTemperature_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
29 ✗ Model_Impl* model, bool keepHandle)
30 ✗ : SetpointManager_Impl(other, model, keepHandle) {
31 ✗ OS_ASSERT(other.iddObject().type() == SetpointManagerFollowGroundTemperature::iddObjectType());
32 ✗ }
33
34 5 SetpointManagerFollowGroundTemperature_Impl::SetpointManagerFollowGroundTemperature_Impl(const SetpointManagerFollowGroundTemperature_Impl& other,
35 5 Model_Impl* model, bool keepHandle)
36 5 : SetpointManager_Impl(other, model, keepHandle) {}
37
38 ✗ const std::vector<std::string>& SetpointManagerFollowGroundTemperature_Impl::outputVariableNames() const {
39 ✗ static const std::vector<std::string> result;
40 ✗ return result;
41 }
42
43 ✗ IddObjectType SetpointManagerFollowGroundTemperature_Impl::iddObjectType() const {
44 ✗ return SetpointManagerFollowGroundTemperature::iddObjectType();
45 }
46
47 /** This SPM is allowed on a PlantLoop */
48 1 bool SetpointManagerFollowGroundTemperature_Impl::isAllowedOnPlantLoop() const {
49 1 return true;
50 }
51
52 18 std::string SetpointManagerFollowGroundTemperature_Impl::controlVariable() const {
53
1/1
✓ Branch 1 taken 18 times.
18 boost::optional<std::string> value = getString(OS_SetpointManager_FollowGroundTemperatureFields::ControlVariable, true);
54
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✗ Branch 4 not taken.
18 OS_ASSERT(value);
55
2/2
✓ Branch 1 taken 18 times.
✓ Branch 4 taken 18 times.
36 return value.get();
56 18 }
57
58 4 std::string SetpointManagerFollowGroundTemperature_Impl::referenceGroundTemperatureObjectType() const {
59
1/1
✓ Branch 1 taken 4 times.
4 boost::optional<std::string> value = getString(OS_SetpointManager_FollowGroundTemperatureFields::ReferenceGroundTemperatureObjectType, true);
60
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 4 not taken.
4 OS_ASSERT(value);
61
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 return value.get();
62 4 }
63
64 7 double SetpointManagerFollowGroundTemperature_Impl::offsetTemperatureDifference() const {
65
1/1
✓ Branch 1 taken 7 times.
7 boost::optional<double> value = getDouble(OS_SetpointManager_FollowGroundTemperatureFields::OffsetTemperatureDifference, true);
66
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 4 not taken.
7 OS_ASSERT(value);
67
1/1
✓ Branch 1 taken 7 times.
14 return value.get();
68 }
69
70 7 double SetpointManagerFollowGroundTemperature_Impl::maximumSetpointTemperature() const {
71
1/1
✓ Branch 1 taken 7 times.
7 boost::optional<double> value = getDouble(OS_SetpointManager_FollowGroundTemperatureFields::MaximumSetpointTemperature, true);
72
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 4 not taken.
7 OS_ASSERT(value);
73
1/1
✓ Branch 1 taken 7 times.
14 return value.get();
74 }
75
76 7 double SetpointManagerFollowGroundTemperature_Impl::minimumSetpointTemperature() const {
77
1/1
✓ Branch 1 taken 7 times.
7 boost::optional<double> value = getDouble(OS_SetpointManager_FollowGroundTemperatureFields::MinimumSetpointTemperature, true);
78
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 4 not taken.
7 OS_ASSERT(value);
79
1/1
✓ Branch 1 taken 7 times.
14 return value.get();
80 }
81
82 27 boost::optional<Node> SetpointManagerFollowGroundTemperature_Impl::setpointNode() const {
83
2/2
✓ Branch 1 taken 27 times.
✓ Branch 4 taken 27 times.
27 return getObject<ModelObject>().getModelObjectTarget<Node>(OS_SetpointManager_FollowGroundTemperatureFields::SetpointNodeorNodeListName);
84 }
85
86 20 bool SetpointManagerFollowGroundTemperature_Impl::setControlVariable(const std::string& controlVariable) {
87 20 bool result = setString(OS_SetpointManager_FollowGroundTemperatureFields::ControlVariable, controlVariable);
88 20 return result;
89 }
90
91 3 bool SetpointManagerFollowGroundTemperature_Impl::setReferenceGroundTemperatureObjectType(const std::string& groundTemperatureObjType) {
92 3 bool result = setString(OS_SetpointManager_FollowGroundTemperatureFields::ReferenceGroundTemperatureObjectType, groundTemperatureObjType);
93 3 return result;
94 }
95
96 13 bool SetpointManagerFollowGroundTemperature_Impl::setOffsetTemperatureDifference(double offsetTemperatureDifference) {
97 13 bool result = setDouble(OS_SetpointManager_FollowGroundTemperatureFields::OffsetTemperatureDifference, offsetTemperatureDifference);
98
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 OS_ASSERT(result);
99 13 return result;
100 }
101
102 13 bool SetpointManagerFollowGroundTemperature_Impl::setMaximumSetpointTemperature(double maximumSetpointTemperature) {
103 13 bool result = setDouble(OS_SetpointManager_FollowGroundTemperatureFields::MaximumSetpointTemperature, maximumSetpointTemperature);
104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 OS_ASSERT(result);
105 13 return result;
106 }
107
108 13 bool SetpointManagerFollowGroundTemperature_Impl::setMinimumSetpointTemperature(double minimumSetpointTemperature) {
109 13 bool result = setDouble(OS_SetpointManager_FollowGroundTemperatureFields::MinimumSetpointTemperature, minimumSetpointTemperature);
110
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 OS_ASSERT(result);
111 13 return result;
112 }
113
114 9 bool SetpointManagerFollowGroundTemperature_Impl::setSetpointNode(const Node& node) {
115
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
9 bool result = setPointer(OS_SetpointManager_FollowGroundTemperatureFields::SetpointNodeorNodeListName, node.handle());
116 9 return result;
117 }
118
119 2 void SetpointManagerFollowGroundTemperature_Impl::resetSetpointNode() {
120
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 bool result = setString(OS_SetpointManager_FollowGroundTemperatureFields::SetpointNodeorNodeListName, "");
121
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
122 2 }
123
124 } // namespace detail
125
126 11 SetpointManagerFollowGroundTemperature::SetpointManagerFollowGroundTemperature(const Model& model)
127 11 : SetpointManager(SetpointManagerFollowGroundTemperature::iddObjectType(), model) {
128
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
✗ Branch 5 not taken.
11 OS_ASSERT(getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>());
129
130
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
22 setControlVariable("Temperature");
131
1/1
✓ Branch 1 taken 11 times.
11 setOffsetTemperatureDifference(0);
132
1/1
✓ Branch 1 taken 11 times.
11 setMaximumSetpointTemperature(80);
133
1/1
✓ Branch 1 taken 11 times.
11 setMinimumSetpointTemperature(10);
134 11 }
135
136 7754 IddObjectType SetpointManagerFollowGroundTemperature::iddObjectType() {
137
1/1
✓ Branch 1 taken 7754 times.
7754 return {IddObjectType::OS_SetpointManager_FollowGroundTemperature};
138 }
139
140 ✗ std::vector<std::string> SetpointManagerFollowGroundTemperature::controlVariableValues() {
141 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_SetpointManager_FollowGroundTemperatureFields::ControlVariable);
142 }
143
144 ✗ std::vector<std::string> SetpointManagerFollowGroundTemperature::referenceGroundTemperatureObjectTypeValues() {
145 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
146 ✗ OS_SetpointManager_FollowGroundTemperatureFields::ReferenceGroundTemperatureObjectType);
147 }
148
149 4 std::string SetpointManagerFollowGroundTemperature::referenceGroundTemperatureObjectType() const {
150
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->referenceGroundTemperatureObjectType();
151 }
152
153 7 double SetpointManagerFollowGroundTemperature::offsetTemperatureDifference() const {
154
1/1
✓ Branch 3 taken 7 times.
7 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->offsetTemperatureDifference();
155 }
156
157 7 double SetpointManagerFollowGroundTemperature::maximumSetpointTemperature() const {
158
1/1
✓ Branch 3 taken 7 times.
7 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->maximumSetpointTemperature();
159 }
160
161 7 double SetpointManagerFollowGroundTemperature::minimumSetpointTemperature() const {
162
1/1
✓ Branch 3 taken 7 times.
7 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->minimumSetpointTemperature();
163 }
164
165 3 bool SetpointManagerFollowGroundTemperature::setReferenceGroundTemperatureObjectType(const std::string& groundTemperatureObjType) {
166
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->setReferenceGroundTemperatureObjectType(groundTemperatureObjType);
167 }
168
169 13 bool SetpointManagerFollowGroundTemperature::setOffsetTemperatureDifference(double offsetTemperatureDifference) {
170
1/1
✓ Branch 3 taken 13 times.
13 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->setOffsetTemperatureDifference(offsetTemperatureDifference);
171 }
172
173 13 bool SetpointManagerFollowGroundTemperature::setMaximumSetpointTemperature(double maximumSetpointTemperature) {
174
1/1
✓ Branch 3 taken 13 times.
13 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->setMaximumSetpointTemperature(maximumSetpointTemperature);
175 }
176
177 13 bool SetpointManagerFollowGroundTemperature::setMinimumSetpointTemperature(double minimumSetpointTemperature) {
178
1/1
✓ Branch 3 taken 13 times.
13 return getImpl<detail::SetpointManagerFollowGroundTemperature_Impl>()->setMinimumSetpointTemperature(minimumSetpointTemperature);
179 }
180
181 /// @cond
182 13 SetpointManagerFollowGroundTemperature::SetpointManagerFollowGroundTemperature(
183 13 std::shared_ptr<detail::SetpointManagerFollowGroundTemperature_Impl> impl)
184
1/1
✓ Branch 3 taken 13 times.
13 : SetpointManager(std::move(impl)) {}
185 /// @endcond
186
187 } // namespace model
188 } // namespace openstudio
189