Tempus  Version of the Day
Time Integration
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Tempus_UnitTest_TimeEventListIndex.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_TimeEventListIndex.hpp"
12 
13 
14 namespace Tempus_Unit_Test {
15 
16 using Teuchos::RCP;
17 using Teuchos::rcp;
18 using Teuchos::rcp_const_cast;
19 using Teuchos::rcp_dynamic_cast;
20 
21 
22 // ************************************************************
23 // ************************************************************
24 TEUCHOS_UNIT_TEST(TimeEventListIndex, Default_Construction)
25 {
26  auto te = rcp(new Tempus::TimeEventListIndex<double>());
27 
28  TEST_COMPARE(te->getName(), ==, "TimeEventListIndex");
29 
30  TEST_COMPARE(te->getIndexList().size(), ==, 0);
31 
32  TEST_COMPARE(te->isIndex(-1), ==, false);
33  TEST_COMPARE(te->isIndex( 0), ==, false);
34  TEST_COMPARE(te->isIndex( 1), ==, false);
35 
36  TEST_COMPARE(te->indexToNextEvent(0), ==, te->getDefaultIndex());
37  TEST_COMPARE(te->indexOfNextEvent(0), ==, te->getDefaultIndex());
38  TEST_COMPARE(te->eventInRangeIndex(2, -1), ==, false);
39 
40  // Check base class defaults (functions not implemented in TimeEventListIndex).
41  TEST_COMPARE(te->isTime(1.0), ==, false);
42  TEST_COMPARE(te->timeToNextEvent(1.0), ==, te->getDefaultTime());
43  TEST_COMPARE(te->timeOfNextEvent(1.0), ==, te->getDefaultTime());
44  TEST_COMPARE(te->eventInRange(1.0, 4.0), ==, false);
45 }
46 
47 
48 // ************************************************************
49 // ************************************************************
50 TEUCHOS_UNIT_TEST(TimeEventListIndex, Construction)
51 {
52  std::vector<int> testVector;
53  testVector.push_back(-2);
54  testVector.push_back( 0);
55  testVector.push_back( 7);
56  testVector.push_back( 3);
57  testVector.push_back(-5);
58 
59  auto te = rcp(new Tempus::TimeEventListIndex<double>(
60  testVector, "TestName"));
61 
62  TEST_COMPARE(te->getName(), ==, "TestName");
63 
64  auto testList = te->getIndexList();
65  TEST_COMPARE(testList.size(), ==, 5);
66  TEST_COMPARE(testList[0], ==, -5);
67  TEST_COMPARE(testList[1], ==, -2);
68  TEST_COMPARE(testList[2], ==, 0);
69  TEST_COMPARE(testList[3], ==, 3);
70  TEST_COMPARE(testList[4], ==, 7);
71 
72  // Test adding a duplicate event index.
73  te->addIndex(3);
74  TEST_COMPARE(te->getIndexList().size(), ==, 5);
75  te->addIndex(1);
76  TEST_COMPARE(te->getIndexList().size(), ==, 6);
77 }
78 
79 
80 // ************************************************************
81 // ************************************************************
82 TEUCHOS_UNIT_TEST(TimeEventListIndex, isIndex)
83 {
84  auto te = rcp(new Tempus::TimeEventListIndex<double>());
85 
86  te->setName("TestName");
87  TEST_COMPARE(te->getName(), ==, "TestName");
88 
89  // Test isIndex with one element.
90  te->addIndex(-5);
91  TEST_COMPARE(te->isIndex(-6), ==, false);
92  TEST_COMPARE(te->isIndex(-5), ==, true );
93  TEST_COMPARE(te->isIndex(-4), ==, false);
94 
95  // Test isIndex with two elements.
96  te->addIndex(1);
97  TEST_COMPARE(te->isIndex(0), ==, false);
98  TEST_COMPARE(te->isIndex(1), ==, true );
99  TEST_COMPARE(te->isIndex(2), ==, false);
100 
101  // Test addIndex.
102  te->addIndex(-2);
103  te->addIndex( 4);
104  te->addIndex(-9);
105  auto testList = te->getIndexList();
106  TEST_COMPARE(testList.size(), ==, 5);
107  TEST_COMPARE(testList[0], ==, -9);
108  TEST_COMPARE(testList[1], ==, -5);
109  TEST_COMPARE(testList[2], ==, -2);
110  TEST_COMPARE(testList[3], ==, 1);
111  TEST_COMPARE(testList[4], ==, 4);
112 }
113 
114 
115 // ************************************************************
116 // ************************************************************
117 TEUCHOS_UNIT_TEST(TimeEventListIndex, indexToNextEvent)
118 {
119  std::vector<int> testListIndex;
120  testListIndex.push_back(-5);
121  testListIndex.push_back( 1);
122  testListIndex.push_back(-2);
123  testListIndex.push_back( 4);
124  testListIndex.push_back(-9);
125 
126  auto te = rcp(new Tempus::TimeEventListIndex<double>(
127  testListIndex, "teListIndex"));
128 
129  // Test indexToNextEvent.
130  // Around first event.
131  TEST_COMPARE(te->indexToNextEvent(-12), ==, 3);
132  TEST_COMPARE(te->indexToNextEvent( -9), ==, 4);
133  TEST_COMPARE(te->indexToNextEvent( -8), ==, 3);
134 
135  // Around mid event.
136  TEST_COMPARE(te->indexToNextEvent(-4), ==, 2);
137  TEST_COMPARE(te->indexToNextEvent(-2), ==, 3);
138  TEST_COMPARE(te->indexToNextEvent( 0), ==, 1);
139 
140  // Around last event.
141  TEST_COMPARE(te->indexToNextEvent(2), ==, 2);
142  TEST_COMPARE(te->indexToNextEvent(4), ==, te->getDefaultIndex()-4);
143  TEST_COMPARE(te->indexToNextEvent(9), ==, te->getDefaultIndex()-9);
144 }
145 
146 
147 // ************************************************************
148 // ************************************************************
149 TEUCHOS_UNIT_TEST(TimeEventListIndex, indexOfNextEvent)
150 {
151  std::vector<int> testListIndex;
152  testListIndex.push_back(-5);
153  testListIndex.push_back( 1);
154  testListIndex.push_back(-2);
155  testListIndex.push_back( 4);
156  testListIndex.push_back(-9);
157 
158  auto te = rcp(new Tempus::TimeEventListIndex<double>(
159  testListIndex, "teListIndex"));
160 
161  // Test indexOfNextEvent.
162  // Around first event.
163  TEST_COMPARE(te->indexOfNextEvent(-12), ==, -9);
164  TEST_COMPARE(te->indexOfNextEvent( -9), ==, -5);
165  TEST_COMPARE(te->indexOfNextEvent( -8), ==, -5);
166 
167  // Around mid event.
168  TEST_COMPARE(te->indexOfNextEvent(-4), ==, -2);
169  TEST_COMPARE(te->indexOfNextEvent(-2), ==, 1);
170  TEST_COMPARE(te->indexOfNextEvent( 0), ==, 1);
171 
172  // Around last event.
173  TEST_COMPARE(te->indexOfNextEvent(2), ==, 4);
174  TEST_COMPARE(te->indexOfNextEvent(4), ==, te->getDefaultIndex());
175  TEST_COMPARE(te->indexOfNextEvent(9), ==, te->getDefaultIndex());
176 }
177 
178 
179 // ************************************************************
180 // ************************************************************
181 TEUCHOS_UNIT_TEST(TimeEventListIndex, eventInRangeIndex)
182 {
183  std::vector<int> testListIndex;
184  testListIndex.push_back(-5);
185  testListIndex.push_back( 1);
186  testListIndex.push_back(-2);
187  testListIndex.push_back( 4);
188  testListIndex.push_back(-9);
189 
190  auto te = rcp(new Tempus::TimeEventListIndex<double>(
191  testListIndex, "teListIndex"));
192 
193  // Test eventInRangeIndex.
194  // Right end.
195  TEST_COMPARE(te->eventInRangeIndex(-12.0, -10), ==, false); // Around first event.
196  TEST_COMPARE(te->eventInRangeIndex(-12.0, -9), ==, true );
197  TEST_COMPARE(te->eventInRangeIndex(-12.0, -8), ==, true );
198 
199  TEST_COMPARE(te->eventInRangeIndex(-4, -3), ==, false); // Around mid event.
200  TEST_COMPARE(te->eventInRangeIndex(-4, -2), ==, true );
201  TEST_COMPARE(te->eventInRangeIndex(-4, -1), ==, true );
202 
203  TEST_COMPARE(te->eventInRangeIndex(3, 3), ==, false); // Around last event.
204  TEST_COMPARE(te->eventInRangeIndex(3, 4), ==, true );
205  TEST_COMPARE(te->eventInRangeIndex(3, 6), ==, true );
206 
207  // Left end.
208  TEST_COMPARE(te->eventInRangeIndex(-12, -7), ==, true ); // Around first event.
209  TEST_COMPARE(te->eventInRangeIndex( -9, -7), ==, false);
210  TEST_COMPARE(te->eventInRangeIndex( -8, -7), ==, false);
211 
212  TEST_COMPARE(te->eventInRangeIndex(-3, 0), ==, true ); // Around mid event.
213  TEST_COMPARE(te->eventInRangeIndex(-2, 0), ==, false);
214  TEST_COMPARE(te->eventInRangeIndex(-1, 0), ==, false);
215 
216  TEST_COMPARE(te->eventInRangeIndex(3, 8), ==, true ); // Around last event.
217  TEST_COMPARE(te->eventInRangeIndex(4, 8), ==, false);
218  TEST_COMPARE(te->eventInRangeIndex(5, 8), ==, false);
219 }
220 
221 
222 
223 
224 // ************************************************************
225 // ************************************************************
226 TEUCHOS_UNIT_TEST(TimeEventListIndex, getValidParameters)
227 {
228  auto teli = rcp(new Tempus::TimeEventListIndex<double>());
229 
230  auto pl = teli->getValidParameters();
231 
232  TEST_COMPARE( pl->get<std::string>("Type"), ==, "List Index");
233  TEST_COMPARE( pl->get<std::string>("Name"), ==, "TimeEventListIndex");
234  TEST_COMPARE( pl->get<std::string>("Index List"), ==, "");
235 
236  { // Ensure that parameters are "used", excluding sublists.
237  std::ostringstream unusedParameters;
238  pl->unused(unusedParameters);
239  TEST_COMPARE ( unusedParameters.str(), ==, "");
240  }
241 }
242 
243 
244 // ************************************************************
245 // ************************************************************
246 TEUCHOS_UNIT_TEST(TimeEventListIndex, createTimeEventListIndex)
247 {
248  // Construct parameterList similar to getValidParameters().
249  Teuchos::RCP<Teuchos::ParameterList> pl =
250  Teuchos::parameterList("Time Event List Index");
251 
252  pl->set("Name", "Unit Test Time Event List Index");
253  pl->set("Type", "List Index");
254 
255  std::vector<int> indices;
256  indices.push_back(-99);
257  indices.push_back( 13);
258  indices.push_back( 97);
259  indices.push_back(101);
260  std::ostringstream list;
261  for(std::size_t i = 0; i < indices.size()-1; ++i) list << indices[i] << ", ";
262  list << indices[indices.size()-1];
263  pl->set<std::string>("Index List", list.str());
264 
265  // Construct TimeEventListIndex from ParameterList.
266  auto teli = Tempus::createTimeEventListIndex<double>(pl);
267 
268  teli->describe(out, Teuchos::VERB_EXTREME);
269 
270  TEST_COMPARE( teli->getName() , ==, "Unit Test Time Event List Index");
271  TEST_COMPARE( teli->getType() , ==, "List Index");
272  auto teList = teli->getIndexList();
273  TEST_COMPARE( teList[0] , ==, -99);
274  TEST_COMPARE( teList[1] , ==, 13);
275  TEST_COMPARE( teList[2] , ==, 97);
276  TEST_COMPARE( teList[3] , ==, 101);
277 }
278 
279 
280 } // namespace Tempus_Unit_Test
Teuchos::ParameterList::set
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
Tempus::TimeEventListIndex
TimeEventListIndex specifies a list of index events.
Definition: Tempus_TimeEventListIndex_decl.hpp:29
TEST_COMPARE
#define TEST_COMPARE(v1, comp, v2)
Teuchos::VERB_EXTREME
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::createTimeEventListIndex
Teuchos::RCP< TimeEventListIndex< Scalar > > createTimeEventListIndex(Teuchos::RCP< Teuchos::ParameterList > pList)
Nonmember Constructor via ParameterList.
Definition: Tempus_TimeEventListIndex_impl.hpp:179
Generated on Tue Sep 26 2023 07:58:58 for Tempus by   doxygen 1.8.5