1 /*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkCPExodusIIResultsArrayTemplate.txx
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14 =========================================================================*/
15
16 #include "vtkCPExodusIIResultsArrayTemplate.h"
17
18 #include "vtkIdList.h"
19 #include "vtkObjectFactory.h"
20 #include "vtkVariant.h"
21 #include "vtkVariantCast.h"
22
23 //------------------------------------------------------------------------------
24 // Can't use vtkStandardNewMacro on a templated class.
25 template <class Scalar>
New()26 vtkCPExodusIIResultsArrayTemplate<Scalar>* vtkCPExodusIIResultsArrayTemplate<Scalar>::New()
27 {
28 VTK_STANDARD_NEW_BODY(vtkCPExodusIIResultsArrayTemplate<Scalar>);
29 }
30
31 //------------------------------------------------------------------------------
32 template <class Scalar>
PrintSelf(ostream & os,vtkIndent indent)33 void vtkCPExodusIIResultsArrayTemplate<Scalar>::PrintSelf(ostream& os, vtkIndent indent)
34 {
35 this->vtkCPExodusIIResultsArrayTemplate<Scalar>::Superclass::PrintSelf(os, indent);
36
37 os << indent << "Number of arrays: " << this->Arrays.size() << "\n";
38 vtkIndent deeper = indent.GetNextIndent();
39 for (size_t i = 0; i < this->Arrays.size(); ++i)
40 {
41 os << deeper << "Array " << i << ": " << this->Arrays.at(i) << "\n";
42 }
43
44 os << indent << "TempDoubleArray: " << this->TempDoubleArray << "\n";
45 os << indent << "Save: " << this->Save << "\n";
46 }
47
48 //------------------------------------------------------------------------------
49 template <class Scalar>
SetExodusScalarArrays(std::vector<Scalar * > arrays,vtkIdType numTuples)50 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetExodusScalarArrays(
51 std::vector<Scalar*> arrays, vtkIdType numTuples)
52 {
53 this->Initialize();
54 this->NumberOfComponents = static_cast<int>(arrays.size());
55 this->Arrays = arrays;
56 this->Size = this->NumberOfComponents * numTuples;
57 this->MaxId = this->Size - 1;
58 this->TempDoubleArray = new double[this->NumberOfComponents];
59 this->Modified();
60 }
61
62 //------------------------------------------------------------------------------
63 template <class Scalar>
SetExodusScalarArrays(std::vector<Scalar * > arrays,vtkIdType numTuples,bool save)64 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetExodusScalarArrays(
65 std::vector<Scalar*> arrays, vtkIdType numTuples, bool save)
66 {
67 this->SetExodusScalarArrays(arrays, numTuples);
68 this->Save = save;
69 }
70
71 //------------------------------------------------------------------------------
72 template <class Scalar>
Initialize()73 void vtkCPExodusIIResultsArrayTemplate<Scalar>::Initialize()
74 {
75 if (!this->Save)
76 {
77 for (size_t i = 0; i < this->Arrays.size(); ++i)
78 {
79 delete this->Arrays[i];
80 }
81 }
82 this->Arrays.clear();
83 this->Arrays.push_back(nullptr);
84
85 delete[] this->TempDoubleArray;
86 this->TempDoubleArray = nullptr;
87
88 this->MaxId = -1;
89 this->Size = 0;
90 this->NumberOfComponents = 1;
91 // the default is to have this class delete the arrays when done with them.
92 this->Save = false;
93 }
94
95 //------------------------------------------------------------------------------
96 template <class Scalar>
GetTuples(vtkIdList * ptIds,vtkAbstractArray * output)97 void vtkCPExodusIIResultsArrayTemplate<Scalar>::GetTuples(
98 vtkIdList* ptIds, vtkAbstractArray* output)
99 {
100 vtkDataArray* da = vtkDataArray::FastDownCast(output);
101 if (!da)
102 {
103 vtkWarningMacro(<< "Input is not a vtkDataArray");
104 return;
105 }
106
107 if (da->GetNumberOfComponents() != this->GetNumberOfComponents())
108 {
109 vtkWarningMacro(<< "Incorrect number of components in input array.");
110 return;
111 }
112
113 const vtkIdType numPoints = ptIds->GetNumberOfIds();
114 for (vtkIdType i = 0; i < numPoints; ++i)
115 {
116 da->SetTuple(i, this->GetTuple(ptIds->GetId(i)));
117 }
118 }
119
120 //------------------------------------------------------------------------------
121 template <class Scalar>
GetTuples(vtkIdType p1,vtkIdType p2,vtkAbstractArray * output)122 void vtkCPExodusIIResultsArrayTemplate<Scalar>::GetTuples(
123 vtkIdType p1, vtkIdType p2, vtkAbstractArray* output)
124 {
125 vtkDataArray* da = vtkDataArray::FastDownCast(output);
126 if (!da)
127 {
128 vtkErrorMacro(<< "Input is not a vtkDataArray");
129 return;
130 }
131
132 if (da->GetNumberOfComponents() != this->GetNumberOfComponents())
133 {
134 vtkErrorMacro(<< "Incorrect number of components in input array.");
135 return;
136 }
137
138 for (vtkIdType daTupleId = 0; p1 <= p2; ++p1)
139 {
140 da->SetTuple(daTupleId++, this->GetTuple(p1));
141 }
142 }
143
144 //------------------------------------------------------------------------------
145 template <class Scalar>
Squeeze()146 void vtkCPExodusIIResultsArrayTemplate<Scalar>::Squeeze()
147 {
148 // noop
149 }
150
151 //------------------------------------------------------------------------------
152 template <class Scalar>
NewIterator()153 vtkArrayIterator* vtkCPExodusIIResultsArrayTemplate<Scalar>::NewIterator()
154 {
155 vtkErrorMacro(<< "Not implemented.");
156 return nullptr;
157 }
158
159 //------------------------------------------------------------------------------
160 template <class Scalar>
LookupValue(vtkVariant value)161 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::LookupValue(vtkVariant value)
162 {
163 bool valid = true;
164 Scalar val = vtkVariantCast<Scalar>(value, &valid);
165 if (valid)
166 {
167 return this->Lookup(val, 0);
168 }
169 return -1;
170 }
171
172 //------------------------------------------------------------------------------
173 template <class Scalar>
LookupValue(vtkVariant value,vtkIdList * ids)174 void vtkCPExodusIIResultsArrayTemplate<Scalar>::LookupValue(vtkVariant value, vtkIdList* ids)
175 {
176 bool valid = true;
177 Scalar val = vtkVariantCast<Scalar>(value, &valid);
178 ids->Reset();
179 if (valid)
180 {
181 vtkIdType index = 0;
182 while ((index = this->Lookup(val, index)) >= 0)
183 {
184 ids->InsertNextId(index);
185 ++index;
186 }
187 }
188 }
189
190 //------------------------------------------------------------------------------
191 template <class Scalar>
GetVariantValue(vtkIdType idx)192 vtkVariant vtkCPExodusIIResultsArrayTemplate<Scalar>::GetVariantValue(vtkIdType idx)
193 {
194 return vtkVariant(this->GetValueReference(idx));
195 }
196
197 //------------------------------------------------------------------------------
198 template <class Scalar>
ClearLookup()199 void vtkCPExodusIIResultsArrayTemplate<Scalar>::ClearLookup()
200 {
201 // no-op, no fast lookup implemented.
202 }
203
204 //------------------------------------------------------------------------------
205 template <class Scalar>
GetTuple(vtkIdType i)206 double* vtkCPExodusIIResultsArrayTemplate<Scalar>::GetTuple(vtkIdType i)
207 {
208 this->GetTuple(i, this->TempDoubleArray);
209 return this->TempDoubleArray;
210 }
211
212 //------------------------------------------------------------------------------
213 template <class Scalar>
GetTuple(vtkIdType i,double * tuple)214 void vtkCPExodusIIResultsArrayTemplate<Scalar>::GetTuple(vtkIdType i, double* tuple)
215 {
216 for (size_t comp = 0; comp < this->Arrays.size(); ++comp)
217 {
218 tuple[comp] = static_cast<double>(this->Arrays[comp][i]);
219 }
220 }
221
222 //------------------------------------------------------------------------------
223 template <class Scalar>
LookupTypedValue(Scalar value)224 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::LookupTypedValue(Scalar value)
225 {
226 return this->Lookup(value, 0);
227 }
228
229 //------------------------------------------------------------------------------
230 template <class Scalar>
LookupTypedValue(Scalar value,vtkIdList * ids)231 void vtkCPExodusIIResultsArrayTemplate<Scalar>::LookupTypedValue(Scalar value, vtkIdList* ids)
232 {
233 ids->Reset();
234 vtkIdType index = 0;
235 while ((index = this->Lookup(value, index)) >= 0)
236 {
237 ids->InsertNextId(index);
238 ++index;
239 }
240 }
241
242 //------------------------------------------------------------------------------
243 template <class Scalar>
244 typename vtkCPExodusIIResultsArrayTemplate<Scalar>::ValueType
GetValue(vtkIdType idx) const245 vtkCPExodusIIResultsArrayTemplate<Scalar>::GetValue(vtkIdType idx) const
246 {
247 return const_cast<vtkCPExodusIIResultsArrayTemplate<Scalar>*>(this)->GetValueReference(idx);
248 }
249
250 //------------------------------------------------------------------------------
251 template <class Scalar>
252 typename vtkCPExodusIIResultsArrayTemplate<Scalar>::ValueType&
GetValueReference(vtkIdType idx)253 vtkCPExodusIIResultsArrayTemplate<Scalar>::GetValueReference(vtkIdType idx)
254 {
255 const vtkIdType tuple = idx / this->NumberOfComponents;
256 const vtkIdType comp = idx % this->NumberOfComponents;
257 return this->Arrays[comp][tuple];
258 }
259
260 //------------------------------------------------------------------------------
261 template <class Scalar>
GetTypedTuple(vtkIdType tupleId,Scalar * tuple) const262 void vtkCPExodusIIResultsArrayTemplate<Scalar>::GetTypedTuple(
263 vtkIdType tupleId, Scalar* tuple) const
264 {
265 for (size_t comp = 0; comp < this->Arrays.size(); ++comp)
266 {
267 tuple[comp] = this->Arrays[comp][tupleId];
268 }
269 }
270
271 //------------------------------------------------------------------------------
272 template <class Scalar>
Allocate(vtkIdType,vtkIdType)273 vtkTypeBool vtkCPExodusIIResultsArrayTemplate<Scalar>::Allocate(vtkIdType, vtkIdType)
274 {
275 vtkErrorMacro("Read only container.");
276 return 0;
277 }
278
279 //------------------------------------------------------------------------------
280 template <class Scalar>
Resize(vtkIdType)281 vtkTypeBool vtkCPExodusIIResultsArrayTemplate<Scalar>::Resize(vtkIdType)
282 {
283 vtkErrorMacro("Read only container.");
284 return 0;
285 }
286
287 //------------------------------------------------------------------------------
288 template <class Scalar>
SetNumberOfTuples(vtkIdType)289 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetNumberOfTuples(vtkIdType)
290 {
291 vtkErrorMacro("Read only container.");
292 return;
293 }
294
295 //------------------------------------------------------------------------------
296 template <class Scalar>
SetTuple(vtkIdType,vtkIdType,vtkAbstractArray *)297 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetTuple(vtkIdType, vtkIdType, vtkAbstractArray*)
298 {
299 vtkErrorMacro("Read only container.");
300 return;
301 }
302
303 //------------------------------------------------------------------------------
304 template <class Scalar>
SetTuple(vtkIdType,const float *)305 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetTuple(vtkIdType, const float*)
306 {
307 vtkErrorMacro("Read only container.");
308 return;
309 }
310
311 //------------------------------------------------------------------------------
312 template <class Scalar>
SetTuple(vtkIdType,const double *)313 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetTuple(vtkIdType, const double*)
314 {
315 vtkErrorMacro("Read only container.");
316 return;
317 }
318
319 //------------------------------------------------------------------------------
320 template <class Scalar>
InsertTuple(vtkIdType,vtkIdType,vtkAbstractArray *)321 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertTuple(vtkIdType, vtkIdType, vtkAbstractArray*)
322 {
323 vtkErrorMacro("Read only container.");
324 return;
325 }
326
327 //------------------------------------------------------------------------------
328 template <class Scalar>
InsertTuple(vtkIdType,const float *)329 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertTuple(vtkIdType, const float*)
330 {
331 vtkErrorMacro("Read only container.");
332 return;
333 }
334
335 //------------------------------------------------------------------------------
336 template <class Scalar>
InsertTuple(vtkIdType,const double *)337 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertTuple(vtkIdType, const double*)
338 {
339 vtkErrorMacro("Read only container.");
340 return;
341 }
342
343 //------------------------------------------------------------------------------
344 template <class Scalar>
InsertTuples(vtkIdList *,vtkIdList *,vtkAbstractArray *)345 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertTuples(
346 vtkIdList*, vtkIdList*, vtkAbstractArray*)
347 {
348 vtkErrorMacro("Read only container.");
349 return;
350 }
351
352 //------------------------------------------------------------------------------
353 template <class Scalar>
InsertTuples(vtkIdType,vtkIdType,vtkIdType,vtkAbstractArray *)354 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertTuples(
355 vtkIdType, vtkIdType, vtkIdType, vtkAbstractArray*)
356 {
357 vtkErrorMacro("Read only container.");
358 return;
359 }
360
361 //------------------------------------------------------------------------------
362 template <class Scalar>
InsertNextTuple(vtkIdType,vtkAbstractArray *)363 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertNextTuple(vtkIdType, vtkAbstractArray*)
364 {
365 vtkErrorMacro("Read only container.");
366 return -1;
367 }
368
369 //------------------------------------------------------------------------------
370 template <class Scalar>
InsertNextTuple(const float *)371 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertNextTuple(const float*)
372 {
373
374 vtkErrorMacro("Read only container.");
375 return -1;
376 }
377
378 //------------------------------------------------------------------------------
379 template <class Scalar>
InsertNextTuple(const double *)380 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertNextTuple(const double*)
381 {
382 vtkErrorMacro("Read only container.");
383 return -1;
384 }
385
386 //------------------------------------------------------------------------------
387 template <class Scalar>
DeepCopy(vtkAbstractArray *)388 void vtkCPExodusIIResultsArrayTemplate<Scalar>::DeepCopy(vtkAbstractArray*)
389 {
390 vtkErrorMacro("Read only container.");
391 return;
392 }
393
394 //------------------------------------------------------------------------------
395 template <class Scalar>
DeepCopy(vtkDataArray *)396 void vtkCPExodusIIResultsArrayTemplate<Scalar>::DeepCopy(vtkDataArray*)
397 {
398 vtkErrorMacro("Read only container.");
399 return;
400 }
401
402 //------------------------------------------------------------------------------
403 template <class Scalar>
InterpolateTuple(vtkIdType,vtkIdList *,vtkAbstractArray *,double *)404 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InterpolateTuple(
405 vtkIdType, vtkIdList*, vtkAbstractArray*, double*)
406 {
407 vtkErrorMacro("Read only container.");
408 return;
409 }
410
411 //------------------------------------------------------------------------------
412 template <class Scalar>
InterpolateTuple(vtkIdType,vtkIdType,vtkAbstractArray *,vtkIdType,vtkAbstractArray *,double)413 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InterpolateTuple(
414 vtkIdType, vtkIdType, vtkAbstractArray*, vtkIdType, vtkAbstractArray*, double)
415 {
416 vtkErrorMacro("Read only container.");
417 return;
418 }
419
420 //------------------------------------------------------------------------------
421 template <class Scalar>
SetVariantValue(vtkIdType,vtkVariant)422 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetVariantValue(vtkIdType, vtkVariant)
423 {
424 vtkErrorMacro("Read only container.");
425 return;
426 }
427
428 //------------------------------------------------------------------------------
429 template <class Scalar>
InsertVariantValue(vtkIdType,vtkVariant)430 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertVariantValue(vtkIdType, vtkVariant)
431 {
432 vtkErrorMacro("Read only container.");
433 return;
434 }
435
436 //------------------------------------------------------------------------------
437 template <class Scalar>
RemoveTuple(vtkIdType)438 void vtkCPExodusIIResultsArrayTemplate<Scalar>::RemoveTuple(vtkIdType)
439 {
440 vtkErrorMacro("Read only container.");
441 return;
442 }
443
444 //------------------------------------------------------------------------------
445 template <class Scalar>
RemoveFirstTuple()446 void vtkCPExodusIIResultsArrayTemplate<Scalar>::RemoveFirstTuple()
447 {
448 vtkErrorMacro("Read only container.");
449 return;
450 }
451
452 //------------------------------------------------------------------------------
453 template <class Scalar>
RemoveLastTuple()454 void vtkCPExodusIIResultsArrayTemplate<Scalar>::RemoveLastTuple()
455 {
456 vtkErrorMacro("Read only container.");
457 return;
458 }
459
460 //------------------------------------------------------------------------------
461 template <class Scalar>
SetTypedTuple(vtkIdType,const Scalar *)462 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetTypedTuple(vtkIdType, const Scalar*)
463 {
464 vtkErrorMacro("Read only container.");
465 return;
466 }
467
468 //------------------------------------------------------------------------------
469 template <class Scalar>
InsertTypedTuple(vtkIdType,const Scalar *)470 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertTypedTuple(vtkIdType, const Scalar*)
471 {
472 vtkErrorMacro("Read only container.");
473 return;
474 }
475
476 //------------------------------------------------------------------------------
477 template <class Scalar>
InsertNextTypedTuple(const Scalar *)478 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertNextTypedTuple(const Scalar*)
479 {
480 vtkErrorMacro("Read only container.");
481 return -1;
482 }
483
484 //------------------------------------------------------------------------------
485 template <class Scalar>
SetValue(vtkIdType,Scalar)486 void vtkCPExodusIIResultsArrayTemplate<Scalar>::SetValue(vtkIdType, Scalar)
487 {
488 vtkErrorMacro("Read only container.");
489 return;
490 }
491
492 //------------------------------------------------------------------------------
493 template <class Scalar>
InsertNextValue(Scalar)494 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertNextValue(Scalar)
495 {
496 vtkErrorMacro("Read only container.");
497 return -1;
498 }
499
500 //------------------------------------------------------------------------------
501 template <class Scalar>
InsertValue(vtkIdType,Scalar)502 void vtkCPExodusIIResultsArrayTemplate<Scalar>::InsertValue(vtkIdType, Scalar)
503 {
504 vtkErrorMacro("Read only container.");
505 return;
506 }
507
508 //------------------------------------------------------------------------------
509 template <class Scalar>
vtkCPExodusIIResultsArrayTemplate()510 vtkCPExodusIIResultsArrayTemplate<Scalar>::vtkCPExodusIIResultsArrayTemplate()
511 : TempDoubleArray(nullptr)
512 , Save(false)
513 {
514 }
515
516 //------------------------------------------------------------------------------
517 template <class Scalar>
~vtkCPExodusIIResultsArrayTemplate()518 vtkCPExodusIIResultsArrayTemplate<Scalar>::~vtkCPExodusIIResultsArrayTemplate()
519 {
520 typedef typename std::vector<Scalar*>::const_iterator ArrayIterator;
521 if (!this->Save)
522 {
523 for (ArrayIterator it = this->Arrays.begin(), itEnd = this->Arrays.end(); it != itEnd; ++it)
524 {
525 delete[] * it;
526 }
527 }
528 delete[] this->TempDoubleArray;
529 }
530
531 //------------------------------------------------------------------------------
532 template <class Scalar>
Lookup(const Scalar & val,vtkIdType index)533 vtkIdType vtkCPExodusIIResultsArrayTemplate<Scalar>::Lookup(const Scalar& val, vtkIdType index)
534 {
535 while (index <= this->MaxId)
536 {
537 if (this->GetValueReference(index++) == val)
538 {
539 return index;
540 }
541 }
542 return -1;
543 }
544