GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 51.8% 59 / 0 / 114
Functions: 57.5% 23 / 0 / 40
Branches: 29.5% 28 / 0 / 95

src/model/ConvergenceLimits.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 "ConvergenceLimits.hpp"
7 #include "ConvergenceLimits_Impl.hpp"
8 #include "SimulationControl.hpp"
9 #include "SimulationControl_Impl.hpp"
10 #include "Model.hpp"
11 #include "Model_Impl.hpp"
12 #include "../utilities/core/Assert.hpp"
13 #include <utilities/idd/OS_ConvergenceLimits_FieldEnums.hxx>
14 #include <utilities/idd/IddEnums.hxx>
15
16 namespace openstudio {
17 namespace model {
18
19 namespace detail {
20
21 220 ConvergenceLimits_Impl::ConvergenceLimits_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
22 220 : ModelObject_Impl(idfObject, model, keepHandle) {
23
4/6
✓ Branch 1 taken 220 times.
✓ Branch 4 taken 220 times.
✓ Branch 7 taken 220 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 220 times.
✗ Branch 13 not taken.
220 OS_ASSERT(idfObject.iddObject().type() == ConvergenceLimits::iddObjectType());
24 220 }
25
26 44 ConvergenceLimits_Impl::ConvergenceLimits_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
27 44 : ModelObject_Impl(other, model, keepHandle) {
28
4/6
✓ Branch 1 taken 44 times.
✓ Branch 4 taken 44 times.
✓ Branch 7 taken 44 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 44 times.
✗ Branch 13 not taken.
44 OS_ASSERT(other.iddObject().type() == ConvergenceLimits::iddObjectType());
29 44 }
30
31 110 ConvergenceLimits_Impl::ConvergenceLimits_Impl(const ConvergenceLimits_Impl& other, Model_Impl* model, bool keepHandle)
32 110 : ModelObject_Impl(other, model, keepHandle) {}
33
34 1 const std::vector<std::string>& ConvergenceLimits_Impl::outputVariableNames() const {
35
2/4
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
1 static const std::vector<std::string> result;
36 1 return result;
37 }
38
39 1 IddObjectType ConvergenceLimits_Impl::iddObjectType() const {
40 1 return ConvergenceLimits::iddObjectType();
41 }
42
43 1 boost::optional<ParentObject> ConvergenceLimits_Impl::parent() const {
44
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
1 boost::optional<ParentObject> result(model().getUniqueModelObject<SimulationControl>());
45 1 return result;
46 }
47
48 ✗ bool ConvergenceLimits_Impl::setParent(ParentObject& newParent) {
49 ✗ if (newParent.optionalCast<SimulationControl>() && (newParent.model() == model())) {
50 ✗ return true;
51 }
52 ✗ return false;
53 }
54
55 45 boost::optional<int> ConvergenceLimits_Impl::minimumSystemTimestep() const {
56 45 return getInt(OS_ConvergenceLimitsFields::MinimumSystemTimestep, true);
57 }
58
59 1 int ConvergenceLimits_Impl::maximumHVACIterations() const {
60
1/1
✓ Branch 1 taken 1 time.
1 boost::optional<int> value = getInt(OS_ConvergenceLimitsFields::MaximumHVACIterations, true);
61
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 4 not taken.
1 OS_ASSERT(value);
62
1/1
✓ Branch 1 taken 1 time.
2 return value.get();
63 }
64
65 45 bool ConvergenceLimits_Impl::isMaximumHVACIterationsDefaulted() const {
66 45 return isEmpty(OS_ConvergenceLimitsFields::MaximumHVACIterations);
67 }
68
69 ✗ int ConvergenceLimits_Impl::minimumPlantIterations() const {
70 ✗ boost::optional<int> value = getInt(OS_ConvergenceLimitsFields::MinimumPlantIterations, true);
71 ✗ OS_ASSERT(value);
72 ✗ return value.get();
73 }
74
75 45 bool ConvergenceLimits_Impl::isMinimumPlantIterationsDefaulted() const {
76 45 return isEmpty(OS_ConvergenceLimitsFields::MinimumPlantIterations);
77 }
78
79 ✗ int ConvergenceLimits_Impl::maximumPlantIterations() const {
80 ✗ boost::optional<int> value = getInt(OS_ConvergenceLimitsFields::MaximumPlantIterations, true);
81 ✗ OS_ASSERT(value);
82 ✗ return value.get();
83 }
84
85 45 bool ConvergenceLimits_Impl::isMaximumPlantIterationsDefaulted() const {
86 45 return isEmpty(OS_ConvergenceLimitsFields::MaximumPlantIterations);
87 }
88
89 178 bool ConvergenceLimits_Impl::setMinimumSystemTimestep(boost::optional<int> minimumSystemTimestep) {
90 178 bool result = false;
91
1/2
✓ Branch 0 taken 178 times.
✗ Branch 1 not taken.
178 if (minimumSystemTimestep) {
92 178 result = setInt(OS_ConvergenceLimitsFields::MinimumSystemTimestep, minimumSystemTimestep.get());
93 } else {
94 ✗ result = setString(OS_ConvergenceLimitsFields::MinimumSystemTimestep, "");
95 }
96 178 return result;
97 }
98
99 ✗ void ConvergenceLimits_Impl::resetMinimumSystemTimestep() {
100 ✗ bool result = setString(OS_ConvergenceLimitsFields::MinimumSystemTimestep, "");
101 ✗ OS_ASSERT(result);
102 ✗ }
103
104 3 bool ConvergenceLimits_Impl::setMaximumHVACIterations(int maximumHVACIterations) {
105 3 bool result = setInt(OS_ConvergenceLimitsFields::MaximumHVACIterations, maximumHVACIterations);
106 3 return result;
107 }
108
109 ✗ void ConvergenceLimits_Impl::resetMaximumHVACIterations() {
110 ✗ bool result = setString(OS_ConvergenceLimitsFields::MaximumHVACIterations, "");
111 ✗ OS_ASSERT(result);
112 ✗ }
113
114 ✗ bool ConvergenceLimits_Impl::setMinimumPlantIterations(int minimumPlantIterations) {
115 ✗ bool result = setInt(OS_ConvergenceLimitsFields::MinimumPlantIterations, minimumPlantIterations);
116 ✗ return result;
117 }
118
119 ✗ void ConvergenceLimits_Impl::resetMinimumPlantIterations() {
120 ✗ bool result = setString(OS_ConvergenceLimitsFields::MinimumPlantIterations, "");
121 ✗ OS_ASSERT(result);
122 ✗ }
123
124 ✗ bool ConvergenceLimits_Impl::setMaximumPlantIterations(int maximumPlantIterations) {
125 ✗ bool result = setInt(OS_ConvergenceLimitsFields::MaximumPlantIterations, maximumPlantIterations);
126 ✗ return result;
127 }
128
129 ✗ void ConvergenceLimits_Impl::resetMaximumPlantIterations() {
130 ✗ bool result = setString(OS_ConvergenceLimitsFields::MaximumPlantIterations, "");
131 ✗ OS_ASSERT(result);
132 ✗ }
133
134 } // namespace detail
135
136 9246 IddObjectType ConvergenceLimits::iddObjectType() {
137
1/1
✓ Branch 1 taken 9246 times.
9246 IddObjectType result(IddObjectType::OS_ConvergenceLimits);
138 9246 return result;
139 }
140
141 45 boost::optional<int> ConvergenceLimits::minimumSystemTimestep() const {
142
1/1
✓ Branch 3 taken 45 times.
45 return getImpl<detail::ConvergenceLimits_Impl>()->minimumSystemTimestep();
143 }
144
145 1 int ConvergenceLimits::maximumHVACIterations() const {
146
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ConvergenceLimits_Impl>()->maximumHVACIterations();
147 }
148
149 45 bool ConvergenceLimits::isMaximumHVACIterationsDefaulted() const {
150
1/1
✓ Branch 3 taken 45 times.
45 return getImpl<detail::ConvergenceLimits_Impl>()->isMaximumHVACIterationsDefaulted();
151 }
152
153 ✗ int ConvergenceLimits::minimumPlantIterations() const {
154 ✗ return getImpl<detail::ConvergenceLimits_Impl>()->minimumPlantIterations();
155 }
156
157 45 bool ConvergenceLimits::isMinimumPlantIterationsDefaulted() const {
158
1/1
✓ Branch 3 taken 45 times.
45 return getImpl<detail::ConvergenceLimits_Impl>()->isMinimumPlantIterationsDefaulted();
159 }
160
161 ✗ int ConvergenceLimits::maximumPlantIterations() const {
162 ✗ return getImpl<detail::ConvergenceLimits_Impl>()->maximumPlantIterations();
163 }
164
165 45 bool ConvergenceLimits::isMaximumPlantIterationsDefaulted() const {
166
1/1
✓ Branch 3 taken 45 times.
45 return getImpl<detail::ConvergenceLimits_Impl>()->isMaximumPlantIterationsDefaulted();
167 }
168
169 178 bool ConvergenceLimits::setMinimumSystemTimestep(int minimumSystemTimestep) {
170
2/2
✓ Branch 3 taken 178 times.
✓ Branch 6 taken 178 times.
178 return getImpl<detail::ConvergenceLimits_Impl>()->setMinimumSystemTimestep(minimumSystemTimestep);
171 }
172
173 ✗ void ConvergenceLimits::resetMinimumSystemTimestep() {
174 ✗ getImpl<detail::ConvergenceLimits_Impl>()->resetMinimumSystemTimestep();
175 ✗ }
176
177 3 bool ConvergenceLimits::setMaximumHVACIterations(int maximumHVACIterations) {
178
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::ConvergenceLimits_Impl>()->setMaximumHVACIterations(maximumHVACIterations);
179 }
180
181 ✗ void ConvergenceLimits::resetMaximumHVACIterations() {
182 ✗ getImpl<detail::ConvergenceLimits_Impl>()->resetMaximumHVACIterations();
183 ✗ }
184
185 ✗ bool ConvergenceLimits::setMinimumPlantIterations(int minimumPlantIterations) {
186 ✗ return getImpl<detail::ConvergenceLimits_Impl>()->setMinimumPlantIterations(minimumPlantIterations);
187 }
188
189 ✗ void ConvergenceLimits::resetMinimumPlantIterations() {
190 ✗ getImpl<detail::ConvergenceLimits_Impl>()->resetMinimumPlantIterations();
191 ✗ }
192
193 ✗ bool ConvergenceLimits::setMaximumPlantIterations(int maximumPlantIterations) {
194 ✗ return getImpl<detail::ConvergenceLimits_Impl>()->setMaximumPlantIterations(maximumPlantIterations);
195 }
196
197 ✗ void ConvergenceLimits::resetMaximumPlantIterations() {
198 ✗ getImpl<detail::ConvergenceLimits_Impl>()->resetMaximumPlantIterations();
199 ✗ }
200
201 /// @cond
202
1/1
✓ Branch 3 taken 115 times.
115 ConvergenceLimits::ConvergenceLimits(std::shared_ptr<detail::ConvergenceLimits_Impl> impl) : ModelObject(std::move(impl)) {}
203
204 175 ConvergenceLimits::ConvergenceLimits(Model& model) : ModelObject(ConvergenceLimits::iddObjectType(), model) {
205
1/1
✓ Branch 1 taken 175 times.
175 setMinimumSystemTimestep(1);
206 175 }
207 /// @endcond
208
209 } // namespace model
210 } // namespace openstudio
211