VTK  9.2.6
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 
40 #ifndef vtkExodusIIReader_h
41 #define vtkExodusIIReader_h
42 
43 #include "vtkIOExodusModule.h" // For export macro
45 
46 class vtkDataArray;
47 class vtkDataSet;
48 class vtkExodusIICache;
50 class vtkFloatArray;
51 class vtkGraph;
53 class vtkIntArray;
54 class vtkPoints;
56 
57 class VTKIOEXODUS_EXPORT vtkExodusIIReader : public vtkMultiBlockDataSetAlgorithm
58 {
59 public:
60  static vtkExodusIIReader* New();
62  void PrintSelf(ostream& os, vtkIndent indent) override;
63 
67  virtual int CanReadFile(VTK_FILEPATH const char* fname);
68 
69  // virtual void Modified();
70 
74  vtkMTimeType GetMTime() override;
75 
81  virtual vtkMTimeType GetMetadataMTime();
82 
84 
87  virtual void SetFileName(VTK_FILEPATH const char* fname);
88  vtkGetFilePathMacro(FileName);
90 
92 
95  virtual void SetXMLFileName(VTK_FILEPATH const char* fname);
96  vtkGetFilePathMacro(XMLFileName);
98 
100 
103  vtkSetMacro(TimeStep, int);
104  vtkGetMacro(TimeStep, int);
106 
111  void SetModeShape(int val) { this->SetTimeStep(val - 1); }
112 
114 
120  vtkGetVector2Macro(ModeShapesRange, int);
122 
124 
129  vtkGetVector2Macro(TimeStepRange, int);
131 
133 
144  virtual void SetGenerateObjectIdCellArray(vtkTypeBool g);
145  vtkTypeBool GetGenerateObjectIdCellArray();
146  vtkBooleanMacro(GenerateObjectIdCellArray, vtkTypeBool);
147  static const char* GetObjectIdArrayName() { return "ObjectId"; }
149 
150  virtual void SetGenerateGlobalElementIdArray(vtkTypeBool g);
151  vtkTypeBool GetGenerateGlobalElementIdArray();
152  vtkBooleanMacro(GenerateGlobalElementIdArray, vtkTypeBool);
153 
154  virtual void SetGenerateGlobalNodeIdArray(vtkTypeBool g);
155  vtkTypeBool GetGenerateGlobalNodeIdArray();
156  vtkBooleanMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
157 
158  virtual void SetGenerateImplicitElementIdArray(vtkTypeBool g);
159  vtkTypeBool GetGenerateImplicitElementIdArray();
160  vtkBooleanMacro(GenerateImplicitElementIdArray, vtkTypeBool);
161 
162  virtual void SetGenerateImplicitNodeIdArray(vtkTypeBool g);
163  vtkTypeBool GetGenerateImplicitNodeIdArray();
164  vtkBooleanMacro(GenerateImplicitNodeIdArray, vtkTypeBool);
165 
166  virtual void SetGenerateFileIdArray(vtkTypeBool f);
167  vtkTypeBool GetGenerateFileIdArray();
168  vtkBooleanMacro(GenerateFileIdArray, vtkTypeBool);
169 
170  virtual void SetFileId(int f);
171  int GetFileId();
172 
174 
180  enum
181  {
182  SEARCH_TYPE_ELEMENT = 0,
186  ID_NOT_FOUND = -234121312
187  };
188  // NOTE: GetNumberOfObjectTypes must be updated whenever you add an entry to enum ObjectType {...}
190  {
191  // match Exodus macros from exodusII.h and exodusII_ext.h
192  EDGE_BLOCK = 6,
193  FACE_BLOCK = 8,
194  ELEM_BLOCK = 1,
195  NODE_SET = 2,
196  EDGE_SET = 7,
197  FACE_SET = 9,
198  SIDE_SET = 3,
199  ELEM_SET = 10,
200  NODE_MAP = 5,
201  EDGE_MAP = 11,
202  FACE_MAP = 12,
203  ELEM_MAP = 4,
204  GLOBAL = 13,
205  NODAL = 14,
206  // extended values (not in Exodus headers) for use with SetAllArrayStatus:
207  ASSEMBLY = 60,
208  PART = 61,
209  MATERIAL = 62,
210  HIERARCHY = 63,
211  // extended values (not in Exodus headers) for use in cache keys:
212  QA_RECORDS = 103,
213  INFO_RECORDS = 104,
214  GLOBAL_TEMPORAL = 102,
215  NODAL_TEMPORAL = 101,
216  ELEM_BLOCK_TEMPORAL = 100,
217  GLOBAL_CONN = 99,
218  ELEM_BLOCK_ELEM_CONN = 98,
219  ELEM_BLOCK_FACE_CONN =
220  97,
221  ELEM_BLOCK_EDGE_CONN =
222  96,
223  FACE_BLOCK_CONN = 95,
224  EDGE_BLOCK_CONN = 94,
225  ELEM_SET_CONN = 93,
226  SIDE_SET_CONN = 92,
227  FACE_SET_CONN = 91,
228  EDGE_SET_CONN = 90,
229  NODE_SET_CONN = 89,
230  NODAL_COORDS = 88,
231  OBJECT_ID = 87,
232  IMPLICIT_ELEMENT_ID = 108,
233  IMPLICIT_NODE_ID = 107,
234  GLOBAL_ELEMENT_ID =
235  86,
236  GLOBAL_NODE_ID =
237  85,
238  ELEMENT_ID = 84,
239  NODE_ID = 83,
240  NODAL_SQUEEZEMAP = 82,
241  ELEM_BLOCK_ATTRIB = 81,
242  FACE_BLOCK_ATTRIB = 80,
243  EDGE_BLOCK_ATTRIB = 79,
244  FACE_ID = 105,
245  EDGE_ID = 106,
246  ENTITY_COUNTS = 109
247  };
249 
250  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
251  static const char* GetPedigreeElementIdArrayName() { return "PedigreeElementId"; }
252  static int GetGlobalElementID(vtkDataSet* data, int localID);
253  static int GetGlobalElementID(vtkDataSet* data, int localID, int searchType);
254  static const char* GetImplicitElementIdArrayName() { return "ImplicitElementId"; }
255 
256  static const char* GetGlobalFaceIdArrayName() { return "GlobalFaceId"; }
257  static const char* GetPedigreeFaceIdArrayName() { return "PedigreeFaceId"; }
258  static int GetGlobalFaceID(vtkDataSet* data, int localID);
259  static int GetGlobalFaceID(vtkDataSet* data, int localID, int searchType);
260  static const char* GetImplicitFaceIdArrayName() { return "ImplicitFaceId"; }
261 
262  static const char* GetGlobalEdgeIdArrayName() { return "GlobalEdgeId"; }
263  static const char* GetPedigreeEdgeIdArrayName() { return "PedigreeEdgeId"; }
264  static int GetGlobalEdgeID(vtkDataSet* data, int localID);
265  static int GetGlobalEdgeID(vtkDataSet* data, int localID, int searchType);
266  static const char* GetImplicitEdgeIdArrayName() { return "ImplicitEdgeId"; }
267 
269 
275  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }
276  static const char* GetPedigreeNodeIdArrayName() { return "PedigreeNodeId"; }
277  static int GetGlobalNodeID(vtkDataSet* data, int localID);
278  static int GetGlobalNodeID(vtkDataSet* data, int localID, int searchType);
279  static const char* GetImplicitNodeIdArrayName() { return "ImplicitNodeId"; }
281 
286  static const char* GetSideSetSourceElementIdArrayName() { return "SourceElementId"; }
287 
292  static const char* GetSideSetSourceElementSideArrayName() { return "SourceElementSide"; }
294 
301  virtual void SetApplyDisplacements(vtkTypeBool d);
302  vtkTypeBool GetApplyDisplacements();
303  vtkBooleanMacro(ApplyDisplacements, vtkTypeBool);
304  virtual void SetDisplacementMagnitude(float s);
305  float GetDisplacementMagnitude();
307 
309 
314  virtual void SetHasModeShapes(vtkTypeBool ms);
315  vtkTypeBool GetHasModeShapes();
316  vtkBooleanMacro(HasModeShapes, vtkTypeBool);
318 
320 
327  virtual void SetModeShapeTime(double phase);
328  double GetModeShapeTime();
330 
332 
339  virtual void SetAnimateModeShapes(vtkTypeBool flag);
340  vtkTypeBool GetAnimateModeShapes();
341  vtkBooleanMacro(AnimateModeShapes, vtkTypeBool);
343 
345 
351  virtual void SetIgnoreFileTime(bool flag);
352  bool GetIgnoreFileTime();
353  vtkBooleanMacro(IgnoreFileTime, bool);
355 
357 
360  const char* GetTitle();
361  int GetDimensionality();
362  int GetNumberOfTimeSteps();
364 
365  int GetNumberOfNodesInFile();
366  int GetNumberOfEdgesInFile();
367  int GetNumberOfFacesInFile();
368  int GetNumberOfElementsInFile();
369 
370  int GetObjectTypeFromName(const char* name);
371  const char* GetObjectTypeName(int);
372 
373  int GetNumberOfNodes();
374  int GetNumberOfObjects(int objectType);
375  int GetNumberOfEntriesInObject(int objectType, int objectIndex);
376  int GetObjectId(int objectType, int objectIndex);
377  const char* GetObjectName(int objectType, int objectIndex);
379  int GetObjectIndex(int objectType, const char* objectName);
380  int GetObjectIndex(int objectType, int id);
381  int GetObjectStatus(int objectType, int objectIndex);
382  int GetObjectStatus(int objectType, const char* objectName)
383  {
384  return this->GetObjectStatus(objectType, this->GetObjectIndex(objectType, objectName));
385  }
386  void SetObjectStatus(int objectType, int objectIndex, int status);
387  void SetObjectStatus(int objectType, const char* objectName, int status);
388 
390 
396  int GetNumberOfObjectArrays(int objectType);
397  const char* GetObjectArrayName(int objectType, int arrayIndex);
398  int GetObjectArrayIndex(int objectType, const char* arrayName);
399  int GetNumberOfObjectArrayComponents(int objectType, int arrayIndex);
400  int GetObjectArrayStatus(int objectType, int arrayIndex);
401  int GetObjectArrayStatus(int objectType, const char* arrayName)
402  {
403  return this->GetObjectArrayStatus(objectType, this->GetObjectArrayIndex(objectType, arrayName));
404  }
405  void SetObjectArrayStatus(int objectType, int arrayIndex, int status);
406  void SetObjectArrayStatus(int objectType, const char* arrayName, int status);
408 
410 
416  int GetNumberOfObjectAttributes(int objectType, int objectIndex);
417  const char* GetObjectAttributeName(int objectType, int objectIndex, int attribIndex);
418  int GetObjectAttributeIndex(int objectType, int objectIndex, const char* attribName);
419  int GetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex);
420  int GetObjectAttributeStatus(int objectType, int objectIndex, const char* attribName)
421  {
422  return this->GetObjectAttributeStatus(
423  objectType, objectIndex, this->GetObjectAttributeIndex(objectType, objectIndex, attribName));
424  }
425  void SetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex, int status);
426  void SetObjectAttributeStatus(int objectType, int objectIndex, const char* attribName, int status)
427  {
428  this->SetObjectAttributeStatus(objectType, objectIndex,
429  this->GetObjectAttributeIndex(objectType, objectIndex, attribName), status);
430  }
432 
433  virtual vtkIdType GetTotalNumberOfNodes();
434  virtual vtkIdType GetTotalNumberOfEdges();
435  virtual vtkIdType GetTotalNumberOfFaces();
436  virtual vtkIdType GetTotalNumberOfElements();
437 
439 
444  int GetNumberOfPartArrays();
445  const char* GetPartArrayName(int arrayIdx);
446  int GetPartArrayID(const char* name);
447  const char* GetPartBlockInfo(int arrayIdx);
448  void SetPartArrayStatus(int index, int flag);
449  void SetPartArrayStatus(const char*, int flag);
450  int GetPartArrayStatus(int index);
451  int GetPartArrayStatus(const char*);
453 
455 
461  int GetNumberOfMaterialArrays();
462  const char* GetMaterialArrayName(int arrayIdx);
463  int GetMaterialArrayID(const char* name);
464  void SetMaterialArrayStatus(int index, int flag);
465  void SetMaterialArrayStatus(const char*, int flag);
466  int GetMaterialArrayStatus(int index);
467  int GetMaterialArrayStatus(const char*);
469 
471 
477  int GetNumberOfAssemblyArrays();
478  const char* GetAssemblyArrayName(int arrayIdx);
479  int GetAssemblyArrayID(const char* name);
480  void SetAssemblyArrayStatus(int index, int flag);
481  void SetAssemblyArrayStatus(const char*, int flag);
482  int GetAssemblyArrayStatus(int index);
483  int GetAssemblyArrayStatus(const char*);
485 
487 
496  int GetNumberOfHierarchyArrays();
497  const char* GetHierarchyArrayName(int arrayIdx);
498  void SetHierarchyArrayStatus(int index, int flag);
499  void SetHierarchyArrayStatus(const char*, int flag);
500  int GetHierarchyArrayStatus(int index);
501  int GetHierarchyArrayStatus(const char*);
503 
504  vtkGetMacro(DisplayType, int);
505  virtual void SetDisplayType(int type);
506 
510  int IsValidVariable(const char* type, const char* name);
511 
515  int GetVariableID(const char* type, const char* name);
516 
517  void SetAllArrayStatus(int otype, int status);
518  // Helper functions
519  // static int StringsEqual(const char* s1, char* s2);
520  // static void StringUppercase(const char* str, char* upperstr);
521  // static char *StrDupWithNew(const char *s);
522 
523  // time series query functions
524  int GetTimeSeriesData(int ID, const char* vName, const char* vType, vtkFloatArray* result);
525 
526  int GetNumberOfEdgeBlockArrays() { return this->GetNumberOfObjects(EDGE_BLOCK); }
527  const char* GetEdgeBlockArrayName(int index) { return this->GetObjectName(EDGE_BLOCK, index); }
528  int GetEdgeBlockArrayStatus(const char* name) { return this->GetObjectStatus(EDGE_BLOCK, name); }
529  void SetEdgeBlockArrayStatus(const char* name, int flag)
530  {
531  this->SetObjectStatus(EDGE_BLOCK, name, flag);
532  }
533 
534  int GetNumberOfFaceBlockArrays() { return this->GetNumberOfObjects(FACE_BLOCK); }
535  const char* GetFaceBlockArrayName(int index) { return this->GetObjectName(FACE_BLOCK, index); }
536  int GetFaceBlockArrayStatus(const char* name) { return this->GetObjectStatus(FACE_BLOCK, name); }
537  void SetFaceBlockArrayStatus(const char* name, int flag)
538  {
539  this->SetObjectStatus(FACE_BLOCK, name, flag);
540  }
541 
542  int GetNumberOfElementBlockArrays() { return this->GetNumberOfObjects(ELEM_BLOCK); }
543  const char* GetElementBlockArrayName(int index) { return this->GetObjectName(ELEM_BLOCK, index); }
545  {
546  return this->GetObjectStatus(ELEM_BLOCK, name);
547  }
548  void SetElementBlockArrayStatus(const char* name, int flag)
549  {
550  this->SetObjectStatus(ELEM_BLOCK, name, flag);
551  }
552 
553  int GetNumberOfGlobalResultArrays() { return this->GetNumberOfObjectArrays(GLOBAL); }
555  {
556  return this->GetObjectArrayName(GLOBAL, index);
557  }
559  {
560  return this->GetObjectArrayStatus(GLOBAL, name);
561  }
562  void SetGlobalResultArrayStatus(const char* name, int flag)
563  {
564  this->SetObjectArrayStatus(GLOBAL, name, flag);
565  }
566 
567  int GetNumberOfPointResultArrays() { return this->GetNumberOfObjectArrays(NODAL); }
568  const char* GetPointResultArrayName(int index) { return this->GetObjectArrayName(NODAL, index); }
570  {
571  return this->GetObjectArrayStatus(NODAL, name);
572  }
573  void SetPointResultArrayStatus(const char* name, int flag)
574  {
575  this->SetObjectArrayStatus(NODAL, name, flag);
576  }
577 
578  int GetNumberOfEdgeResultArrays() { return this->GetNumberOfObjectArrays(EDGE_BLOCK); }
579  const char* GetEdgeResultArrayName(int index)
580  {
581  return this->GetObjectArrayName(EDGE_BLOCK, index);
582  }
584  {
585  return this->GetObjectArrayStatus(EDGE_BLOCK, name);
586  }
587  void SetEdgeResultArrayStatus(const char* name, int flag)
588  {
589  this->SetObjectArrayStatus(EDGE_BLOCK, name, flag);
590  }
591 
592  int GetNumberOfFaceResultArrays() { return this->GetNumberOfObjectArrays(FACE_BLOCK); }
593  const char* GetFaceResultArrayName(int index)
594  {
595  return this->GetObjectArrayName(FACE_BLOCK, index);
596  }
598  {
599  return this->GetObjectArrayStatus(FACE_BLOCK, name);
600  }
601  void SetFaceResultArrayStatus(const char* name, int flag)
602  {
603  this->SetObjectArrayStatus(FACE_BLOCK, name, flag);
604  }
605 
606  int GetNumberOfElementResultArrays() { return this->GetNumberOfObjectArrays(ELEM_BLOCK); }
608  {
609  return this->GetObjectArrayName(ELEM_BLOCK, index);
610  }
612  {
613  return this->GetObjectArrayStatus(ELEM_BLOCK, name);
614  }
615  void SetElementResultArrayStatus(const char* name, int flag)
616  {
617  this->SetObjectArrayStatus(ELEM_BLOCK, name, flag);
618  }
619 
620  int GetNumberOfNodeMapArrays() { return this->GetNumberOfObjects(NODE_MAP); }
621  const char* GetNodeMapArrayName(int index) { return this->GetObjectName(NODE_MAP, index); }
622  int GetNodeMapArrayStatus(const char* name) { return this->GetObjectStatus(NODE_MAP, name); }
623  void SetNodeMapArrayStatus(const char* name, int flag)
624  {
625  this->SetObjectStatus(NODE_MAP, name, flag);
626  }
627 
628  int GetNumberOfEdgeMapArrays() { return this->GetNumberOfObjects(EDGE_MAP); }
629  const char* GetEdgeMapArrayName(int index) { return this->GetObjectName(EDGE_MAP, index); }
630  int GetEdgeMapArrayStatus(const char* name) { return this->GetObjectStatus(EDGE_MAP, name); }
631  void SetEdgeMapArrayStatus(const char* name, int flag)
632  {
633  this->SetObjectStatus(EDGE_MAP, name, flag);
634  }
635 
636  int GetNumberOfFaceMapArrays() { return this->GetNumberOfObjects(FACE_MAP); }
637  const char* GetFaceMapArrayName(int index) { return this->GetObjectName(FACE_MAP, index); }
638  int GetFaceMapArrayStatus(const char* name) { return this->GetObjectStatus(FACE_MAP, name); }
639  void SetFaceMapArrayStatus(const char* name, int flag)
640  {
641  this->SetObjectStatus(FACE_MAP, name, flag);
642  }
643 
644  int GetNumberOfElementMapArrays() { return this->GetNumberOfObjects(ELEM_MAP); }
645  const char* GetElementMapArrayName(int index) { return this->GetObjectName(ELEM_MAP, index); }
646  int GetElementMapArrayStatus(const char* name) { return this->GetObjectStatus(ELEM_MAP, name); }
647  void SetElementMapArrayStatus(const char* name, int flag)
648  {
649  this->SetObjectStatus(ELEM_MAP, name, flag);
650  }
651 
652  int GetNumberOfNodeSetArrays() { return this->GetNumberOfObjects(NODE_SET); }
653  const char* GetNodeSetArrayName(int index) { return this->GetObjectName(NODE_SET, index); }
654  int GetNodeSetArrayStatus(const char* name) { return this->GetObjectStatus(NODE_SET, name); }
655  void SetNodeSetArrayStatus(const char* name, int flag)
656  {
657  this->SetObjectStatus(NODE_SET, name, flag);
658  }
659 
660  int GetNumberOfSideSetArrays() { return this->GetNumberOfObjects(SIDE_SET); }
661  const char* GetSideSetArrayName(int index) { return this->GetObjectName(SIDE_SET, index); }
662  int GetSideSetArrayStatus(const char* name) { return this->GetObjectStatus(SIDE_SET, name); }
663  void SetSideSetArrayStatus(const char* name, int flag)
664  {
665  this->SetObjectStatus(SIDE_SET, name, flag);
666  }
667 
668  int GetNumberOfEdgeSetArrays() { return this->GetNumberOfObjects(EDGE_SET); }
669  const char* GetEdgeSetArrayName(int index) { return this->GetObjectName(EDGE_SET, index); }
670  int GetEdgeSetArrayStatus(const char* name) { return this->GetObjectStatus(EDGE_SET, name); }
671  void SetEdgeSetArrayStatus(const char* name, int flag)
672  {
673  this->SetObjectStatus(EDGE_SET, name, flag);
674  }
675 
676  int GetNumberOfFaceSetArrays() { return this->GetNumberOfObjects(FACE_SET); }
677  const char* GetFaceSetArrayName(int index) { return this->GetObjectName(FACE_SET, index); }
678  int GetFaceSetArrayStatus(const char* name) { return this->GetObjectStatus(FACE_SET, name); }
679  void SetFaceSetArrayStatus(const char* name, int flag)
680  {
681  this->SetObjectStatus(FACE_SET, name, flag);
682  }
683 
684  int GetNumberOfElementSetArrays() { return this->GetNumberOfObjects(ELEM_SET); }
685  const char* GetElementSetArrayName(int index) { return this->GetObjectName(ELEM_SET, index); }
686  int GetElementSetArrayStatus(const char* name) { return this->GetObjectStatus(ELEM_SET, name); }
687  void SetElementSetArrayStatus(const char* name, int flag)
688  {
689  this->SetObjectStatus(ELEM_SET, name, flag);
690  }
691 
692  int GetNumberOfNodeSetResultArrays() { return this->GetNumberOfObjectArrays(NODE_SET); }
694  {
695  return this->GetObjectArrayName(NODE_SET, index);
696  }
698  {
699  return this->GetObjectArrayStatus(NODE_SET, name);
700  }
701  void SetNodeSetResultArrayStatus(const char* name, int flag)
702  {
703  this->SetObjectArrayStatus(NODE_SET, name, flag);
704  }
705 
706  int GetNumberOfSideSetResultArrays() { return this->GetNumberOfObjectArrays(SIDE_SET); }
708  {
709  return this->GetObjectArrayName(SIDE_SET, index);
710  }
712  {
713  return this->GetObjectArrayStatus(SIDE_SET, name);
714  }
715  void SetSideSetResultArrayStatus(const char* name, int flag)
716  {
717  this->SetObjectArrayStatus(SIDE_SET, name, flag);
718  }
719 
720  int GetNumberOfEdgeSetResultArrays() { return this->GetNumberOfObjectArrays(EDGE_SET); }
722  {
723  return this->GetObjectArrayName(EDGE_SET, index);
724  }
726  {
727  return this->GetObjectArrayStatus(EDGE_SET, name);
728  }
729  void SetEdgeSetResultArrayStatus(const char* name, int flag)
730  {
731  this->SetObjectArrayStatus(EDGE_SET, name, flag);
732  }
733 
734  int GetNumberOfFaceSetResultArrays() { return this->GetNumberOfObjectArrays(FACE_SET); }
736  {
737  return this->GetObjectArrayName(FACE_SET, index);
738  }
740  {
741  return this->GetObjectArrayStatus(FACE_SET, name);
742  }
743  void SetFaceSetResultArrayStatus(const char* name, int flag)
744  {
745  this->SetObjectArrayStatus(FACE_SET, name, flag);
746  }
747 
748  int GetNumberOfElementSetResultArrays() { return this->GetNumberOfObjectArrays(ELEM_SET); }
750  {
751  return this->GetObjectArrayName(ELEM_SET, index);
752  }
754  {
755  return this->GetObjectArrayStatus(ELEM_SET, name);
756  }
757  void SetElementSetResultArrayStatus(const char* name, int flag)
758  {
759  this->SetObjectArrayStatus(ELEM_SET, name, flag);
760  }
761 
770  void Reset();
771 
780  void ResetSettings();
781 
785  void ResetCache();
786 
790  void SetCacheSize(double CacheSize);
791 
795  double GetCacheSize();
796 
798 
810  void SetSqueezePoints(bool sp);
811  bool GetSqueezePoints();
813 
814  virtual void Dump();
815 
820  vtkGraph* GetSIL();
821 
823 
826  vtkGetMacro(SILUpdateStamp, int);
828 
830 
834  int GetMaxNameLength();
836 
838 
846  static vtkInformationIntegerKey* GLOBAL_VARIABLE();
847  static vtkInformationIntegerKey* GLOBAL_TEMPORAL_VARIABLE();
849 
851 
858  vtkSetMacro(UseLegacyBlockNames, bool);
859  vtkGetMacro(UseLegacyBlockNames, bool);
860  vtkBooleanMacro(UseLegacyBlockNames, bool);
862 protected:
864  ~vtkExodusIIReader() override;
865 
866  // helper for finding IDs
867  static int GetIDHelper(const char* arrayName, vtkDataSet* data, int localID, int searchType);
868  static int GetGlobalID(const char* arrayName, vtkDataSet* data, int localID, int searchType);
869 
870  virtual void SetMetadata(vtkExodusIIReaderPrivate*);
871  vtkGetObjectMacro(Metadata, vtkExodusIIReaderPrivate);
872 
877  bool FindXMLFile();
878 
879  // Time query function. Called by ExecuteInformation().
880  // Fills the TimestepValues array.
881  void GetAllTimes(vtkInformationVector*);
882 
886  void AdvertiseTimeSteps(vtkInformation* outputInfo);
887 
892  // int RequestDataOverTime( vtkInformation *, vtkInformationVector **, vtkInformationVector *);
893 
894  // Parameters for controlling what is read in.
895  char* FileName;
896  char* XMLFileName;
897  int TimeStep;
898  int TimeStepRange[2];
901 
902  // Information specific for exodus files.
903 
904  // 1=display Block names
905  // 2=display Part names
906  // 3=display Material names
908 
909  // Metadata containing a description of the currently open file.
911 
913 
914  friend class vtkPExodusIIReader;
915 
916 private:
917  vtkExodusIIReader(const vtkExodusIIReader&) = delete;
918  void operator=(const vtkExodusIIReader&) = delete;
919 
920  void AddDisplacements(vtkUnstructuredGrid* output);
921  int ModeShapesRange[2];
922 
923  bool UseLegacyBlockNames;
924 };
925 
926 #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:287
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:62
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:35
int GetElementSetResultArrayStatus(const char *name)
int GetElementBlockArrayStatus(const char *name)
const char * GetElementSetArrayName(int index)
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:41
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:332
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:295
int GetNodeSetArrayStatus(const char *name)
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:45
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:39
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:55
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)
virtual std::string GetObjectName() const
Set/get the name of this object for reporting purposes.
#define VTK_FILEPATH
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:39
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