Tempus Version of the Day
Time Integration
Loading...
Searching...
No Matches
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
14namespace Tempus_Unit_Test {
15
16using Teuchos::RCP;
17using Teuchos::rcp;
18using Teuchos::rcp_const_cast;
19using Teuchos::rcp_dynamic_cast;
20
21
22// ************************************************************
23// ************************************************************
24TEUCHOS_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// ************************************************************
50TEUCHOS_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// ************************************************************
82TEUCHOS_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// ************************************************************
117TEUCHOS_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// ************************************************************
149TEUCHOS_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// ************************************************************
181TEUCHOS_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// ************************************************************
226TEUCHOS_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// ************************************************************
246TEUCHOS_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_Test
TimeEventListIndex specifies a list of index events.
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)