Tempus  Version of the Day
Time Integration
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 
9 #include "Tempus_UnitTest_Utils.hpp"
10 
11 #include "Tempus_TimeStepControl.hpp"
12 #include "Tempus_TimeStepControlStrategyBasicVS.hpp"
13 #include "Tempus_TimeStepControlStrategyConstant.hpp"
14 #include "Tempus_TimeStepControlStrategyIntegralController.hpp"
15 #include "Tempus_TimeStepControlStrategyComposite.hpp"
16 
17 namespace Tempus_Unit_Test {
18 
19 using Teuchos::ParameterList;
20 using Teuchos::RCP;
21 using Teuchos::rcp;
22 using Teuchos::rcp_const_cast;
23 using Teuchos::rcp_dynamic_cast;
24 using Teuchos::sublist;
25 
26 // ************************************************************
27 // ************************************************************
28 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Default_Construction_1)
29 {
30  auto tscsc = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
31  TEUCHOS_TEST_FOR_EXCEPT(
32  tscsc->isInitialized()); // Should NOT be initialized.
33 
34  auto tscsConstant =
35  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 =
46  rcp_dynamic_cast<Tempus::TimeStepControlStrategyConstant<double>>(
47  strategies[0]);
48 
49  TEUCHOS_TEST_FOR_EXCEPT(strategyConstant->getStepType() != "Constant");
50  TEUCHOS_TEST_FOR_EXCEPT(strategyConstant->getConstantTimeStep() != 0.0);
51 }
52 
53 // ************************************************************
54 // ************************************************************
55 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Default_Construction_2)
56 {
57  auto tscsc = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
58  TEUCHOS_TEST_FOR_EXCEPT(
59  tscsc->isInitialized()); // Should NOT be initialized.
60 
61  auto tscsBasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
62  tscsc->addStrategy(tscsBasicVS);
63  auto tscsIntCtrl =
64  rcp(new Tempus::TimeStepControlStrategyIntegralController<double>());
65  tscsc->addStrategy(tscsIntCtrl);
66  tscsc->initialize();
67  TEUCHOS_TEST_FOR_EXCEPT(!tscsc->isInitialized());
68 
69  TEST_COMPARE(tscsc->size(), ==, 2);
70 
71  std::vector<Teuchos::RCP<Tempus::TimeStepControlStrategy<double>>>
72  strategies = tscsc->getStrategies();
73 
74  auto strategyBasicVS =
75  rcp_dynamic_cast<Tempus::TimeStepControlStrategyBasicVS<double>>(
76  strategies[0]);
77  TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getStrategyType() != "Basic VS");
78 
79  auto strategyIntCtrl = rcp_dynamic_cast<
80  Tempus::TimeStepControlStrategyIntegralController<double>>(strategies[1]);
81  TEUCHOS_TEST_FOR_EXCEPT(strategyIntCtrl->getStrategyType() !=
82  "Integral Controller");
83 }
84 
85 // ************************************************************
86 // ************************************************************
87 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Create_Construction)
88 {
89  // Construct ParmeterList for testing.
90  auto tscsc_temp = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
91  auto tscs_BasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
92  auto tscs_IC =
93  rcp(new Tempus::TimeStepControlStrategyIntegralController<double>());
94 
95  tscsc_temp->addStrategy(tscs_BasicVS);
96  tscsc_temp->addStrategy(tscs_IC);
97  tscsc_temp->initialize();
98  TEUCHOS_TEST_FOR_EXCEPT(!tscsc_temp->isInitialized());
99 
100  auto pl =
101  rcp_const_cast<Teuchos::ParameterList>(tscsc_temp->getValidParameters());
102 
103  auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
104 
105  TEST_COMPARE(tscsc->size(), ==, 2);
106 
107  std::vector<Teuchos::RCP<Tempus::TimeStepControlStrategy<double>>>
108  strategies = tscsc->getStrategies();
109 
110  auto strategyBasicVS =
111  Teuchos::rcp_dynamic_cast<Tempus::TimeStepControlStrategyBasicVS<double>>(
112  strategies[0]);
113 
114  TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getStepType() != "Variable");
115  TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getAmplFactor() != 1.75);
116  TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getReductFactor() != 0.5);
117  TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getMinEta() != 0.0);
118  TEUCHOS_TEST_FOR_EXCEPT(strategyBasicVS->getMaxEta() != 1.0e+16);
119 
120  auto strategyIC = Teuchos::rcp_dynamic_cast<
121  Tempus::TimeStepControlStrategyIntegralController<double>>(strategies[1]);
122 
123  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getStepType() != "Variable");
124  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getController() != "PID");
125  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getKI() != 0.58);
126  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getKP() != 0.21);
127  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getKD() != 0.10);
128  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getSafetyFactor() != 0.90);
129  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getSafetyFactorAfterReject() != 0.90);
130  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getFacMax() != 5.0);
131  TEUCHOS_TEST_FOR_EXCEPT(strategyIC->getFacMin() != 0.5);
132 }
133 
134 // ************************************************************
135 // ************************************************************
136 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, getValidParameters)
137 {
138  // Construct ParmeterList for testing.
139  auto tscsc_temp = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
140  auto tscs_BasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
141  auto tscs_IC =
142  rcp(new Tempus::TimeStepControlStrategyIntegralController<double>());
143 
144  tscsc_temp->addStrategy(tscs_BasicVS);
145  tscsc_temp->addStrategy(tscs_IC);
146  tscsc_temp->initialize();
147  TEUCHOS_TEST_FOR_EXCEPT(!tscsc_temp->isInitialized());
148 
149  auto pl = tscsc_temp->getValidParameters();
150 
151  TEST_COMPARE(pl->get<std::string>("Strategy Type"), ==, "Composite");
152  TEST_COMPARE(pl->get<std::string>("Strategy List"), ==,
153  "Basic VS, Integral Controller");
154  TEST_COMPARE(pl->isSublist("Basic VS"), ==, true);
155  TEST_COMPARE(pl->isSublist("Integral Controller"), ==, true);
156 
157  { // Ensure that parameters are "used", excluding sublists.
158  std::ostringstream unusedParameters;
159  pl->unused(unusedParameters);
160  TEST_COMPARE(
161  unusedParameters.str(), ==,
162  "WARNING: Parameter \"Basic VS\" [unused] is unused\n"
163  "WARNING: Parameter \"Integral Controller\" [unused] is unused\n");
164  }
165 
166  auto BasicVS_PL = pl->sublist("Basic VS");
167  TEST_COMPARE(BasicVS_PL.get<std::string>("Strategy Type"), ==, "Basic VS");
168  TEST_FLOATING_EQUALITY(BasicVS_PL.get<double>("Amplification Factor"), 1.75,
169  1.0e-14);
170  TEST_FLOATING_EQUALITY(BasicVS_PL.get<double>("Reduction Factor"), 0.5,
171  1.0e-14);
172  TEST_FLOATING_EQUALITY(
173  BasicVS_PL.get<double>("Minimum Value Monitoring Function"), 0.0,
174  1.0e-14);
175  TEST_FLOATING_EQUALITY(
176  BasicVS_PL.get<double>("Maximum Value Monitoring Function"), 1.0e+16,
177  1.0e-14);
178 
179  { // Ensure that parameters are "used", excluding sublists.
180  std::ostringstream unusedParameters;
181  BasicVS_PL.unused(unusedParameters);
182  TEST_COMPARE(unusedParameters.str(), ==, "");
183  }
184 
185  auto IntCtrl_PL = pl->sublist("Integral Controller");
186  TEST_COMPARE(IntCtrl_PL.get<std::string>("Strategy Type"), ==,
187  "Integral Controller");
188  TEST_COMPARE(IntCtrl_PL.get<std::string>("Controller Type"), ==, "PID");
189  TEST_FLOATING_EQUALITY(IntCtrl_PL.get<double>("KI"), 0.58, 1.0e-14);
190  TEST_FLOATING_EQUALITY(IntCtrl_PL.get<double>("KP"), 0.21, 1.0e-14);
191  TEST_FLOATING_EQUALITY(IntCtrl_PL.get<double>("KD"), 0.1, 1.0e-14);
192  TEST_FLOATING_EQUALITY(IntCtrl_PL.get<double>("Safety Factor"), 0.9, 1.0e-14);
193  TEST_FLOATING_EQUALITY(
194  IntCtrl_PL.get<double>("Safety Factor After Step Rejection"), 0.9,
195  1.0e-14);
196  TEST_FLOATING_EQUALITY(IntCtrl_PL.get<double>("Maximum Safety Factor"), 5.0,
197  1.0e-14);
198  TEST_FLOATING_EQUALITY(IntCtrl_PL.get<double>("Minimum Safety Factor"), 0.5,
199  1.0e-14);
200 
201  { // Ensure that parameters are "used", excluding sublists.
202  std::ostringstream unusedParameters;
203  IntCtrl_PL.unused(unusedParameters);
204  TEST_COMPARE(unusedParameters.str(), ==, "");
205  }
206 }
207 
208 // ************************************************************
209 // ************************************************************
210 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Setting_Strategies_PLs)
211 {
212  { // Test with default ParameterList
213  auto pl = Tempus::getTimeStepControlStrategyCompositePL<double>();
214 
215  auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
216  TEUCHOS_TEST_FOR_EXCEPT(!tscsc->isInitialized());
217 
218  std::vector<Teuchos::RCP<Tempus::TimeStepControlStrategy<double>>>
219  strategies = tscsc->getStrategies();
220 
221  // Default strategy is "Constant"
222  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Constant"));
223  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
224  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 1));
225  TEUCHOS_TEST_FOR_EXCEPT(!(strategies[0]->getStepType() == "Constant"));
226  TEUCHOS_TEST_FOR_EXCEPT(!(strategies[0]->getStrategyType() == "Constant"));
227  }
228 
229  { // Test with empty "Strategy List"
230  auto pl = Tempus::getTimeStepControlStrategyCompositePL<double>();
231  pl->set("Strategy List", "");
232  pl->remove("Constant");
233 
234  auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
235  TEUCHOS_TEST_FOR_EXCEPT(
236  tscsc->isInitialized()); // Should NOT be initialized!
237 
238  // Default strategy is "Variable"
239  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Variable"));
240  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
241  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 0));
242  }
243 
244  { // Test with non-Tempus strategy
245  auto pl = Tempus::getTimeStepControlStrategyCompositePL<double>();
246  pl->remove("Constant");
247  pl->set("Strategy List", "Application Strategy");
248 
249  auto nonTempusStrategyPL = Teuchos::parameterList("Application Strategy");
250  nonTempusStrategyPL->set<std::string>("Strategy Type",
251  "Application Strategy");
252  nonTempusStrategyPL->set<double>("Secret Sauce", 1.2345);
253  pl->set("Application Strategy", *nonTempusStrategyPL);
254 
255  auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
256  TEUCHOS_TEST_FOR_EXCEPT(
257  tscsc->isInitialized()); // Should NOT be initialized!
258 
259  // Default strategy is "Variable"
260  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Variable"));
261  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
262  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 0));
263  }
264 
265  { // Test with two Tempus strategies and a non-Tempus strategy
266 
267  // Setup ParameterList for this test.
268  auto temp = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
269  auto tscsBasicVS =
270  rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
271  temp->addStrategy(tscsBasicVS);
272  auto tscsIntCtrl =
273  rcp(new Tempus::TimeStepControlStrategyIntegralController<double>());
274  temp->addStrategy(tscsIntCtrl);
275  temp->initialize();
276 
277  auto pl =
278  rcp_const_cast<Teuchos::ParameterList>(temp->getValidParameters());
279  auto sList = pl->get<std::string>("Strategy List");
280  pl->set("Strategy List", sList + ", Application Strategy");
281 
282  auto nonTempusStrategyPL = Teuchos::parameterList("Application Strategy");
283  nonTempusStrategyPL->set<std::string>("Strategy Type",
284  "Application Strategy");
285  nonTempusStrategyPL->set<double>("Secret Sauce", 1.2345);
286  pl->set("Application Strategy", *nonTempusStrategyPL);
287 
288  auto tscsc = Tempus::createTimeStepControlStrategyComposite<double>(pl);
289  TEUCHOS_TEST_FOR_EXCEPT(!tscsc->isInitialized());
290 
291  // Default strategy is "Constant"
292  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStepType() == "Variable"));
293  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategyType() == "Composite"));
294  TEUCHOS_TEST_FOR_EXCEPT(!(tscsc->getStrategies().size() == 2));
295  }
296 }
297 
298 } // namespace Tempus_Unit_Test
Teuchos::ParameterList::get
T & get(const std::string &name, T def_value)
Tempus::TimeStepControlStrategyBasicVS
StepControlStrategy class for TimeStepControl.
Definition: Tempus_TimeStepControlStrategyBasicVS.hpp:103
TEST_COMPARE
#define TEST_COMPARE(v1, comp, v2)
TEST_FLOATING_EQUALITY
#define TEST_FLOATING_EQUALITY(v1, v2, tol)
Tempus_TimeStepControlStrategyComposite.hpp
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Tempus_UnitTest_Utils.hpp
Tempus_Unit_Test::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
Definition: Tempus_UnitTest_BackwardEuler.cpp:32
Tempus::TimeStepControlStrategyConstant
StepControlStrategy class for TimeStepControl.
Definition: Tempus_TimeStepControlStrategyConstant.hpp:24
Tempus_TimeStepControlStrategyConstant.hpp
Tempus_TimeStepControlStrategyBasicVS.hpp
Tempus::TimeStepControlStrategyComposite
TimeStepControlStrategyComposite loops over a vector of TimeStepControlStrategies.
Definition: Tempus_TimeStepControlStrategyComposite.hpp:42
Tempus_TimeStepControlStrategyIntegralController.hpp
TEUCHOS_TEST_FOR_EXCEPT
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)
Generated on Thu Apr 25 2024 09:24:37 for Tempus by   doxygen 1.8.5