VTK  9.2.6
vtkLSDynaReader.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkLSDynaReader.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 
155 #ifndef vtkLSDynaReader_h
156 #define vtkLSDynaReader_h
157 
158 #include "vtkIOLSDynaModule.h" // For export macro
159 #include "vtkLegacy.h" // For VTK_LEGACY_REMOVE
161 #include <string> // for method signature
162 
163 class LSDynaMetaData;
165 class vtkPoints;
166 class vtkDataArray;
168 class vtkUnstructuredGrid;
169 
170 class VTKIOLSDYNA_EXPORT vtkLSDynaReader : public vtkMultiBlockDataSetAlgorithm
171 {
172 public:
174  void PrintSelf(ostream& os, vtkIndent indent) override;
175  static vtkLSDynaReader* New();
176 
181  void Dump(ostream& os);
182 
187  void DebugDump();
188 
192  virtual int CanReadFile(VTK_FILEPATH const char* fname);
193 
195 
200  virtual void SetDatabaseDirectory(VTK_FILEPATH const char*);
201 #ifdef VTK_LEGACY_REMOVE
202  VTK_FILEPATH std::string GetDatabaseDirectory();
203 #else
204  VTK_LEGACY(VTK_FILEPATH const char* GetDatabaseDirectory());
205 #endif
208 
210 
216  virtual void SetFileName(VTK_FILEPATH const std::string&);
217  virtual void SetFileName(VTK_FILEPATH const char*);
218 #ifdef VTK_LEGACY_REMOVE
220 #else
221  VTK_LEGACY(VTK_FILEPATH const char* GetFileName());
222 #endif
224 
230  char* GetTitle();
231 
238 
245 
255 
267 
274 
281 
288 
295 
302 
309 
316 
318 
324  virtual void SetTimeStep(vtkIdType);
327  vtkGetVector2Macro(TimeStepRange, int);
328  vtkSetVector2Macro(TimeStepRange, int);
330 
332 
337  const char* GetPointArrayName(int);
338  virtual void SetPointArrayStatus(int arr, int status);
339  virtual void SetPointArrayStatus(const char* arrName, int status);
340  int GetPointArrayStatus(int arr);
341  int GetPointArrayStatus(const char* arrName);
343  int GetNumberOfComponentsInPointArray(const char* arrName);
345 
347 
353  int GetNumberOfCellArrays(int cellType);
354  const char* GetCellArrayName(int cellType, int arr);
355  virtual void SetCellArrayStatus(int cellType, int arr, int status);
356  virtual void SetCellArrayStatus(int cellType, const char* arrName, int status);
357  int GetCellArrayStatus(int cellType, int arr);
358  int GetCellArrayStatus(int cellType, const char* arrName);
359  int GetNumberOfComponentsInCellArray(int cellType, int arr);
360  int GetNumberOfComponentsInCellArray(int cellType, const char* arrName);
362 
364 
369  const char* GetSolidArrayName(int);
370  virtual void SetSolidArrayStatus(int arr, int status);
371  virtual void SetSolidArrayStatus(const char* arrName, int status);
372  int GetSolidArrayStatus(int arr);
373  int GetSolidArrayStatus(const char* arrName);
375 
377  int GetNumberOfComponentsInSolidArray(const char* arrName);
378 
380 
385  const char* GetThickShellArrayName(int);
386  virtual void SetThickShellArrayStatus(int arr, int status);
387  virtual void SetThickShellArrayStatus(const char* arrName, int status);
389  int GetThickShellArrayStatus(const char* arrName);
391 
393  int GetNumberOfComponentsInThickShellArray(const char* arrName);
394 
396 
401  const char* GetShellArrayName(int);
402  virtual void SetShellArrayStatus(int arr, int status);
403  virtual void SetShellArrayStatus(const char* arrName, int status);
404  int GetShellArrayStatus(int arr);
405  int GetShellArrayStatus(const char* arrName);
407 
409  int GetNumberOfComponentsInShellArray(const char* arrName);
410 
412 
417  const char* GetRigidBodyArrayName(int);
418  virtual void SetRigidBodyArrayStatus(int arr, int status);
419  virtual void SetRigidBodyArrayStatus(const char* arrName, int status);
421  int GetRigidBodyArrayStatus(const char* arrName);
423 
425  int GetNumberOfComponentsInRigidBodyArray(const char* arrName);
426 
428 
433  const char* GetRoadSurfaceArrayName(int);
434  virtual void SetRoadSurfaceArrayStatus(int arr, int status);
435  virtual void SetRoadSurfaceArrayStatus(const char* arrName, int status);
437  int GetRoadSurfaceArrayStatus(const char* arrName);
439 
441  int GetNumberOfComponentsInRoadSurfaceArray(const char* arrName);
442 
444 
449  const char* GetBeamArrayName(int);
450  virtual void SetBeamArrayStatus(int arr, int status);
451  virtual void SetBeamArrayStatus(const char* arrName, int status);
452  int GetBeamArrayStatus(int arr);
453  int GetBeamArrayStatus(const char* arrName);
455 
457  int GetNumberOfComponentsInBeamArray(const char* arrName);
458 
460 
465  const char* GetParticleArrayName(int);
466  virtual void SetParticleArrayStatus(int arr, int status);
467  virtual void SetParticleArrayStatus(const char* arrName, int status);
469  int GetParticleArrayStatus(const char* arrName);
471 
473  int GetNumberOfComponentsInParticleArray(const char* arrName);
474 
476 
482  vtkGetMacro(DeformedMesh, vtkTypeBool);
483  vtkBooleanMacro(DeformedMesh, vtkTypeBool);
485 
487 
497  vtkSetMacro(RemoveDeletedCells, vtkTypeBool);
498  vtkGetMacro(RemoveDeletedCells, vtkTypeBool);
499  vtkBooleanMacro(RemoveDeletedCells, vtkTypeBool);
501 
503 
507  vtkSetMacro(DeletedCellsAsGhostArray, vtkTypeBool);
508  vtkGetMacro(DeletedCellsAsGhostArray, vtkTypeBool);
509  vtkBooleanMacro(DeletedCellsAsGhostArray, vtkTypeBool);
511 
513 
524  vtkSetStringMacro(InputDeck);
525  vtkGetStringMacro(InputDeck);
527 
529 
540  const char* GetPartArrayName(int);
541  virtual void SetPartArrayStatus(int arr, int status);
542  virtual void SetPartArrayStatus(const char* partName, int status);
543  int GetPartArrayStatus(int arr);
544  int GetPartArrayStatus(const char* partName);
546 
547 protected:
548  // holds all the parts and all the properties for each part
550 
556 
558 
565 
570  int TimeStepRange[2];
571 
575  char* InputDeck;
576 
578  ~vtkLSDynaReader() override;
579 
588  int ReadHeaderInformation(int currentAdaptLevel);
589 
600 
603 
605 
614  virtual int ReadTopology();
615  virtual int ReadNodes();
616  virtual int ReadPartSizes();
618  virtual int ReadUserIds();
619  virtual int ReadState(vtkIdType);
622  virtual int ReadDeletion();
623  virtual int ReadSPHState(vtkIdType);
626 
630  virtual void ResetPartInfo();
631 
636  virtual int ReadInputDeck();
637 
644 
650  virtual int ReadUserMaterialIds();
651 
653 
657  int ReadInputDeckXML(istream& deck);
658  int ReadInputDeckKeywords(istream& deck);
660 
665  int WriteInputDeckSummary(const char* fname);
666 
678  virtual void ReadDeletionArray(vtkUnsignedCharArray* arr, const int& pos, const int& size);
679 
683  virtual void ReadCellProperties(const int& type, const int& numTuples);
684 
686 
688 
689 private:
690  // Helper templated methods to optimize reading. We cast the entire buffer
691  // to a given type instead of casting each element to improve performance
692  template <typename T>
693  void FillDeletionArray(T* buffer, vtkUnsignedCharArray* arr, const vtkIdType& start,
694  const vtkIdType& numCells, const int& deathPos, const int& cellSize);
695 
696  template <int wordSize, typename T>
697  int FillTopology(T* buffer);
698 
699  template <typename T, int blockType, vtkIdType numWordsPerCell, vtkIdType cellLength>
700  void ReadBlockCellSizes();
701 
702  template <typename T>
703  int FillPartSizes();
704 
705  vtkLSDynaReader(const vtkLSDynaReader&) = delete;
706  void operator=(const vtkLSDynaReader&) = delete;
707 };
708 
709 inline void vtkLSDynaReader::SetPointArrayStatus(const char* arrName, int status)
710 {
711  for (int a = 0; a < this->GetNumberOfPointArrays(); ++a)
712  {
713  if (strcmp(arrName, this->GetPointArrayName(a)) == 0)
714  {
715  this->SetPointArrayStatus(a, status);
716  return;
717  }
718  }
719  vtkWarningMacro("Point array \"" << arrName << "\" does not exist");
720 }
721 
722 inline int vtkLSDynaReader::GetPointArrayStatus(const char* arrName)
723 {
724  for (int a = 0; a < this->GetNumberOfPointArrays(); ++a)
725  {
726  if (strcmp(arrName, this->GetPointArrayName(a)) == 0)
727  {
728  return this->GetPointArrayStatus(a);
729  }
730  }
731  // vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
732  return 0;
733 }
734 
736 {
737  for (int a = 0; a < this->GetNumberOfPointArrays(); ++a)
738  {
739  if (strcmp(arrName, this->GetPointArrayName(a)) == 0)
740  {
741  return this->GetNumberOfComponentsInPointArray(a);
742  }
743  }
744  // vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
745  return 0;
746 }
747 
748 inline void vtkLSDynaReader::SetCellArrayStatus(int cellType, const char* arrName, int status)
749 {
750  for (int a = 0; a < this->GetNumberOfCellArrays(cellType); ++a)
751  {
752  if (strcmp(arrName, this->GetCellArrayName(cellType, a)) == 0)
753  {
754  this->SetCellArrayStatus(cellType, a, status);
755  return;
756  }
757  }
758  vtkWarningMacro("Cell array \"" << arrName << "\" (type " << cellType << ") does not exist");
759 }
760 
761 inline int vtkLSDynaReader::GetCellArrayStatus(int cellType, const char* arrName)
762 {
763  for (int a = 0; a < this->GetNumberOfCellArrays(cellType); ++a)
764  {
765  if (strcmp(arrName, this->GetCellArrayName(cellType, a)) == 0)
766  {
767  return this->GetCellArrayStatus(cellType, a);
768  }
769  }
770  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
771  return 0;
772 }
773 
774 inline int vtkLSDynaReader::GetNumberOfComponentsInCellArray(int cellType, const char* arrName)
775 {
776  for (int a = 0; a < this->GetNumberOfCellArrays(cellType); ++a)
777  {
778  if (strcmp(arrName, this->GetCellArrayName(cellType, a)) == 0)
779  {
780  return this->GetNumberOfComponentsInCellArray(cellType, a);
781  }
782  }
783  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
784  return 0;
785 }
786 
787 inline void vtkLSDynaReader::SetSolidArrayStatus(const char* arrName, int status)
788 {
789  for (int a = 0; a < this->GetNumberOfSolidArrays(); ++a)
790  {
791  if (strcmp(arrName, this->GetSolidArrayName(a)) == 0)
792  {
793  this->SetSolidArrayStatus(a, status);
794  return;
795  }
796  }
797  vtkWarningMacro("Solid array \"" << arrName << "\" does not exist");
798 }
799 
800 inline int vtkLSDynaReader::GetSolidArrayStatus(const char* arrName)
801 {
802  for (int a = 0; a < this->GetNumberOfSolidArrays(); ++a)
803  {
804  if (strcmp(arrName, this->GetSolidArrayName(a)) == 0)
805  {
806  return this->GetSolidArrayStatus(a);
807  }
808  }
809  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
810  return 0;
811 }
812 
814 {
815  for (int a = 0; a < this->GetNumberOfSolidArrays(); ++a)
816  {
817  if (strcmp(arrName, this->GetSolidArrayName(a)) == 0)
818  {
819  return this->GetNumberOfComponentsInSolidArray(a);
820  }
821  }
822  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
823  return 0;
824 }
825 
826 inline void vtkLSDynaReader::SetThickShellArrayStatus(const char* arrName, int status)
827 {
828  for (int a = 0; a < this->GetNumberOfThickShellArrays(); ++a)
829  {
830  if (strcmp(arrName, this->GetThickShellArrayName(a)) == 0)
831  {
832  this->SetThickShellArrayStatus(a, status);
833  return;
834  }
835  }
836  vtkWarningMacro("Thick shell array \"" << arrName << "\" does not exist");
837 }
838 
839 inline int vtkLSDynaReader::GetThickShellArrayStatus(const char* arrName)
840 {
841  for (int a = 0; a < this->GetNumberOfThickShellArrays(); ++a)
842  {
843  if (strcmp(arrName, this->GetThickShellArrayName(a)) == 0)
844  {
845  return this->GetThickShellArrayStatus(a);
846  }
847  }
848  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
849  return 0;
850 }
851 
853 {
854  for (int a = 0; a < this->GetNumberOfThickShellArrays(); ++a)
855  {
856  if (strcmp(arrName, this->GetThickShellArrayName(a)) == 0)
857  {
859  }
860  }
861  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
862  return 0;
863 }
864 
865 inline void vtkLSDynaReader::SetShellArrayStatus(const char* arrName, int status)
866 {
867  for (int a = 0; a < this->GetNumberOfShellArrays(); ++a)
868  {
869  if (strcmp(arrName, this->GetShellArrayName(a)) == 0)
870  {
871  this->SetShellArrayStatus(a, status);
872  return;
873  }
874  }
875  vtkWarningMacro("Shell array \"" << arrName << "\" does not exist");
876 }
877 
878 inline int vtkLSDynaReader::GetShellArrayStatus(const char* arrName)
879 {
880  for (int a = 0; a < this->GetNumberOfShellArrays(); ++a)
881  {
882  if (strcmp(arrName, this->GetShellArrayName(a)) == 0)
883  {
884  return this->GetShellArrayStatus(a);
885  }
886  }
887  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
888  return 0;
889 }
890 
892 {
893  for (int a = 0; a < this->GetNumberOfShellArrays(); ++a)
894  {
895  if (strcmp(arrName, this->GetShellArrayName(a)) == 0)
896  {
897  return this->GetNumberOfComponentsInShellArray(a);
898  }
899  }
900  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
901  return 0;
902 }
903 
904 inline void vtkLSDynaReader::SetBeamArrayStatus(const char* arrName, int status)
905 {
906  for (int a = 0; a < this->GetNumberOfBeamArrays(); ++a)
907  {
908  if (strcmp(arrName, this->GetBeamArrayName(a)) == 0)
909  {
910  this->SetBeamArrayStatus(a, status);
911  return;
912  }
913  }
914  vtkWarningMacro("Beam array \"" << arrName << "\" does not exist");
915 }
916 
917 inline int vtkLSDynaReader::GetBeamArrayStatus(const char* arrName)
918 {
919  for (int a = 0; a < this->GetNumberOfBeamArrays(); ++a)
920  {
921  if (strcmp(arrName, this->GetBeamArrayName(a)) == 0)
922  {
923  return this->GetBeamArrayStatus(a);
924  }
925  }
926  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
927  return 0;
928 }
929 
931 {
932  for (int a = 0; a < this->GetNumberOfBeamArrays(); ++a)
933  {
934  if (strcmp(arrName, this->GetBeamArrayName(a)) == 0)
935  {
936  return this->GetNumberOfComponentsInBeamArray(a);
937  }
938  }
939  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
940  return 0;
941 }
942 
943 inline void vtkLSDynaReader::SetParticleArrayStatus(const char* arrName, int status)
944 {
945  for (int a = 0; a < this->GetNumberOfParticleArrays(); ++a)
946  {
947  if (strcmp(arrName, this->GetParticleArrayName(a)) == 0)
948  {
949  this->SetParticleArrayStatus(a, status);
950  return;
951  }
952  }
953  vtkWarningMacro("Particle array \"" << arrName << "\" does not exist");
954 }
955 
956 inline int vtkLSDynaReader::GetParticleArrayStatus(const char* arrName)
957 {
958  for (int a = 0; a < this->GetNumberOfParticleArrays(); ++a)
959  {
960  if (strcmp(arrName, this->GetParticleArrayName(a)) == 0)
961  {
962  return this->GetParticleArrayStatus(a);
963  }
964  }
965  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
966  return 0;
967 }
968 
970 {
971  for (int a = 0; a < this->GetNumberOfParticleArrays(); ++a)
972  {
973  if (strcmp(arrName, this->GetParticleArrayName(a)) == 0)
974  {
975  return this->GetNumberOfComponentsInParticleArray(a);
976  }
977  }
978  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
979  return 0;
980 }
981 
982 inline void vtkLSDynaReader::SetRigidBodyArrayStatus(const char* arrName, int status)
983 {
984  for (int a = 0; a < this->GetNumberOfRigidBodyArrays(); ++a)
985  {
986  if (strcmp(arrName, this->GetRigidBodyArrayName(a)) == 0)
987  {
988  this->SetRigidBodyArrayStatus(a, status);
989  return;
990  }
991  }
992  vtkWarningMacro("Rigid body array \"" << arrName << "\" does not exist");
993 }
994 
995 inline int vtkLSDynaReader::GetRigidBodyArrayStatus(const char* arrName)
996 {
997  for (int a = 0; a < this->GetNumberOfRigidBodyArrays(); ++a)
998  {
999  if (strcmp(arrName, this->GetRigidBodyArrayName(a)) == 0)
1000  {
1001  return this->GetRigidBodyArrayStatus(a);
1002  }
1003  }
1004  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1005  return 0;
1006 }
1007 
1009 {
1010  for (int a = 0; a < this->GetNumberOfRigidBodyArrays(); ++a)
1011  {
1012  if (strcmp(arrName, this->GetRigidBodyArrayName(a)) == 0)
1013  {
1014  return this->GetNumberOfComponentsInRigidBodyArray(a);
1015  }
1016  }
1017  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1018  return 0;
1019 }
1020 
1021 inline void vtkLSDynaReader::SetRoadSurfaceArrayStatus(const char* arrName, int status)
1022 {
1023  for (int a = 0; a < this->GetNumberOfRoadSurfaceArrays(); ++a)
1024  {
1025  if (strcmp(arrName, this->GetRoadSurfaceArrayName(a)) == 0)
1026  {
1027  this->SetRoadSurfaceArrayStatus(a, status);
1028  return;
1029  }
1030  }
1031  vtkWarningMacro("Road surface array \"" << arrName << "\" does not exist");
1032 }
1033 
1034 inline int vtkLSDynaReader::GetRoadSurfaceArrayStatus(const char* arrName)
1035 {
1036  for (int a = 0; a < this->GetNumberOfRoadSurfaceArrays(); ++a)
1037  {
1038  if (strcmp(arrName, this->GetRoadSurfaceArrayName(a)) == 0)
1039  {
1040  return this->GetRoadSurfaceArrayStatus(a);
1041  }
1042  }
1043  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1044  return 0;
1045 }
1046 
1048 {
1049  for (int a = 0; a < this->GetNumberOfRoadSurfaceArrays(); ++a)
1050  {
1051  if (strcmp(arrName, this->GetRoadSurfaceArrayName(a)) == 0)
1052  {
1054  }
1055  }
1056  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1057  return 0;
1058 }
1059 
1060 inline void vtkLSDynaReader::SetPartArrayStatus(const char* arrName, int status)
1061 {
1062  for (int a = 0; a < this->GetNumberOfPartArrays(); ++a)
1063  {
1064  if (strcmp(arrName, this->GetPartArrayName(a)) == 0)
1065  {
1066  this->SetPartArrayStatus(a, status);
1067  return;
1068  }
1069  }
1070  vtkWarningMacro("Part \"" << arrName << "\" does not exist");
1071 }
1072 
1073 inline int vtkLSDynaReader::GetPartArrayStatus(const char* partName)
1074 {
1075  for (int a = 0; a < this->GetNumberOfPartArrays(); ++a)
1076  {
1077  if (strcmp(partName, this->GetPartArrayName(a)) == 0)
1078  {
1079  return this->GetPartArrayStatus(a);
1080  }
1081  }
1082  // vtkWarningMacro( "PartArray \"" << partName << "\" does not exist" );
1083  return 0;
1084 }
1085 
1086 #endif // vtkLSDynaReader_h
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:165
a simple class to control print indentation
Definition: vtkIndent.h:119
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
Read LS-Dyna databases (d3plot)
virtual void SetDatabaseDirectory(VTK_FILEPATH const char *)
Get/Set the directory containing the LS-Dyna database and determine whether it is valid.
int GetNumberOfParticleArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetRigidBodyArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadSPHState(vtkIdType)
These functions read various parts of the database.
virtual int ReadInputDeck()
Called from within ReadHeaderInformation() to read part names associated with material IDs.
virtual int ReadCellStateInfo(vtkIdType)
These functions read various parts of the database.
const char * GetPointArrayName(int)
These methods allow you to load only selected subsets of the nodal variables defined over the mesh.
void Dump(ostream &os)
Print out more complete information about the dataset (and less complete information about the VTK hi...
int GetRoadSurfaceArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadPartTitlesFromRootFile()
Called from within ReadHeaderInformation to read part names from the end of the first d3plot file.
vtkIdType GetNumberOfCells()
Retrieve the number of cells of a given type in the database.
int GetNumberOfComponentsInParticleArray(int a)
int GetParticleArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadUserIds()
These functions read various parts of the database.
virtual void SetThickShellArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkIdType GetNumberOfShellCells()
Retrieve the number of cells of a given type in the database.
int ReadInputDeckKeywords(istream &deck)
ReadInputDeck determines the type of file (keyword or XML summary) and calls one of these two routine...
const char * GetParticleArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetNumberOfComponentsInCellArray(int cellType, int arr)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
virtual void SetShellArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetNumberOfComponentsInBeamArray(int a)
int ReadHeaderInformation(int currentAdaptLevel)
This function populates the reader's private dictionary with information about the database.
virtual void SetDatabaseDirectory(VTK_FILEPATH const std::string &)
Get/Set the directory containing the LS-Dyna database and determine whether it is valid.
char * InputDeck
The name of a file containing part names and IDs.
virtual int CanReadFile(VTK_FILEPATH const char *fname)
Determine if the file can be read with this reader.
virtual void SetSolidArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
VTK_FILEPATH const char * GetDatabaseDirectory()
Get/Set the directory containing the LS-Dyna database and determine whether it is valid.
void ResetPartsCache()
virtual int ReadUserMaterialIds()
Called from within ReadHeaderInformation() to read arbitrary material IDs (if present) or manufacture...
int GetThickShellArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetNumberOfSolidArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetBeamArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadNodeStateInfo(vtkIdType)
These functions read various parts of the database.
vtkLSDynaPartCollection * Parts
void DebugDump()
A routine to call Dump() from within a lame debugger that won't properly pass a C++ iostream object l...
int GetNumberOfRigidBodyArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadState(vtkIdType)
These functions read various parts of the database.
int GetNumberOfPartArrays()
These methods allow you to load only selected parts of the input.
vtkIdType GetNumberOfRigidBodyCells()
Retrieve the number of cells of a given type in the database.
const char * GetPartArrayName(int)
These methods allow you to load only selected parts of the input.
int GetNumberOfComponentsInPointArray(int arr)
These methods allow you to load only selected subsets of the nodal variables defined over the mesh.
vtkTypeBool DeformedMesh
Should deflected coordinates be used, or should the mesh remain undeflected? By default,...
virtual void ReadDeletionArray(vtkUnsignedCharArray *arr, const int &pos, const int &size)
Read an array of deletion data.
int WriteInputDeckSummary(const char *fname)
ReadInputDeckKeywords calls this function if it was successful in reading part names for materials.
int GetDimensionality()
Retrieve the dimension of points in the database.
vtkIdType GetNumberOfThickShellCells()
Retrieve the number of cells of a given type in the database.
virtual void SetParticleArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
VTK_FILEPATH const char * GetFileName()
Get/Set the filename.
int GetNumberOfShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetShellArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
const char * GetRigidBodyArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
~vtkLSDynaReader() override
const char * GetCellArrayName(int cellType, int arr)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
virtual void SetPointArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the nodal variables defined over the mesh.
int GetNumberOfComponentsInRigidBodyArray(int a)
virtual void SetFileName(VTK_FILEPATH const char *)
Get/Set the filename.
int GetNumberOfThickShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
double GetTimeValue(vtkIdType)
Retrieve information about the time extents of the LS-Dyna database.
const char * GetBeamArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetNumberOfCellArrays(int cellType)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
int GetNumberOfRoadSurfaceArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadPartSizes()
These functions read various parts of the database.
virtual void SetBeamArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int ReadInputDeckXML(istream &deck)
ReadInputDeck determines the type of file (keyword or XML summary) and calls one of these two routine...
vtkIdType GetTimeStep()
Retrieve information about the time extents of the LS-Dyna database.
int IsDatabaseValid()
Get/Set the directory containing the LS-Dyna database and determine whether it is valid.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkIdType GetNumberOfParticleCells()
Retrieve the number of cells of a given type in the database.
int GetNumberOfBeamArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual void SetPartArrayStatus(int arr, int status)
These methods allow you to load only selected parts of the input.
vtkTypeBool DeletedCellsAsGhostArray
Should cells marked as deleted be removed from the mesh? By default, this is true.
char * GetTitle()
The title of the database is a 40 or 80 character text description stored at the front of a d3plot fi...
virtual int ReadConnectivityAndMaterial()
These functions read various parts of the database.
virtual void ResetPartInfo()
Resets the Part information to the default state.
virtual void SetFileName(VTK_FILEPATH const std::string &)
Get/Set the filename.
virtual int ReadNodes()
These functions read various parts of the database.
vtkIdType GetNumberOfNodes()
Retrieve the number of points in the database.
const char * GetSolidArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual void SetRoadSurfaceArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
This is called by the superclass.
virtual int ReadTopology()
These functions read various parts of the database.
int GetNumberOfComponentsInRoadSurfaceArray(int a)
int GetNumberOfComponentsInSolidArray(int a)
int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
This is called by the superclass.
int GetNumberOfPointArrays()
These methods allow you to load only selected subsets of the nodal variables defined over the mesh.
virtual void SetCellArrayStatus(int cellType, int arr, int status)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
int GetNumberOfComponentsInThickShellArray(int a)
const char * GetThickShellArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ComputeDeflectionAndUpdateGeometry(vtkUnstructuredGrid *grid)
These functions read various parts of the database.
vtkIdType GetNumberOfSolidCells()
Retrieve the number of cells of a given type in the database.
LSDynaMetaData * P
virtual void ReadCellProperties(const int &type, const int &numTuples)
Read all the cell properties of a given part type.
int ScanDatabaseTimeSteps()
This function scans the list of files in the database and bookmarks the start of each time step's sta...
const char * GetRoadSurfaceArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkIdType GetNumberOfTimeSteps()
Retrieve information about the time extents of the LS-Dyna database.
int GetCellArrayStatus(int cellType, int arr)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
int GetPointArrayStatus(int arr)
These methods allow you to load only selected subsets of the nodal variables defined over the mesh.
vtkIdType GetNumberOfRoadSurfaceCells()
Retrieve the number of cells of a given type in the database.
vtkIdType GetNumberOfBeamCells()
Retrieve the number of cells of a given type in the database.
int GetNumberOfComponentsInShellArray(int a)
virtual void SetTimeStep(vtkIdType)
Retrieve information about the time extents of the LS-Dyna database.
vtkTypeBool RemoveDeletedCells
Should cells marked as deleted be removed from the mesh? By default, this is true.
int GetSolidArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual void SetRigidBodyArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkIdType GetNumberOfContinuumCells()
Retrieve the number of cells of a given type in the database.
const char * GetShellArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
void SetDeformedMesh(vtkTypeBool)
Should deflected coordinates be used, or should the mesh remain undeflected? By default,...
virtual int ReadDeletion()
These functions read various parts of the database.
int GetPartArrayStatus(int arr)
These methods allow you to load only selected parts of the input.
static vtkLSDynaReader * New()
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
represent and manipulate 3D points
Definition: vtkPoints.h:149
dynamic, self-adjusting array of unsigned char
dataset represents arbitrary combinations of all possible cell types
@ type
Definition: vtkX3D.h:522
@ size
Definition: vtkX3D.h:259
@ string
Definition: vtkX3D.h:496
std::string GetFileName(const std::string &fileName) noexcept
Set the appropriate file name based on recognized user input.
int vtkTypeBool
Definition: vtkABI.h:69
int vtkIdType
Definition: vtkType.h:332
#define VTK_FILEPATH