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