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 
18 namespace Tempus_Unit_Test {
19 
20 using Teuchos::RCP;
21 using Teuchos::rcp;
22 using Teuchos::rcp_const_cast;
23 using Teuchos::rcp_dynamic_cast;
24 using Teuchos::ParameterList;
25 using Teuchos::sublist;
26 
27 
28 // ************************************************************
29 // ************************************************************
30 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Default_Construction_1)
31 {
32  auto tscsc = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
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 // ************************************************************
54 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Default_Construction_2)
55 {
56  auto tscsc = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
57  TEUCHOS_TEST_FOR_EXCEPT(tscsc->isInitialized()); // Should NOT be initialized.
58 
59  auto tscsBasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
60  tscsc->addStrategy(tscsBasicVS);
61  auto tscsIntCtrl = rcp(new Tempus::TimeStepControlStrategyIntegralController<double>());
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 // ************************************************************
81 TEUCHOS_UNIT_TEST(TimeStepControlStrategyComposite, Create_Construction)
82 {
83  // Construct ParmeterList for testing.
84  auto tscsc_temp = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
85  auto tscs_BasicVS =
86  rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
87  auto tscs_IC =
88  rcp(new Tempus::TimeStepControlStrategyIntegralController<double>());
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 // ************************************************************
128 TEUCHOS_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>());
133  auto tscs_IC = rcp(new Tempus::TimeStepControlStrategyIntegralController<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 // ************************************************************
189 TEUCHOS_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.
246  auto temp = rcp(new Tempus::TimeStepControlStrategyComposite<double>());
247  auto tscsBasicVS = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
248  temp->addStrategy(tscsBasicVS);
249  auto tscsIntCtrl = rcp(new Tempus::TimeStepControlStrategyIntegralController<double>());
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_Unit_Test
Teuchos::ParameterList::get
T & get(const std::string &name, T def_value)
Tempus::TimeStepControlStrategyBasicVS
StepControlStrategy class for TimeStepControl.
Definition: Tempus_TimeStepControlStrategyBasicVS.hpp:104
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:34
Tempus::TimeStepControlStrategyConstant
StepControlStrategy class for TimeStepControl.
Definition: Tempus_TimeStepControlStrategyConstant.hpp:25
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 Sep 21 2023 07:59:01 for Tempus by   doxygen 1.8.5