VTK  9.0.1
vtkExodusIIReader.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkExodusIIReader.h
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  Copyright (c) Sandia Corporation
17  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
18 ----------------------------------------------------------------------------*/
19 
37 #ifndef vtkExodusIIReader_h
38 #define vtkExodusIIReader_h
39 
40 #include "vtkIOExodusModule.h" // For export macro
42 
43 class vtkDataArray;
44 class vtkDataSet;
45 class vtkExodusIICache;
47 class vtkFloatArray;
48 class vtkGraph;
50 class vtkIntArray;
51 class vtkPoints;
53 
54 class VTKIOEXODUS_EXPORT vtkExodusIIReader : public vtkMultiBlockDataSetAlgorithm
55 {
56 public:
57  static vtkExodusIIReader* New();
59  void PrintSelf(ostream& os, vtkIndent indent) override;
60 
64  virtual int CanReadFile(const char* fname);
65 
66  // virtual void Modified();
67 
71  vtkMTimeType GetMTime() override;
72 
78  virtual vtkMTimeType GetMetadataMTime();
79 
81 
84  virtual void SetFileName(const char* fname);
85  vtkGetStringMacro(FileName);
87 
89 
92  virtual void SetXMLFileName(const char* fname);
93  vtkGetStringMacro(XMLFileName);
95 
97 
100  vtkSetMacro(TimeStep, int);
101  vtkGetMacro(TimeStep, int);
103 
108  void SetModeShape(int val) { this->SetTimeStep(val - 1); }
109 
111 
117  vtkGetVector2Macro(ModeShapesRange, int);
119 
121 
126  vtkGetVector2Macro(TimeStepRange, int);
128 
130 
141  virtual void SetGenerateObjectIdCellArray(vtkTypeBool g);
142  vtkTypeBool GetGenerateObjectIdCellArray();
143  vtkBooleanMacro(GenerateObjectIdCellArray, vtkTypeBool);
144  static const char* GetObjectIdArrayName() { return "ObjectId"; }
146 
147  virtual void SetGenerateGlobalElementIdArray(vtkTypeBool g);
148  vtkTypeBool GetGenerateGlobalElementIdArray();
149  vtkBooleanMacro(GenerateGlobalElementIdArray, vtkTypeBool);
150 
151  virtual void SetGenerateGlobalNodeIdArray(vtkTypeBool g);
152  vtkTypeBool GetGenerateGlobalNodeIdArray();
153  vtkBooleanMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
154 
155  virtual void SetGenerateImplicitElementIdArray(vtkTypeBool g);
156  vtkTypeBool GetGenerateImplicitElementIdArray();
157  vtkBooleanMacro(GenerateImplicitElementIdArray, vtkTypeBool);
158 
159  virtual void SetGenerateImplicitNodeIdArray(vtkTypeBool g);
160  vtkTypeBool GetGenerateImplicitNodeIdArray();
161  vtkBooleanMacro(GenerateImplicitNodeIdArray, vtkTypeBool);
162 
163  virtual void SetGenerateFileIdArray(vtkTypeBool f);
164  vtkTypeBool GetGenerateFileIdArray();
165  vtkBooleanMacro(GenerateFileIdArray, vtkTypeBool);
166 
167  virtual void SetFileId(int f);
168  int GetFileId();
169 
171 
177  enum
178  {
179  SEARCH_TYPE_ELEMENT = 0,
183  ID_NOT_FOUND = -234121312
184  };
185  // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
187  {
188  // match Exodus macros from exodusII.h and exodusII_ext.h
189  EDGE_BLOCK = 6,
190  FACE_BLOCK = 8,
191  ELEM_BLOCK = 1,
192  NODE_SET = 2,
193  EDGE_SET = 7,
194  FACE_SET = 9,
195  SIDE_SET = 3,
196  ELEM_SET = 10,
197  NODE_MAP = 5,
198  EDGE_MAP = 11,
199  FACE_MAP = 12,
200  ELEM_MAP = 4,
201  GLOBAL = 13,
202  NODAL = 14,
203  // extended values (not in Exodus headers) for use with SetAllArrayStatus:
204  ASSEMBLY = 60,
205  PART = 61,
206  MATERIAL = 62,
207  HIERARCHY = 63,
208  // extended values (not in Exodus headers) for use in cache keys:
209  QA_RECORDS = 103,
210  INFO_RECORDS = 104,
211  GLOBAL_TEMPORAL = 102,
212  NODAL_TEMPORAL = 101,
213  ELEM_BLOCK_TEMPORAL = 100,
214  GLOBAL_CONN = 99,
215  ELEM_BLOCK_ELEM_CONN = 98,
216  ELEM_BLOCK_FACE_CONN =
217  97,
218  ELEM_BLOCK_EDGE_CONN =
219  96,
220  FACE_BLOCK_CONN = 95,
221  EDGE_BLOCK_CONN = 94,
222  ELEM_SET_CONN = 93,
223  SIDE_SET_CONN = 92,
224  FACE_SET_CONN = 91,
225  EDGE_SET_CONN = 90,
226  NODE_SET_CONN = 89,
227  NODAL_COORDS = 88,
228  OBJECT_ID = 87,
229  IMPLICIT_ELEMENT_ID = 108,
230  IMPLICIT_NODE_ID = 107,
231  GLOBAL_ELEMENT_ID =
232  86,
233  GLOBAL_NODE_ID =
234  85,
235  ELEMENT_ID = 84,
236  NODE_ID = 83,
237  NODAL_SQUEEZEMAP = 82,
238  ELEM_BLOCK_ATTRIB = 81,
239  FACE_BLOCK_ATTRIB = 80,
240  EDGE_BLOCK_ATTRIB = 79,
241  FACE_ID = 105,
242  EDGE_ID = 106,
243  ENTITY_COUNTS = 109
244  };
246 
247  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
248  static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
249  static int GetGlobalElementID(vtkDataSet* data, int localID);
250  static int GetGlobalElementID(vtkDataSet* data, int localID, int searchType);
251  static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }
252 
253  static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
254  static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
255  static int GetGlobalFaceID(vtkDataSet* data, int localID);
256  static int GetGlobalFaceID(vtkDataSet* data, int localID, int searchType);
257  static const char* GetImplicitFaceIdArrayName() { return "ImplicitFaceId"; }
258 
259  static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
260  static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
261  static int GetGlobalEdgeID(vtkDataSet* data, int localID);
262  static int GetGlobalEdgeID(vtkDataSet* data, int localID, int searchType);
263  static const char* GetImplicitEdgeIdArrayName() { return "ImplicitEdgeId"; }
264 
266 
272  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }
273  static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }
274  static int GetGlobalNodeID(vtkDataSet* data, int localID);
275  static int GetGlobalNodeID(vtkDataSet* data, int localID, int searchType);
276  static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }
278 
283  static const char* GetSideSetSourceElementIdArrayName() { return "SourceElementId"; }
284 
289  static const char* GetSideSetSourceElementSideArrayName() { return "SourceElementSide"; }
291 
298  virtual void SetApplyDisplacements(vtkTypeBool d);
299  vtkTypeBool GetApplyDisplacements();
300  vtkBooleanMacro(ApplyDisplacements, vtkTypeBool);
301  virtual void SetDisplacementMagnitude(float s);
302  float GetDisplacementMagnitude();
304 
306 
311  virtual void SetHasModeShapes(vtkTypeBool ms);
312  vtkTypeBool GetHasModeShapes();
313  vtkBooleanMacro(HasModeShapes, vtkTypeBool);
315 
317 
324  virtual void SetModeShapeTime(double phase);
325  double GetModeShapeTime();
327 
329 
336  virtual void SetAnimateModeShapes(vtkTypeBool flag);
337  vtkTypeBool GetAnimateModeShapes();
338  vtkBooleanMacro(AnimateModeShapes, vtkTypeBool);
340 
342 
348  virtual void SetIgnoreFileTime(bool flag);
349  bool GetIgnoreFileTime();
350  vtkBooleanMacro(IgnoreFileTime, bool);
352 
354 
357  const char* GetTitle();
358  int GetDimensionality();
359  int GetNumberOfTimeSteps();
361 
362  int GetNumberOfNodesInFile();
363  int GetNumberOfEdgesInFile();
364  int GetNumberOfFacesInFile();
365  int GetNumberOfElementsInFile();
366 
367  int GetObjectTypeFromName(const char* name);
368  const char* GetObjectTypeName(int);
369 
370  int GetNumberOfNodes();
371  int GetNumberOfObjects(int objectType);
372  int GetNumberOfEntriesInObject(int objectType, int objectIndex);
373  int GetObjectId(int objectType, int objectIndex);
374  const char* GetObjectName(int objectType, int objectIndex);
375  int GetObjectIndex(int objectType, const char* objectName);
376  int GetObjectIndex(int objectType, int id);
377  int GetObjectStatus(int objectType, int objectIndex);
378  int GetObjectStatus(int objectType, const char* objectName)
379  {
380  return this->GetObjectStatus(objectType, this->GetObjectIndex(objectType, objectName));
381  }
382  void SetObjectStatus(int objectType, int objectIndex, int status);
383  void SetObjectStatus(int objectType, const char* objectName, int status);
384 
386 
392  int GetNumberOfObjectArrays(int objectType);
393  const char* GetObjectArrayName(int objectType, int arrayIndex);
394  int GetObjectArrayIndex(int objectType, const char* arrayName);
395  int GetNumberOfObjectArrayComponents(int objectType, int arrayIndex);
396  int GetObjectArrayStatus(int objectType, int arrayIndex);
397  int GetObjectArrayStatus(int objectType, const char* arrayName)
398  {
399  return this->GetObjectArrayStatus(objectType, this->GetObjectArrayIndex(objectType, arrayName));
400  }
401  void SetObjectArrayStatus(int objectType, int arrayIndex, int status);
402  void SetObjectArrayStatus(int objectType, const char* arrayName, int status);
404 
406 
412  int GetNumberOfObjectAttributes(int objectType, int objectIndex);
413  const char* GetObjectAttributeName(int objectType, int objectIndex, int attribIndex);
414  int GetObjectAttributeIndex(int objectType, int objectIndex, const char* attribName);
415  int GetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex);
416  int GetObjectAttributeStatus(int objectType, int objectIndex, const char* attribName)
417  {
418  return this->GetObjectAttributeStatus(
419  objectType, objectIndex, this->GetObjectAttributeIndex(objectType, objectIndex, attribName));
420  }
421  void SetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex, int status);
422  void SetObjectAttributeStatus(int objectType, int objectIndex, const char* attribName, int status)
423  {
424  this->SetObjectAttributeStatus(objectType, objectIndex,
425  this->GetObjectAttributeIndex(objectType, objectIndex, attribName), status);
426  }
428 
429  virtual vtkIdType GetTotalNumberOfNodes();
430  virtual vtkIdType GetTotalNumberOfEdges();
431  virtual vtkIdType GetTotalNumberOfFaces();
432  virtual vtkIdType GetTotalNumberOfElements();
433 
435 
440  int GetNumberOfPartArrays();
441  const char* GetPartArrayName(int arrayIdx);
442  int GetPartArrayID(const char* name);
443  const char* GetPartBlockInfo(int arrayIdx);
444  void SetPartArrayStatus(int index, int flag);
445  void SetPartArrayStatus(const char*, int flag);
446  int GetPartArrayStatus(int index);
447  int GetPartArrayStatus(const char*);
449 
451 
457  int GetNumberOfMaterialArrays();
458  const char* GetMaterialArrayName(int arrayIdx);
459  int GetMaterialArrayID(const char* name);
460  void SetMaterialArrayStatus(int index, int flag);
461  void SetMaterialArrayStatus(const char*, int flag);
462  int GetMaterialArrayStatus(int index);
463  int GetMaterialArrayStatus(const char*);
465 
467 
473  int GetNumberOfAssemblyArrays();
474  const char* GetAssemblyArrayName(int arrayIdx);
475  int GetAssemblyArrayID(const char* name);
476  void SetAssemblyArrayStatus(int index, int flag);
477  void SetAssemblyArrayStatus(const char*, int flag);
478  int GetAssemblyArrayStatus(int index);
479  int GetAssemblyArrayStatus(const char*);
481 
483 
492  int GetNumberOfHierarchyArrays();
493  const char* GetHierarchyArrayName(int arrayIdx);
494  void SetHierarchyArrayStatus(int index, int flag);
495  void SetHierarchyArrayStatus(const char*, int flag);
496  int GetHierarchyArrayStatus(int index);
497  int GetHierarchyArrayStatus(const char*);
499 
500  vtkGetMacro(DisplayType, int);
501  virtual void SetDisplayType(int type);
502 
506  int IsValidVariable(const char* type, const char* name);
507 
511  int GetVariableID(const char* type, const char* name);
512 
513  void SetAllArrayStatus(int otype, int status);
514  // Helper functions
515  // static int StringsEqual(const char* s1, char* s2);
516  // static void StringUppercase(const char* str, char* upperstr);
517  // static char *StrDupWithNew(const char *s);
518 
519  // time series query functions
520  int GetTimeSeriesData(int ID, const char* vName, const char* vType, vtkFloatArray* result);
521 
522  int GetNumberOfEdgeBlockArrays() { return this->GetNumberOfObjects(EDGE_BLOCK); }
523  const char* GetEdgeBlockArrayName(int index) { return this->GetObjectName(EDGE_BLOCK, index); }
524  int GetEdgeBlockArrayStatus(const char* name) { return this->GetObjectStatus(EDGE_BLOCK, name); }
525  void SetEdgeBlockArrayStatus(const char* name, int flag)
526  {
527  this->SetObjectStatus(EDGE_BLOCK, name, flag);
528  }
529 
530  int GetNumberOfFaceBlockArrays() { return this->GetNumberOfObjects(FACE_BLOCK); }
531  const char* GetFaceBlockArrayName(int index) { return this->GetObjectName(FACE_BLOCK, index); }
532  int GetFaceBlockArrayStatus(const char* name) { return this->GetObjectStatus(FACE_BLOCK, name); }
533  void SetFaceBlockArrayStatus(const char* name, int flag)
534  {
535  this->SetObjectStatus(FACE_BLOCK, name, flag);
536  }
537 
538  int GetNumberOfElementBlockArrays() { return this->GetNumberOfObjects(ELEM_BLOCK); }
539  const char* GetElementBlockArrayName(int index) { return this->GetObjectName(ELEM_BLOCK, index); }
541  {
542  return this->GetObjectStatus(ELEM_BLOCK, name);
543  }
544  void SetElementBlockArrayStatus(const char* name, int flag)
545  {
546  this->SetObjectStatus(ELEM_BLOCK, name, flag);
547  }
548 
549  int GetNumberOfGlobalResultArrays() { return this->GetNumberOfObjectArrays(GLOBAL); }
551  {
552  return this->GetObjectArrayName(GLOBAL, index);
553  }
555  {
556  return this->GetObjectArrayStatus(GLOBAL, name);
557  }
558  void SetGlobalResultArrayStatus(const char* name, int flag)
559  {
560  this->SetObjectArrayStatus(GLOBAL, name, flag);
561  }
562 
563  int GetNumberOfPointResultArrays() { return this->GetNumberOfObjectArrays(NODAL); }
564  const char* GetPointResultArrayName(int index) { return this->GetObjectArrayName(NODAL, index); }
566  {
567  return this->GetObjectArrayStatus(NODAL, name);
568  }
569  void SetPointResultArrayStatus(const char* name, int flag)
570  {
571  this->SetObjectArrayStatus(NODAL, name, flag);
572  }
573 
574  int GetNumberOfEdgeResultArrays() { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
575  const char* GetEdgeResultArrayName(int index)
576  {
577  return this->GetObjectArrayName(EDGE_BLOCK, index);
578  }
580  {
581  return this->GetObjectArrayStatus(EDGE_BLOCK, name);
582  }
583  void SetEdgeResultArrayStatus(const char* name, int flag)
584  {
585  this->SetObjectArrayStatus(EDGE_BLOCK, name, flag);
586  }
587 
588  int GetNumberOfFaceResultArrays() { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
589  const char* GetFaceResultArrayName(int index)
590  {
591  return this->GetObjectArrayName(FACE_BLOCK, index);
592  }
594  {
595  return this->GetObjectArrayStatus(FACE_BLOCK, name);
596  }
597  void SetFaceResultArrayStatus(const char* name, int flag)
598  {
599  this->SetObjectArrayStatus(FACE_BLOCK, name, flag);
600  }
601 
602  int GetNumberOfElementResultArrays() { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
604  {
605  return this->GetObjectArrayName(ELEM_BLOCK, index);
606  }
608  {
609  return this->GetObjectArrayStatus(ELEM_BLOCK, name);
610  }
611  void SetElementResultArrayStatus(const char* name, int flag)
612  {
613  this->SetObjectArrayStatus(ELEM_BLOCK, name, flag);
614  }
615 
616  int GetNumberOfNodeMapArrays() { return this->GetNumberOfObjects(NODE_MAP); }
617  const char* GetNodeMapArrayName(int index) { return this->GetObjectName(NODE_MAP, index); }
618  int GetNodeMapArrayStatus(const char* name) { return this->GetObjectStatus(NODE_MAP, name); }
619  void SetNodeMapArrayStatus(const char* name, int flag)
620  {
621  this->SetObjectStatus(NODE_MAP, name, flag);
622  }
623 
624  int GetNumberOfEdgeMapArrays() { return this->GetNumberOfObjects(EDGE_MAP); }
625  const char* GetEdgeMapArrayName(int index) { return this->GetObjectName(EDGE_MAP, index); }
626  int GetEdgeMapArrayStatus(const char* name) { return this->GetObjectStatus(EDGE_MAP, name); }
627  void SetEdgeMapArrayStatus(const char* name, int flag)
628  {
629  this->SetObjectStatus(EDGE_MAP, name, flag);
630  }
631 
632  int GetNumberOfFaceMapArrays() { return this->GetNumberOfObjects(FACE_MAP); }
633  const char* GetFaceMapArrayName(int index) { return this->GetObjectName(FACE_MAP, index); }
634  int GetFaceMapArrayStatus(const char* name) { return this->GetObjectStatus(FACE_MAP, name); }
635  void SetFaceMapArrayStatus(const char* name, int flag)
636  {
637  this->SetObjectStatus(FACE_MAP, name, flag);
638  }
639 
640  int GetNumberOfElementMapArrays() { return this->GetNumberOfObjects(ELEM_MAP); }
641  const char* GetElementMapArrayName(int index) { return this->GetObjectName(ELEM_MAP, index); }
642  int GetElementMapArrayStatus(const char* name) { return this->GetObjectStatus(ELEM_MAP, name); }
643  void SetElementMapArrayStatus(const char* name, int flag)
644  {
645  this->SetObjectStatus(ELEM_MAP, name, flag);
646  }
647 
648  int GetNumberOfNodeSetArrays() { return this->GetNumberOfObjects(NODE_SET); }
649  const char* GetNodeSetArrayName(int index) { return this->GetObjectName(NODE_SET, index); }
650  int GetNodeSetArrayStatus(const char* name) { return this->GetObjectStatus(NODE_SET, name); }
651  void SetNodeSetArrayStatus(const char* name, int flag)
652  {
653  this->SetObjectStatus(NODE_SET, name, flag);
654  }
655 
656  int GetNumberOfSideSetArrays() { return this->GetNumberOfObjects(SIDE_SET); }
657  const char* GetSideSetArrayName(int index) { return this->GetObjectName(SIDE_SET, index); }
658  int GetSideSetArrayStatus(const char* name) { return this->GetObjectStatus(SIDE_SET, name); }
659  void SetSideSetArrayStatus(const char* name, int flag)
660  {
661  this->SetObjectStatus(SIDE_SET, name, flag);
662  }
663 
664  int GetNumberOfEdgeSetArrays() { return this->GetNumberOfObjects(EDGE_SET); }
665  const char* GetEdgeSetArrayName(int index) { return this->GetObjectName(EDGE_SET, index); }
666  int GetEdgeSetArrayStatus(const char* name) { return this->GetObjectStatus(EDGE_SET, name); }
667  void SetEdgeSetArrayStatus(const char* name, int flag)
668  {
669  this->SetObjectStatus(EDGE_SET, name, flag);
670  }
671 
672  int GetNumberOfFaceSetArrays() { return this->GetNumberOfObjects(FACE_SET); }
673  const char* GetFaceSetArrayName(int index) { return this->GetObjectName(FACE_SET, index); }
674  int GetFaceSetArrayStatus(const char* name) { return this->GetObjectStatus(FACE_SET, name); }
675  void SetFaceSetArrayStatus(const char* name, int flag)
676  {
677  this->SetObjectStatus(FACE_SET, name, flag);
678  }
679 
680  int GetNumberOfElementSetArrays() { return this->GetNumberOfObjects(ELEM_SET); }
681  const char* GetElementSetArrayName(int index) { return this->GetObjectName(ELEM_SET, index); }
682  int GetElementSetArrayStatus(const char* name) { return this->GetObjectStatus(ELEM_SET, name); }
683  void SetElementSetArrayStatus(const char* name, int flag)
684  {
685  this->SetObjectStatus(ELEM_SET, name, flag);
686  }
687 
688  int GetNumberOfNodeSetResultArrays() { return this->GetNumberOfObjectArrays(NODE_SET); }
690  {
691  return this->GetObjectArrayName(NODE_SET, index);
692  }
694  {
695  return this->GetObjectArrayStatus(NODE_SET, name);
696  }
697  void SetNodeSetResultArrayStatus(const char* name, int flag)
698  {
699  this->SetObjectArrayStatus(NODE_SET, name, flag);
700  }
701 
702  int GetNumberOfSideSetResultArrays() { return this->GetNumberOfObjectArrays(SIDE_SET); }
704  {
705  return this->GetObjectArrayName(SIDE_SET, index);
706  }
708  {
709  return this->GetObjectArrayStatus(SIDE_SET, name);
710  }
711  void SetSideSetResultArrayStatus(const char* name, int flag)
712  {
713  this->SetObjectArrayStatus(SIDE_SET, name, flag);
714  }
715 
716  int GetNumberOfEdgeSetResultArrays() { return this->GetNumberOfObjectArrays(EDGE_SET); }
718  {
719  return this->GetObjectArrayName(EDGE_SET, index);
720  }
722  {
723  return this->GetObjectArrayStatus(EDGE_SET, name);
724  }
725  void SetEdgeSetResultArrayStatus(const char* name, int flag)
726  {
727  this->SetObjectArrayStatus(EDGE_SET, name, flag);
728  }
729 
730  int GetNumberOfFaceSetResultArrays() { return this->GetNumberOfObjectArrays(FACE_SET); }
732  {
733  return this->GetObjectArrayName(FACE_SET, index);
734  }
736  {
737  return this->GetObjectArrayStatus(FACE_SET, name);
738  }
739  void SetFaceSetResultArrayStatus(const char* name, int flag)
740  {
741  this->SetObjectArrayStatus(FACE_SET, name, flag);
742  }
743 
744  int GetNumberOfElementSetResultArrays() { return this->GetNumberOfObjectArrays(ELEM_SET); }
746  {
747  return this->GetObjectArrayName(ELEM_SET, index);
748  }
750  {
751  return this->GetObjectArrayStatus(ELEM_SET, name);
752  }
753  void SetElementSetResultArrayStatus(const char* name, int flag)
754  {
755  this->SetObjectArrayStatus(ELEM_SET, name, flag);
756  }
757 
766  void Reset();
767 
776  void ResetSettings();
777 
781  void ResetCache();
782 
786  void SetCacheSize(double CacheSize);
787 
791  double GetCacheSize();
792 
794 
806  void SetSqueezePoints(bool sp);
807  bool GetSqueezePoints();
809 
810  virtual void Dump();
811 
816  vtkGraph* GetSIL();
817 
819 
822  vtkGetMacro(SILUpdateStamp, int);
824 
826 
830  int GetMaxNameLength();
832 
834 
842  static vtkInformationIntegerKey* GLOBAL_VARIABLE();
843  static vtkInformationIntegerKey* GLOBAL_TEMPORAL_VARIABLE();
845 
847 
854  vtkSetMacro(UseLegacyBlockNames, bool);
855  vtkGetMacro(UseLegacyBlockNames, bool);
856  vtkBooleanMacro(UseLegacyBlockNames, bool);
858 protected:
860  ~vtkExodusIIReader() override;
861 
862  // helper for finding IDs
863  static int GetIDHelper(const char* arrayName, vtkDataSet* data, int localID, int searchType);
864  static int GetGlobalID(const char* arrayName, vtkDataSet* data, int localID, int searchType);
865 
866  virtual void SetMetadata(vtkExodusIIReaderPrivate*);
867  vtkGetObjectMacro(Metadata, vtkExodusIIReaderPrivate);
868 
873  bool FindXMLFile();
874 
875  // Time query function. Called by ExecuteInformation().
876  // Fills the TimestepValues array.
877  void GetAllTimes(vtkInformationVector*);
878 
882  void AdvertiseTimeSteps(vtkInformation* outputInfo);
883 
888  // int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
889 
890  // Parameters for controlling what is read in.
891  char* FileName;
892  char* XMLFileName;
893  int TimeStep;
894  int TimeStepRange[2];
897 
898  // Information specific for exodus files.
899 
900  // 1=display Block names
901  // 2=display Part names
902  // 3=display Material names
904 
905  // Metadata containing a description of the currently open file.
907 
909 
910  friend class vtkPExodusIIReader;
911 
912 private:
913  vtkExodusIIReader(const vtkExodusIIReader&) = delete;
914  void operator=(const vtkExodusIIReader&) = delete;
915 
916  void AddDisplacements(vtkUnstructuredGrid* output);
917  int ModeShapesRange[2];
918 
919  bool UseLegacyBlockNames;
920 };
921 
922 #endif
const char * GetEdgeResultArrayName(int index)
static const char * GetGlobalNodeIdArrayName()
Extra point data array that can be generated.
const char * GetSideSetResultArrayName(int index)
static const char * GetImplicitElementIdArrayName()
const char * GetEdgeSetArrayName(int index)
void SetElementSetResultArrayStatus(const char *name, int flag)
int GetFaceMapArrayStatus(const char *name)
const char * GetEdgeSetResultArrayName(int index)
void SetEdgeResultArrayStatus(const char *name, int flag)
void SetNodeSetArrayStatus(const char *name, int flag)
Store vtkAlgorithm input/output information.
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:293
const char * GetEdgeBlockArrayName(int index)
void SetNodeMapArrayStatus(const char *name, int flag)
void SetEdgeSetResultArrayStatus(const char *name, int flag)
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
int GetGlobalResultArrayStatus(const char *name)
static const char * GetImplicitFaceIdArrayName()
int GetEdgeSetResultArrayStatus(const char *name)
const char * GetNodeSetArrayName(int index)
void SetEdgeBlockArrayStatus(const char *name, int flag)
void SetNodeSetResultArrayStatus(const char *name, int flag)
void SetSideSetArrayStatus(const char *name, int flag)
record modification and/or execution time
Definition: vtkTimeStamp.h:32
int GetElementSetResultArrayStatus(const char *name)
int GetElementBlockArrayStatus(const char *name)
const char * GetElementSetArrayName(int index)
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:35
int GetNumberOfFaceSetResultArrays()
const char * GetFaceSetResultArrayName(int index)
const char * GetFaceSetArrayName(int index)
int GetNumberOfEdgeSetResultArrays()
int GetNumberOfElementResultArrays()
int GetElementResultArrayStatus(const char *name)
void SetElementResultArrayStatus(const char *name, int flag)
int GetEdgeResultArrayStatus(const char *name)
ObjectType
Extra cell data array that can be generated.
int vtkIdType
Definition: vtkType.h:338
This class holds metadata for an Exodus file.
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
void SetPointResultArrayStatus(const char *name, int flag)
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
const char * GetEdgeMapArrayName(int index)
int GetNodeSetResultArrayStatus(const char *name)
void SetFaceBlockArrayStatus(const char *name, int flag)
const char * GetGlobalResultArrayName(int index)
int GetNumberOfSideSetResultArrays()
int GetElementSetArrayStatus(const char *name)
static vtkMultiBlockDataSetAlgorithm * New()
static const char * GetImplicitNodeIdArrayName()
Extra point data array that can be generated.
int vtkTypeBool
Definition: vtkABI.h:69
Base class for graph data types.
Definition: vtkGraph.h:289
int GetNodeSetArrayStatus(const char *name)
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:39
void SetEdgeMapArrayStatus(const char *name, int flag)
int GetNumberOfNodeSetResultArrays()
int GetSideSetArrayStatus(const char *name)
const char * GetNodeSetResultArrayName(int index)
const char * GetElementMapArrayName(int index)
a simple class to control print indentation
Definition: vtkIndent.h:33
void SetElementSetArrayStatus(const char *name, int flag)
static const char * GetObjectIdArrayName()
Extra cell data array that can be generated.
Read Exodus II files (.exii)
int GetElementMapArrayStatus(const char *name)
static const char * GetSideSetSourceElementIdArrayName()
Get the name of the array that stores the mapping from side set cells back to the global id of the el...
Key for integer values in vtkInformation.
const char * GetNodeMapArrayName(int index)
dataset represents arbitrary combinations of all possible cell types
void SetFaceSetArrayStatus(const char *name, int flag)
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
virtual vtkMTimeType GetMTime()
Return this object's modified time.
void SetFaceMapArrayStatus(const char *name, int flag)
vtkTimeStamp XMLFileNameMTime
static const char * GetGlobalEdgeIdArrayName()
static const char * GetGlobalFaceIdArrayName()
vtkTypeBool ProcessRequest(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
see vtkAlgorithm for details
static const char * GetPedigreeFaceIdArrayName()
int GetEdgeBlockArrayStatus(const char *name)
int GetObjectArrayStatus(int objectType, const char *arrayName)
By default arrays are not loaded.
static const char * GetPedigreeElementIdArrayName()
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
const char * GetFaceBlockArrayName(int index)
static const char * GetPedigreeNodeIdArrayName()
Extra point data array that can be generated.
const char * GetElementResultArrayName(int index)
void SetSideSetResultArrayStatus(const char *name, int flag)
int GetEdgeSetArrayStatus(const char *name)
const char * GetFaceResultArrayName(int index)
int GetNumberOfElementSetResultArrays()
const char * GetSideSetArrayName(int index)
int GetNodeMapArrayStatus(const char *name)
static const char * GetPedigreeEdgeIdArrayName()
Read exodus 2 files .ex2.
int GetFaceSetResultArrayStatus(const char *name)
static const char * GetImplicitEdgeIdArrayName()
void SetGlobalResultArrayStatus(const char *name, int flag)
int GetEdgeMapArrayStatus(const char *name)
int GetObjectStatus(int objectType, const char *objectName)
void SetElementBlockArrayStatus(const char *name, int flag)
int GetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName)
By default attributes are not loaded.
void SetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName, int status)
By default attributes are not loaded.
int GetPointResultArrayStatus(const char *name)
const char * GetFaceMapArrayName(int index)
void SetModeShape(int val)
Convenience method to set the mode-shape which is same as this->SetTimeStep(val-1);.
void SetFaceResultArrayStatus(const char *name, int flag)
int GetFaceBlockArrayStatus(const char *name)
const char * GetPointResultArrayName(int index)
int GetSideSetResultArrayStatus(const char *name)
Store zero or more vtkInformation instances.
const char * GetElementBlockArrayName(int index)
int GetFaceSetArrayStatus(const char *name)
void SetElementMapArrayStatus(const char *name, int flag)
static const char * GetGlobalElementIdArrayName()
void SetFaceSetResultArrayStatus(const char *name, int flag)
static const char * GetSideSetSourceElementSideArrayName()
Get the name of the array that stores the mapping from side set cells back to the canonical side of t...
represent and manipulate 3D points
Definition: vtkPoints.h:33
const char * GetElementSetResultArrayName(int index)
void SetEdgeSetArrayStatus(const char *name, int flag)
vtkExodusIIReaderPrivate * Metadata
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
int GetFaceResultArrayStatus(const char *name)
vtkTimeStamp FileNameMTime