Tempus Version of the Day
Time Integration
Loading...
Searching...
No Matches
Tempus_UnitTest_TimeStepControlStrategyComposite.cpp
Go to the documentation of this file.
1// @HEADER
2// ****************************************************************************
3// Tempus: Copyright (2017) Sandia Corporation
4//
5// Distributed under BSD 3-clause license (See accompanying file Copyright.txt)
6// ****************************************************************************
7// @HEADER
8
10
11#include "Tempus_TimeStepControl.hpp"
16
17
18namespace Tempus_Unit_Test {
19
20using Teuchos::RCP;
21using Teuchos::rcp;
22using Teuchos::rcp_const_cast;
23using Teuchos::rcp_dynamic_cast;
24using Teuchos::ParameterList;
25using Teuchos::sublist;
26
27
28// ************************************************************
29// ************************************************************
30TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Default_Construction_1)
31{
33 TEUCHOS_TEST_FOR_EXCEPT(tscsc->isInitialized()); // Should NOT be initialized.
34
35 auto tscsConstant = rcp(new Tempus::TimeStepControlStrategyConstant<double>());
36 tscsc->addStrategy(tscsConstant);
37 tscsc->initialize();
38 TEUCHOS_TEST_FOR_EXCEPT(!tscsc->isInitialized());
39
40 TEST_COMPARE(tscsc->size(), ==, 1);
41
42 std::vector<Teuchos::RCP<Tempus::TimeStepControlStrategy<double>>>
43 strategies = tscsc->getStrategies();
44
45 auto strategyConstant = rcp_dynamic_cast<Tempus::TimeStepControlStrategyConstant<double> > (strategies[0]);
46
47 TEUCHOS_TEST_FOR_EXCEPT(strategyConstant->getStepType() != "Constant");
48 TEUCHOS_TEST_FOR_EXCEPT(strategyConstant->getConstantTimeStep() != 0.0);
49}
50
51
52// ************************************************************
53// ************************************************************
54TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Default_Construction_2)
55{
57 TEUCHOS_TEST_FOR_EXCEPT(tscsc->isInitialized()); // Should NOT be initialized.
58
59 auto tscsBasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
60 tscsc->addStrategy(tscsBasicVS);
62 tscsc->addStrategy(tscsIntCtrl);
63 tscsc->initialize();
64 TEUCHOS_TEST_FOR_EXCEPT(!tscsc->isInitialized());
65
66 TEST_COMPARE(tscsc->size(), ==, 2);
67
68 std::vector<Teuchos::RCP<Tempus::TimeStepControlStrategy<double>>>
69 strategies = tscsc->getStrategies();
70
71 auto strategyBasicVS = rcp_dynamic_cast<Tempus::TimeStepControlStrategyBasicVS<double> > (strategies[0]);
72 TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getStrategyType() != "Basic VS");
73
74 auto strategyIntCtrl = rcp_dynamic_cast<Tempus::TimeStepControlStrategyIntegralController<double> > (strategies[1]);
75 TEUCHOS_TEST_FOR_EXCEPT(strategyIntCtrl->getStrategyType() != "Integral Controller");
76}
77
78
79// ************************************************************
80// ************************************************************
81TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Create_Construction)
82{
83 // Construct ParmeterList for testing.
84 auto tscsc_temp = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
85 auto tscs_BasicVS =
87 auto tscs_IC =
89
90 tscsc_temp->addStrategy(tscs_BasicVS);
91 tscsc_temp->addStrategy(tscs_IC);
92 tscsc_temp->initialize();
93 TEUCHOS_TEST_FOR_EXCEPT(!tscsc_temp->isInitialized());
94
95 auto pl = rcp_const_cast<Teuchos::ParameterList>(tscsc_temp->getValidParameters());
96
97 auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
98
99 TEST_COMPARE(tscsc->size(), ==, 2);
100
101 std::vector<Teuchos::RCP<Tempus::TimeStepControlStrategy<double>>>
102 strategies = tscsc->getStrategies();
103
104 auto strategyBasicVS = Teuchos::rcp_dynamic_cast<Tempus::TimeStepControlStrategyBasicVS<double> > (strategies[0]);
105
106 TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getStepType() != "Variable");
107 TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getAmplFactor() != 1.75);
108 TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getReductFactor() != 0.5);
109 TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getMinEta() != 0.0);
110 TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getMaxEta() != 1.0e+16);
111
112 auto strategyIC = Teuchos::rcp_dynamic_cast<Tempus::TimeStepControlStrategyIntegralController<double> > (strategies[1]);
113
114 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getStepType() != "Variable");
115 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getController() != "PID");
116 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getKI() != 0.58);
117 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getKP() != 0.21);
118 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getKD() != 0.10);
119 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getSafetyFactor() != 0.90);
120 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getSafetyFactorAfterReject() != 0.90);
121 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getFacMax() != 5.0);
122 TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getFacMin() != 0.5);
123}
124
125
126// ************************************************************
127// ************************************************************
128TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, getValidParameters)
129{
130 // Construct ParmeterList for testing.
131 auto tscsc_temp = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
132 auto tscs_BasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
134
135 tscsc_temp->addStrategy(tscs_BasicVS);
136 tscsc_temp->addStrategy(tscs_IC);
137 tscsc_temp->initialize();
138 TEUCHOS_TEST_FOR_EXCEPT(!tscsc_temp->isInitialized());
139
140 auto pl = tscsc_temp->getValidParameters();
141
142 TEST_COMPARE ( pl->get<std::string>("Strategy Type"), ==, "Composite");
143 TEST_COMPARE ( pl->get<std::string>("Strategy List"), ==, "Basic VS, Integral Controller");
144 TEST_COMPARE ( pl->isSublist("Basic VS") , ==, true);
145 TEST_COMPARE ( pl->isSublist("Integral Controller") , ==, true);
146
147 { // Ensure that parameters are "used", excluding sublists.
148 std::ostringstream unusedParameters;
149 pl->unused(unusedParameters);
150 TEST_COMPARE ( unusedParameters.str(), ==,
151 "WARNING: Parameter \"Basic VS\" [unused] is unused\n"
152 "WARNING: Parameter \"Integral Controller\" [unused] is unused\n");
153 }
154
155 auto BasicVS_PL = pl->sublist("Basic VS");
156 TEST_COMPARE ( BasicVS_PL.get<std::string>("Strategy Type") , ==, "Basic VS");
157 TEST_FLOATING_EQUALITY( BasicVS_PL.get<double>("Amplification Factor"), 1.75, 1.0e-14);
158 TEST_FLOATING_EQUALITY( BasicVS_PL.get<double>("Reduction Factor") , 0.5 , 1.0e-14);
159 TEST_FLOATING_EQUALITY( BasicVS_PL.get<double>("Minimum Value Monitoring Function"), 0.0 , 1.0e-14);
160 TEST_FLOATING_EQUALITY( BasicVS_PL.get<double>("Maximum Value Monitoring Function"), 1.0e+16, 1.0e-14);
161
162 { // Ensure that parameters are "used", excluding sublists.
163 std::ostringstream unusedParameters;
164 BasicVS_PL.unused(unusedParameters);
165 TEST_COMPARE ( unusedParameters.str(), ==, "");
166 }
167
168 auto IntCtrl_PL = pl->sublist("Integral Controller");
169 TEST_COMPARE ( IntCtrl_PL.get<std::string>("Strategy Type") , ==, "Integral Controller");
170 TEST_COMPARE ( IntCtrl_PL.get<std::string>("Controller Type") , ==, "PID");
171 TEST_FLOATING_EQUALITY( IntCtrl_PL.get<double>("KI"), 0.58, 1.0e-14);
172 TEST_FLOATING_EQUALITY( IntCtrl_PL.get<double>("KP"), 0.21, 1.0e-14);
173 TEST_FLOATING_EQUALITY( IntCtrl_PL.get<double>("KD"), 0.1 , 1.0e-14);
174 TEST_FLOATING_EQUALITY( IntCtrl_PL.get<double>("Safety Factor"), 0.9 , 1.0e-14);
175 TEST_FLOATING_EQUALITY( IntCtrl_PL.get<double>("Safety Factor After Step Rejection"), 0.9 , 1.0e-14);
176 TEST_FLOATING_EQUALITY( IntCtrl_PL.get<double>("Maximum Safety Factor"), 5.0 , 1.0e-14);
177 TEST_FLOATING_EQUALITY( IntCtrl_PL.get<double>("Minimum Safety Factor"), 0.5 , 1.0e-14);
178
179 { // Ensure that parameters are "used", excluding sublists.
180 std::ostringstream unusedParameters;
181 IntCtrl_PL.unused(unusedParameters);
182 TEST_COMPARE ( unusedParameters.str(), ==, "");
183 }
184}
185
186
187// ************************************************************
188// ************************************************************
189TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Setting_Strategies_PLs)
190{
191
192 { // Test with default ParameterList
193 auto pl = Tempus::getTimeStepControlStrategyCompositePL<double>();
194
195 auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
196 TEUCHOS_TEST_FOR_EXCEPT(!tscsc->isInitialized());
197
198 std::vector<Teuchos::RCP<Tempus::TimeStepControlStrategy<double>>>
199 strategies = tscsc->getStrategies();
200
201 // Default strategy is "Constant"
202 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Constant"));
203 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
204 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 1));
205 TEUCHOS_TEST_FOR_EXCEPT(!(strategies[0]->getStepType() == "Constant"));
206 TEUCHOS_TEST_FOR_EXCEPT(!(strategies[0]->getStrategyType() == "Constant"));
207 }
208
209 { // Test with empty "Strategy List"
210 auto pl = Tempus::getTimeStepControlStrategyCompositePL<double>();
211 pl->set("Strategy List", "");
212 pl->remove("Constant");
213
214 auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
215 TEUCHOS_TEST_FOR_EXCEPT(tscsc->isInitialized()); // Should NOT be initialized!
216
217 // Default strategy is "Variable"
218 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Variable"));
219 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
220 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 0));
221 }
222
223 { // Test with non-Tempus strategy
224 auto pl = Tempus::getTimeStepControlStrategyCompositePL<double>();
225 pl->remove("Constant");
226 pl->set("Strategy List", "Application Strategy");
227
228 auto nonTempusStrategyPL =
229 Teuchos::parameterList("Application Strategy");
230 nonTempusStrategyPL->set<std::string>("Strategy Type", "Application Strategy");
231 nonTempusStrategyPL->set<double>("Secret Sauce", 1.2345);
232 pl->set("Application Strategy", *nonTempusStrategyPL);
233
234 auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
235 TEUCHOS_TEST_FOR_EXCEPT(tscsc->isInitialized()); // Should NOT be initialized!
236
237 // Default strategy is "Variable"
238 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Variable"));
239 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
240 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 0));
241 }
242
243 { // Test with two Tempus strategies and a non-Tempus strategy
244
245 // Setup ParameterList for this test.
247 auto tscsBasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
248 temp->addStrategy(tscsBasicVS);
250 temp->addStrategy(tscsIntCtrl);
251 temp->initialize();
252
253 auto pl = rcp_const_cast<Teuchos::ParameterList>(temp->getValidParameters());
254 auto sList = pl->get<std::string>("Strategy List");
255 pl->set("Strategy List", sList+", Application Strategy");
256
257 auto nonTempusStrategyPL =
258 Teuchos::parameterList("Application Strategy");
259 nonTempusStrategyPL->set<std::string>("Strategy Type", "Application Strategy");
260 nonTempusStrategyPL->set<double>("Secret Sauce", 1.2345);
261 pl->set("Application Strategy", *nonTempusStrategyPL);
262
263 auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
264 TEUCHOS_TEST_FOR_EXCEPT(!tscsc->isInitialized());
265
266 // Default strategy is "Constant"
267 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Variable"));
268 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
269 TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 2));
270 }
271
272}
273
274
275} // namespace Tempus_Test
StepControlStrategy class for TimeStepControl.
TimeStepControlStrategyComposite loops over a vector of TimeStepControlStrategies.
StepControlStrategy class for TimeStepControl.
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)