VTK  9.0.2
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:
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 
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 
143  vtkBooleanMacro(GenerateObjectIdCellArray, vtkTypeBool);
144  static const char* GetObjectIdArrayName() { return "ObjectId"; }
146 
149  vtkBooleanMacro(GenerateGlobalElementIdArray, vtkTypeBool);
150 
153  vtkBooleanMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
154 
157  vtkBooleanMacro(GenerateImplicitElementIdArray, vtkTypeBool);
158 
161  vtkBooleanMacro(GenerateImplicitNodeIdArray, vtkTypeBool);
162 
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 
300  vtkBooleanMacro(ApplyDisplacements, vtkTypeBool);
301  virtual void SetDisplacementMagnitude(float s);
304 
306 
311  virtual void SetHasModeShapes(vtkTypeBool ms);
313  vtkBooleanMacro(HasModeShapes, vtkTypeBool);
315 
317 
324  virtual void SetModeShapeTime(double phase);
327 
329 
336  virtual void SetAnimateModeShapes(vtkTypeBool flag);
338  vtkBooleanMacro(AnimateModeShapes, vtkTypeBool);
340 
342 
348  virtual void SetIgnoreFileTime(bool flag);
350  vtkBooleanMacro(IgnoreFileTime, bool);
352 
354 
357  const char* GetTitle();
361 
366 
367  int GetObjectTypeFromName(const char* name);
368  const char* GetObjectTypeName(int);
369 
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 
433 
435 
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);
447  int GetPartArrayStatus(const char*);
449 
451 
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);
463  int GetMaterialArrayStatus(const char*);
465 
467 
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);
479  int GetAssemblyArrayStatus(const char*);
481 
483 
493  const char* GetHierarchyArrayName(int arrayIdx);
494  void SetHierarchyArrayStatus(int index, int flag);
495  void SetHierarchyArrayStatus(const char*, int flag);
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 
777 
781  void ResetCache();
782 
786  void SetCacheSize(double CacheSize);
787 
791  double GetCacheSize();
792 
794 
806  void SetSqueezePoints(bool sp);
809 
810  virtual void Dump();
811 
817 
819 
822  vtkGetMacro(SILUpdateStamp, int);
824 
826 
832 
834 
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 
867  vtkGetObjectMacro(Metadata, vtkExodusIIReaderPrivate);
868 
873  bool FindXMLFile();
874 
875  // Time query function. Called by ExecuteInformation().
876  // Fills the TimestepValues array.
878 
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
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
abstract class to specify dataset behavior
Definition: vtkDataSet.h:57
This class holds metadata for an Exodus file.
Read exodus 2 files .ex2.
virtual void SetGenerateGlobalNodeIdArray(vtkTypeBool g)
int GetNumberOfElementsInFile()
int IsValidVariable(const char *type, const char *name)
return boolean indicating whether the type,name is a valid variable
vtkTypeBool ProcessRequest(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
see vtkAlgorithm for details
const char * GetFaceSetResultArrayName(int index)
vtkTypeBool GetAnimateModeShapes()
const char * GetEdgeMapArrayName(int index)
const char * GetNodeMapArrayName(int index)
int GetEdgeBlockArrayStatus(const char *name)
int GetFaceResultArrayStatus(const char *name)
virtual void SetFileId(int f)
virtual int CanReadFile(const char *fname)
Determine if the file can be read with this reader.
void SetEdgeBlockArrayStatus(const char *name, int flag)
int GetNumberOfFacesInFile()
static int GetGlobalNodeID(vtkDataSet *data, int localID, int searchType)
vtkTypeBool GetGenerateImplicitNodeIdArray()
static const char * GetImplicitEdgeIdArrayName()
const char * GetEdgeResultArrayName(int index)
static int GetGlobalFaceID(vtkDataSet *data, int localID)
int GetObjectArrayStatus(int objectType, int arrayIndex)
static const char * GetImplicitNodeIdArrayName()
int GetObjectIndex(int objectType, const char *objectName)
void SetElementResultArrayStatus(const char *name, int flag)
static const char * GetPedigreeElementIdArrayName()
int GetNumberOfObjectArrays(int objectType)
By default arrays are not loaded.
int GetEdgeSetResultArrayStatus(const char *name)
void SetElementMapArrayStatus(const char *name, int flag)
void SetElementSetArrayStatus(const char *name, int flag)
const char * GetEdgeSetResultArrayName(int index)
const char * GetSideSetResultArrayName(int index)
void SetSideSetResultArrayStatus(const char *name, int flag)
virtual void SetFileName(const char *fname)
Specify file name of the Exodus file.
int GetMaterialArrayStatus(const char *)
int GetNodeMapArrayStatus(const char *name)
int GetNumberOfHierarchyArrays()
By default all hierarchy entries are loaded.
static int GetGlobalEdgeID(vtkDataSet *data, int localID, int searchType)
int GetElementMapArrayStatus(const char *name)
void SetEdgeResultArrayStatus(const char *name, int flag)
int GetNumberOfPartArrays()
By default all parts are loaded.
int GetHierarchyArrayStatus(const char *)
int GetNumberOfTimeSteps()
vtkTypeBool GetGenerateFileIdArray()
int GetNumberOfNodesInFile()
virtual void Dump()
void SetFaceBlockArrayStatus(const char *name, int flag)
int GetPointResultArrayStatus(const char *name)
int GetPartArrayStatus(int index)
void SetPartArrayStatus(int index, int flag)
virtual void SetHasModeShapes(vtkTypeBool ms)
Set/Get whether the Exodus sequence number corresponds to time steps or mode shapes.
const char * GetElementResultArrayName(int index)
static int GetGlobalID(const char *arrayName, vtkDataSet *data, int localID, int searchType)
static const char * GetPedigreeFaceIdArrayName()
vtkTypeBool GetGenerateGlobalElementIdArray()
virtual void SetGenerateImplicitNodeIdArray(vtkTypeBool g)
int GetPartArrayID(const char *name)
~vtkExodusIIReader() override
int GetEdgeMapArrayStatus(const char *name)
void SetPartArrayStatus(const char *, int flag)
vtkExodusIIReaderPrivate * Metadata
int GetMaterialArrayStatus(int index)
int GetNumberOfEdgeSetResultArrays()
int GetElementResultArrayStatus(const char *name)
int GetNumberOfAssemblyArrays()
By default all assemblies are loaded.
const char * GetObjectName(int objectType, int objectIndex)
void SetAssemblyArrayStatus(const char *, int flag)
int GetNumberOfSideSetResultArrays()
int GetNumberOfNodeSetResultArrays()
int GetEdgeSetArrayStatus(const char *name)
void SetNodeSetResultArrayStatus(const char *name, int flag)
const char * GetGlobalResultArrayName(int index)
void SetMaterialArrayStatus(int index, int flag)
int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
This is called by the superclass.
static vtkInformationIntegerKey * GLOBAL_VARIABLE()
Exodus reader outputs global variables and global temporal variables, together with some other variab...
int GetNodeSetResultArrayStatus(const char *name)
virtual void SetGenerateGlobalElementIdArray(vtkTypeBool g)
void SetAllArrayStatus(int otype, int status)
int GetHierarchyArrayStatus(int index)
const char * GetFaceResultArrayName(int index)
vtkTypeBool GetGenerateObjectIdCellArray()
int GetNumberOfMaterialArrays()
By default all materials are loaded.
vtkTypeBool GetGenerateImplicitElementIdArray()
void ResetCache()
Clears out the cache entries.
virtual void SetMetadata(vtkExodusIIReaderPrivate *)
void SetMaterialArrayStatus(const char *, int flag)
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
This is called by the superclass.
void Reset()
Reset the user-specified parameters and flush internal arrays so that the reader state is just as it ...
double GetCacheSize()
Get the size of the cache in MiB.
virtual void SetDisplayType(int type)
static const char * GetGlobalEdgeIdArrayName()
static vtkExodusIIReader * New()
int GetNumberOfEntriesInObject(int objectType, int objectIndex)
const char * GetElementSetArrayName(int index)
int GetObjectStatus(int objectType, int objectIndex)
void SetSideSetArrayStatus(const char *name, int flag)
void SetNodeMapArrayStatus(const char *name, int flag)
static int GetIDHelper(const char *arrayName, vtkDataSet *data, int localID, int searchType)
void SetEdgeMapArrayStatus(const char *name, int flag)
void SetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex, int status)
const char * GetElementSetResultArrayName(int index)
const char * GetHierarchyArrayName(int arrayIdx)
vtkTimeStamp FileNameMTime
int GetAssemblyArrayStatus(const char *)
void SetModeShape(int val)
Convenience method to set the mode-shape which is same as this->SetTimeStep(val-1);.
int GetAssemblyArrayID(const char *name)
static const char * GetGlobalElementIdArrayName()
static int GetGlobalEdgeID(vtkDataSet *data, int localID)
void SetObjectArrayStatus(int objectType, int arrayIndex, int status)
void SetFaceMapArrayStatus(const char *name, int flag)
bool GetIgnoreFileTime()
int GetSideSetArrayStatus(const char *name)
void ResetSettings()
Reset the user-specified parameters to their default values.
const char * GetSideSetArrayName(int index)
const char * GetTitle()
Access to meta data generated by UpdateInformation.
int GetMaterialArrayID(const char *name)
void SetFaceResultArrayStatus(const char *name, int flag)
int GetObjectIndex(int objectType, int id)
int GetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName)
static int GetGlobalFaceID(vtkDataSet *data, int localID, int searchType)
const char * GetFaceMapArrayName(int index)
void SetObjectStatus(int objectType, int objectIndex, int status)
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...
void SetElementSetResultArrayStatus(const char *name, int flag)
void SetAssemblyArrayStatus(int index, int flag)
int GetObjectArrayIndex(int objectType, const char *arrayName)
static vtkInformationIntegerKey * GLOBAL_TEMPORAL_VARIABLE()
int GetNumberOfObjectAttributes(int objectType, int objectIndex)
By default attributes are not loaded.
void GetAllTimes(vtkInformationVector *)
int GetFaceSetArrayStatus(const char *name)
void SetHierarchyArrayStatus(int index, int flag)
int GetMaxNameLength()
Get the max_name_length in the file.
const char * GetFaceBlockArrayName(int index)
double GetModeShapeTime()
vtkTimeStamp XMLFileNameMTime
static const char * GetPedigreeNodeIdArrayName()
int GetEdgeResultArrayStatus(const char *name)
const char * GetObjectArrayName(int objectType, int arrayIndex)
const char * GetPartArrayName(int arrayIdx)
float GetDisplacementMagnitude()
virtual void SetGenerateObjectIdCellArray(vtkTypeBool g)
Extra cell data array that can be generated.
int GetTimeSeriesData(int ID, const char *vName, const char *vType, vtkFloatArray *result)
void SetObjectStatus(int objectType, const char *objectName, int status)
void SetObjectAttributeStatus(int objectType, int objectIndex, const char *attribName, int status)
const char * GetEdgeSetArrayName(int index)
static int GetGlobalNodeID(vtkDataSet *data, int localID)
int GetFaceMapArrayStatus(const char *name)
int GetFaceBlockArrayStatus(const char *name)
const char * GetMaterialArrayName(int arrayIdx)
virtual vtkIdType GetTotalNumberOfEdges()
virtual vtkMTimeType GetMetadataMTime()
Return the MTime of the internal data structure.
const char * GetElementBlockArrayName(int index)
bool FindXMLFile()
Returns true if the file given by XMLFileName exists.
void AdvertiseTimeSteps(vtkInformation *outputInfo)
Populates the TIME_STEPS and TIME_RANGE keys based on file metadata.
vtkTypeBool GetHasModeShapes()
void SetEdgeSetArrayStatus(const char *name, int flag)
static const char * GetGlobalNodeIdArrayName()
Extra point data array that can be generated.
virtual vtkIdType GetTotalNumberOfFaces()
int GetObjectId(int objectType, int objectIndex)
int GetNumberOfElementSetResultArrays()
const char * GetNodeSetResultArrayName(int index)
int GetNumberOfEdgesInFile()
void SetElementBlockArrayStatus(const char *name, int flag)
virtual void SetModeShapeTime(double phase)
Set/Get the time used to animate mode shapes.
const char * GetFaceSetArrayName(int index)
void SetFaceSetArrayStatus(const char *name, int flag)
void SetGlobalResultArrayStatus(const char *name, int flag)
vtkTypeBool GetGenerateGlobalNodeIdArray()
virtual void SetApplyDisplacements(vtkTypeBool d)
Geometric locations can include displacements.
virtual vtkIdType GetTotalNumberOfElements()
virtual void SetXMLFileName(const char *fname)
Specify file name of the xml file.
vtkMTimeType GetMTime() override
Return the object's MTime.
void SetHierarchyArrayStatus(const char *, int flag)
int GetNumberOfObjects(int objectType)
const char * GetObjectAttributeName(int objectType, int objectIndex, int attribIndex)
static const char * GetGlobalFaceIdArrayName()
static const char * GetObjectIdArrayName()
static const char * GetImplicitFaceIdArrayName()
virtual void SetIgnoreFileTime(bool flag)
When on, this option ignores the time values assigned to each time step in the file.
const char * GetNodeSetArrayName(int index)
int GetAssemblyArrayStatus(int index)
int GetObjectTypeFromName(const char *name)
vtkGraph * GetSIL()
SIL describes organization of/relationships between classifications eg.
const char * GetEdgeBlockArrayName(int index)
int GetElementBlockArrayStatus(const char *name)
int GetElementSetResultArrayStatus(const char *name)
int GetObjectAttributeIndex(int objectType, int objectIndex, const char *attribName)
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual void SetDisplacementMagnitude(float s)
int GetObjectAttributeStatus(int objectType, int objectIndex, int attribIndex)
int GetGlobalResultArrayStatus(const char *name)
virtual vtkIdType GetTotalNumberOfNodes()
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...
const char * GetObjectTypeName(int)
virtual void SetAnimateModeShapes(vtkTypeBool flag)
If this flag is on (the default) and HasModeShapes is also on, then this reader will report a continu...
virtual void SetGenerateImplicitElementIdArray(vtkTypeBool g)
const char * GetElementMapArrayName(int index)
const char * GetPartBlockInfo(int arrayIdx)
void SetPointResultArrayStatus(const char *name, int flag)
int GetVariableID(const char *type, const char *name)
Return the id of the type,name variable.
void SetNodeSetArrayStatus(const char *name, int flag)
int GetSideSetResultArrayStatus(const char *name)
static const char * GetImplicitElementIdArrayName()
void SetSqueezePoints(bool sp)
Should the reader output only points used by elements in the output mesh, or all the points.
static const char * GetPedigreeEdgeIdArrayName()
virtual void SetGenerateFileIdArray(vtkTypeBool f)
void SetFaceSetResultArrayStatus(const char *name, int flag)
int GetNumberOfFaceSetResultArrays()
void SetCacheSize(double CacheSize)
Set the size of the cache in MiB.
static int GetGlobalElementID(vtkDataSet *data, int localID, int searchType)
int GetElementSetArrayStatus(const char *name)
const char * GetAssemblyArrayName(int arrayIdx)
int GetNumberOfObjectArrayComponents(int objectType, int arrayIndex)
vtkTypeBool GetApplyDisplacements()
int GetObjectStatus(int objectType, const char *objectName)
int GetNumberOfElementResultArrays()
int GetObjectArrayStatus(int objectType, const char *arrayName)
void SetEdgeSetResultArrayStatus(const char *name, int flag)
static int GetGlobalElementID(vtkDataSet *data, int localID)
int GetNodeSetArrayStatus(const char *name)
int GetFaceSetResultArrayStatus(const char *name)
int GetPartArrayStatus(const char *)
void SetObjectArrayStatus(int objectType, const char *arrayName, int status)
const char * GetPointResultArrayName(int index)
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:36
Base class for graph data types.
Definition: vtkGraph.h:290
a simple class to control print indentation
Definition: vtkIndent.h:34
Key for integer values in vtkInformation.
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:40
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
Read Exodus II files (.exii)
represent and manipulate 3D points
Definition: vtkPoints.h:34
record modification and/or execution time
Definition: vtkTimeStamp.h:33
dataset represents arbitrary combinations of all possible cell types
@ type
Definition: vtkX3D.h:522
@ name
Definition: vtkX3D.h:225
@ index
Definition: vtkX3D.h:252
@ data
Definition: vtkX3D.h:321
int vtkTypeBool
Definition: vtkABI.h:69
int vtkIdType
Definition: vtkType.h:338
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:293