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 
199  virtual void SetDatabaseDirectory(VTK_FILEPATH const std::string&);
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
206  int IsDatabaseValid();
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
223 
230  char* GetTitle();
231 
237  int GetDimensionality();
238 
244  vtkIdType GetNumberOfNodes();
245 
254  vtkIdType GetNumberOfCells();
255 
266  vtkIdType GetNumberOfContinuumCells();
267 
273  vtkIdType GetNumberOfSolidCells();
274 
280  vtkIdType GetNumberOfThickShellCells();
281 
287  vtkIdType GetNumberOfShellCells();
288 
294  vtkIdType GetNumberOfRigidBodyCells();
295 
301  vtkIdType GetNumberOfRoadSurfaceCells();
302 
308  vtkIdType GetNumberOfBeamCells();
309 
315  vtkIdType GetNumberOfParticleCells();
316 
318 
323  vtkIdType GetNumberOfTimeSteps();
324  virtual void SetTimeStep(vtkIdType);
325  vtkIdType GetTimeStep();
326  double GetTimeValue(vtkIdType);
327  vtkGetVector2Macro(TimeStepRange, int);
328  vtkSetVector2Macro(TimeStepRange, int);
330 
332 
336  int GetNumberOfPointArrays();
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);
342  int GetNumberOfComponentsInPointArray(int arr);
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 
368  int GetNumberOfSolidArrays();
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 
376  int GetNumberOfComponentsInSolidArray(int a);
377  int GetNumberOfComponentsInSolidArray(const char* arrName);
378 
380 
384  int GetNumberOfThickShellArrays();
385  const char* GetThickShellArrayName(int);
386  virtual void SetThickShellArrayStatus(int arr, int status);
387  virtual void SetThickShellArrayStatus(const char* arrName, int status);
388  int GetThickShellArrayStatus(int arr);
389  int GetThickShellArrayStatus(const char* arrName);
391 
392  int GetNumberOfComponentsInThickShellArray(int a);
393  int GetNumberOfComponentsInThickShellArray(const char* arrName);
394 
396 
400  int GetNumberOfShellArrays();
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 
408  int GetNumberOfComponentsInShellArray(int a);
409  int GetNumberOfComponentsInShellArray(const char* arrName);
410 
412 
416  int GetNumberOfRigidBodyArrays();
417  const char* GetRigidBodyArrayName(int);
418  virtual void SetRigidBodyArrayStatus(int arr, int status);
419  virtual void SetRigidBodyArrayStatus(const char* arrName, int status);
420  int GetRigidBodyArrayStatus(int arr);
421  int GetRigidBodyArrayStatus(const char* arrName);
423 
424  int GetNumberOfComponentsInRigidBodyArray(int a);
425  int GetNumberOfComponentsInRigidBodyArray(const char* arrName);
426 
428 
432  int GetNumberOfRoadSurfaceArrays();
433  const char* GetRoadSurfaceArrayName(int);
434  virtual void SetRoadSurfaceArrayStatus(int arr, int status);
435  virtual void SetRoadSurfaceArrayStatus(const char* arrName, int status);
436  int GetRoadSurfaceArrayStatus(int arr);
437  int GetRoadSurfaceArrayStatus(const char* arrName);
439 
440  int GetNumberOfComponentsInRoadSurfaceArray(int a);
441  int GetNumberOfComponentsInRoadSurfaceArray(const char* arrName);
442 
444 
448  int GetNumberOfBeamArrays();
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 
456  int GetNumberOfComponentsInBeamArray(int a);
457  int GetNumberOfComponentsInBeamArray(const char* arrName);
458 
460 
464  int GetNumberOfParticleArrays();
465  const char* GetParticleArrayName(int);
466  virtual void SetParticleArrayStatus(int arr, int status);
467  virtual void SetParticleArrayStatus(const char* arrName, int status);
468  int GetParticleArrayStatus(int arr);
469  int GetParticleArrayStatus(const char* arrName);
471 
472  int GetNumberOfComponentsInParticleArray(int a);
473  int GetNumberOfComponentsInParticleArray(const char* arrName);
474 
476 
481  void SetDeformedMesh(vtkTypeBool);
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 
539  int GetNumberOfPartArrays();
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 
577  vtkLSDynaReader();
578  ~vtkLSDynaReader() override;
579 
588  int ReadHeaderInformation(int currentAdaptLevel);
589 
599  int ScanDatabaseTimeSteps();
600 
603 
605 
614  virtual int ReadTopology();
615  virtual int ReadNodes();
616  virtual int ReadPartSizes();
617  virtual int ReadConnectivityAndMaterial();
618  virtual int ReadUserIds();
619  virtual int ReadState(vtkIdType);
620  virtual int ReadNodeStateInfo(vtkIdType);
621  virtual int ReadCellStateInfo(vtkIdType);
622  virtual int ReadDeletion();
623  virtual int ReadSPHState(vtkIdType);
624  virtual int ComputeDeflectionAndUpdateGeometry(vtkUnstructuredGrid* grid);
626 
630  virtual void ResetPartInfo();
631 
636  virtual int ReadInputDeck();
637 
643  virtual int ReadPartTitlesFromRootFile();
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 
687  void ResetPartsCache();
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
virtual void SetThickShellArrayStatus(int arr, int status)
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...
vtkLSDynaPartCollection * Parts
const char * GetPartArrayName(int)
These methods allow you to load only selected parts of the input.
int GetNumberOfCellArrays(int cellType)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
int GetNumberOfPointArrays()
These methods allow you to load only selected subsets of the nodal variables defined over the mesh...
std::string GetFileName(const std::string &fileName) noexcept
Set the appropriate file name based on recognized user input.
int GetThickShellArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
const char * GetPointArrayName(int)
These methods allow you to load only selected subsets of the nodal variables defined over the mesh...
Store vtkAlgorithm input/output information.
int GetNumberOfComponentsInBeamArray(int a)
int GetNumberOfBeamArrays()
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 GetRoadSurfaceArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
Read LS-Dyna databases (d3plot)
vtkTypeBool DeformedMesh
Should deflected coordinates be used, or should the mesh remain undeflected? By default, this is true.
const char * GetParticleArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
const char * GetThickShellArrayName(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 SetRigidBodyArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
int GetNumberOfComponentsInSolidArray(int a)
int GetNumberOfThickShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
const char * GetSolidArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
int vtkIdType
Definition: vtkType.h:332
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
virtual void SetSolidArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
vtkTypeBool DeletedCellsAsGhostArray
Should cells marked as deleted be removed from the mesh? By default, this is true.
virtual void SetRoadSurfaceArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
static vtkMultiBlockDataSetAlgorithm * New()
int vtkTypeBool
Definition: vtkABI.h:69
int GetPointArrayStatus(int arr)
These methods allow you to load only selected subsets of the nodal 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...
int GetNumberOfParticleArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
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 GetCellArrayStatus(int cellType, int arr)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
int GetNumberOfPartArrays()
These methods allow you to load only selected parts of the input.
int GetNumberOfRoadSurfaceArrays()
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...
a simple class to control print indentation
Definition: vtkIndent.h:39
int GetNumberOfRigidBodyArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
int GetSolidArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
dataset represents arbitrary combinations of all possible cell types
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
int GetNumberOfShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkTypeBool RemoveDeletedCells
Should cells marked as deleted be removed from the mesh? By default, this is true.
dynamic, self-adjusting array of unsigned char
int GetNumberOfComponentsInShellArray(int a)
#define VTK_FILEPATH
int GetNumberOfComponentsInRigidBodyArray(int a)
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...
int GetPartArrayStatus(int arr)
These methods allow you to load only selected parts of the input.
int GetParticleArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
int GetNumberOfComponentsInThickShellArray(int a)
int GetBeamArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
virtual void SetBeamArrayStatus(int arr, int status)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
Store zero or more vtkInformation instances.
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...
const char * GetShellArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
char * InputDeck
The name of a file containing part names and IDs.
virtual void SetParticleArrayStatus(int arr, int status)
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.
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 GetNumberOfComponentsInRoadSurfaceArray(int a)
const char * GetBeamArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
int GetNumberOfComponentsInParticleArray(int a)
represent and manipulate 3D points
Definition: vtkPoints.h:39
const char * GetRoadSurfaceArrayName(int)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
int GetNumberOfComponentsInPointArray(int arr)
These methods allow you to load only selected subsets of the nodal variables defined over the mesh...
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
LSDynaMetaData * P