VTK
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 
151 #ifndef vtkLSDynaReader_h
152 #define vtkLSDynaReader_h
153 
154 #include "vtkIOLSDynaModule.h" // For export macro
156 
157 class LSDynaMetaData;
159 class vtkPoints;
160 class vtkDataArray;
162 class vtkUnstructuredGrid;
163 
164 class VTKIOLSDYNA_EXPORT vtkLSDynaReader : public vtkMultiBlockDataSetAlgorithm
165 {
166 public:
168  void PrintSelf(ostream &os, vtkIndent indent) override;
169  static vtkLSDynaReader *New();
170 
175  void Dump( ostream &os );
176 
181  void DebugDump();
182 
186  virtual int CanReadFile( const char* fname );
187 
189 
193  virtual void SetDatabaseDirectory( const char* );
194  const char* GetDatabaseDirectory();
195  int IsDatabaseValid();
197 
199 
205  virtual void SetFileName( const char* );
206  const char* GetFileName();
208 
214  char* GetTitle();
215 
221  int GetDimensionality();
222 
228  vtkIdType GetNumberOfNodes();
229 
238  vtkIdType GetNumberOfCells();
239 
250  vtkIdType GetNumberOfContinuumCells();
251 
257  vtkIdType GetNumberOfSolidCells();
258 
264  vtkIdType GetNumberOfThickShellCells();
265 
271  vtkIdType GetNumberOfShellCells();
272 
278  vtkIdType GetNumberOfRigidBodyCells();
279 
285  vtkIdType GetNumberOfRoadSurfaceCells();
286 
291  vtkIdType GetNumberOfBeamCells();
292 
298  vtkIdType GetNumberOfParticleCells();
299 
301 
306  vtkIdType GetNumberOfTimeSteps();
307  virtual void SetTimeStep( vtkIdType );
308  vtkIdType GetTimeStep();
309  double GetTimeValue( vtkIdType );
310  vtkGetVector2Macro(TimeStepRange,int);
311  vtkSetVector2Macro(TimeStepRange,int);
313 
315 
319  int GetNumberOfPointArrays();
320  const char* GetPointArrayName(int);
321  virtual void SetPointArrayStatus( int arr, int status );
322  virtual void SetPointArrayStatus( const char* arrName, int status );
323  int GetPointArrayStatus( int arr );
324  int GetPointArrayStatus( const char* arrName );
325  int GetNumberOfComponentsInPointArray( int arr );
326  int GetNumberOfComponentsInPointArray( const char* arrName );
328 
330 
336  int GetNumberOfCellArrays( int cellType );
337  const char* GetCellArrayName( int cellType, int arr );
338  virtual void SetCellArrayStatus( int cellType, int arr, int status );
339  virtual void SetCellArrayStatus( int cellType, const char* arrName, int status );
340  int GetCellArrayStatus( int cellType, int arr );
341  int GetCellArrayStatus( int cellType, const char* arrName );
342  int GetNumberOfComponentsInCellArray( int cellType, int arr );
343  int GetNumberOfComponentsInCellArray( int cellType, const char* arrName );
345 
347 
351  int GetNumberOfSolidArrays();
352  const char* GetSolidArrayName(int);
353  virtual void SetSolidArrayStatus( int arr, int status );
354  virtual void SetSolidArrayStatus( const char* arrName, int status );
355  int GetSolidArrayStatus( int arr );
356  int GetSolidArrayStatus( const char* arrName );
358 
359  int GetNumberOfComponentsInSolidArray( int a );
360  int GetNumberOfComponentsInSolidArray( const char* arrName );
361 
363 
367  int GetNumberOfThickShellArrays();
368  const char* GetThickShellArrayName(int);
369  virtual void SetThickShellArrayStatus( int arr, int status );
370  virtual void SetThickShellArrayStatus( const char* arrName, int status );
371  int GetThickShellArrayStatus( int arr );
372  int GetThickShellArrayStatus( const char* arrName );
374 
375  int GetNumberOfComponentsInThickShellArray( int a );
376  int GetNumberOfComponentsInThickShellArray( const char* arrName );
377 
379 
383  int GetNumberOfShellArrays();
384  const char* GetShellArrayName(int);
385  virtual void SetShellArrayStatus( int arr, int status );
386  virtual void SetShellArrayStatus( const char* arrName, int status );
387  int GetShellArrayStatus( int arr );
388  int GetShellArrayStatus( const char* arrName );
390 
391  int GetNumberOfComponentsInShellArray( int a );
392  int GetNumberOfComponentsInShellArray( const char* arrName );
393 
395 
399  int GetNumberOfRigidBodyArrays();
400  const char* GetRigidBodyArrayName(int);
401  virtual void SetRigidBodyArrayStatus( int arr, int status );
402  virtual void SetRigidBodyArrayStatus( const char* arrName, int status );
403  int GetRigidBodyArrayStatus( int arr );
404  int GetRigidBodyArrayStatus( const char* arrName );
406 
407  int GetNumberOfComponentsInRigidBodyArray( int a );
408  int GetNumberOfComponentsInRigidBodyArray( const char* arrName );
409 
411 
415  int GetNumberOfRoadSurfaceArrays();
416  const char* GetRoadSurfaceArrayName(int);
417  virtual void SetRoadSurfaceArrayStatus( int arr, int status );
418  virtual void SetRoadSurfaceArrayStatus( const char* arrName, int status );
419  int GetRoadSurfaceArrayStatus( int arr );
420  int GetRoadSurfaceArrayStatus( const char* arrName );
422 
423  int GetNumberOfComponentsInRoadSurfaceArray( int a );
424  int GetNumberOfComponentsInRoadSurfaceArray( const char* arrName );
425 
427 
431  int GetNumberOfBeamArrays();
432  const char* GetBeamArrayName(int);
433  virtual void SetBeamArrayStatus( int arr, int status );
434  virtual void SetBeamArrayStatus( const char* arrName, int status );
435  int GetBeamArrayStatus( int arr );
436  int GetBeamArrayStatus( const char* arrName );
438 
439  int GetNumberOfComponentsInBeamArray( int a );
440  int GetNumberOfComponentsInBeamArray( const char* arrName );
441 
443 
447  int GetNumberOfParticleArrays();
448  const char* GetParticleArrayName(int);
449  virtual void SetParticleArrayStatus( int arr, int status );
450  virtual void SetParticleArrayStatus( const char* arrName, int status );
451  int GetParticleArrayStatus( int arr );
452  int GetParticleArrayStatus( const char* arrName );
454 
455  int GetNumberOfComponentsInParticleArray( int a );
456  int GetNumberOfComponentsInParticleArray( const char* arrName );
457 
459 
464  void SetDeformedMesh(vtkTypeBool);
465  vtkGetMacro(DeformedMesh,vtkTypeBool);
466  vtkBooleanMacro(DeformedMesh,vtkTypeBool);
468 
470 
480  vtkSetMacro(RemoveDeletedCells,vtkTypeBool);
481  vtkGetMacro(RemoveDeletedCells,vtkTypeBool);
482  vtkBooleanMacro(RemoveDeletedCells,vtkTypeBool);
484 
486 
490  vtkSetMacro(DeletedCellsAsGhostArray,vtkTypeBool);
491  vtkGetMacro(DeletedCellsAsGhostArray,vtkTypeBool);
492  vtkBooleanMacro(DeletedCellsAsGhostArray,vtkTypeBool);
494 
496 
507  vtkSetStringMacro(InputDeck);
508  vtkGetStringMacro(InputDeck);
510 
512 
522  int GetNumberOfPartArrays();
523  const char* GetPartArrayName(int);
524  virtual void SetPartArrayStatus( int arr, int status );
525  virtual void SetPartArrayStatus( const char* partName, int status );
526  int GetPartArrayStatus( int arr );
527  int GetPartArrayStatus( const char* partName );
529 
530 protected:
531  //holds all the parts and all the properties for each part
533 
539 
541 
548 
553  int TimeStepRange[2];
554 
558  char* InputDeck;
559 
560  vtkLSDynaReader();
561  ~vtkLSDynaReader() override;
562 
571  int ReadHeaderInformation( int currentAdaptLevel );
572 
582  int ScanDatabaseTimeSteps();
583 
586 
588 
597  virtual int ReadTopology();
598  virtual int ReadNodes();
599  virtual int ReadPartSizes();
600  virtual int ReadConnectivityAndMaterial();
601  virtual int ReadUserIds();
602  virtual int ReadState( vtkIdType );
603  virtual int ReadNodeStateInfo( vtkIdType );
604  virtual int ReadCellStateInfo( vtkIdType );
605  virtual int ReadDeletion();
606  virtual int ReadSPHState( vtkIdType );
607  virtual int ComputeDeflectionAndUpdateGeometry(vtkUnstructuredGrid* grid);
609 
613  virtual void ResetPartInfo();
614 
619  virtual int ReadInputDeck();
620 
626  virtual int ReadPartTitlesFromRootFile();
627 
633  virtual int ReadUserMaterialIds();
634 
636 
640  int ReadInputDeckXML( ifstream& deck );
641  int ReadInputDeckKeywords( ifstream& deck );
643 
648  int WriteInputDeckSummary( const char* fname );
649 
661  virtual void ReadDeletionArray(vtkUnsignedCharArray* arr, const int& pos, const int& size);
662 
666  virtual void ReadCellProperties(const int& type,const int& numTuples);
667 
669 
670  void ResetPartsCache();
671 private:
672 
673  //Helper templated methods to optimze reading. We cast the entire buffer
674  //to a given type instead of casting each element to improve performance
675  template<typename T>
676  void FillDeletionArray(T* buffer, vtkUnsignedCharArray* arr, const vtkIdType& start, const vtkIdType& numCells,
677  const int& deathPos, const int& cellSize);
678 
679  template<int wordSize, typename T>
680  int FillTopology(T* buffer);
681 
682  template<typename T, int blockType, vtkIdType numWordsPerCell, vtkIdType cellLength>
683  void ReadBlockCellSizes();
684 
685  template<typename T>
686  int FillPartSizes();
687 
688  vtkLSDynaReader( const vtkLSDynaReader& ) = delete;
689  void operator = ( const vtkLSDynaReader& ) = delete;
690 };
691 
692 inline void vtkLSDynaReader::SetPointArrayStatus( const char* arrName, int status )
693 {
694  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
695  {
696  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
697  {
698  this->SetPointArrayStatus( a, status );
699  return;
700  }
701  }
702  vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
703 }
704 
705 inline int vtkLSDynaReader::GetPointArrayStatus( const char* arrName )
706 {
707  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
708  {
709  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
710  {
711  return this->GetPointArrayStatus( a );
712  }
713  }
714  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
715  return 0;
716 }
717 
718 inline int vtkLSDynaReader::GetNumberOfComponentsInPointArray( const char* arrName )
719 {
720  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
721  {
722  if ( strcmp( arrName, this->GetPointArrayName( a ) ) == 0 )
723  {
724  return this->GetNumberOfComponentsInPointArray( a );
725  }
726  }
727  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
728  return 0;
729 }
730 
731 inline void vtkLSDynaReader::SetCellArrayStatus( int cellType, const char* arrName, int status )
732 {
733  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
734  {
735  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
736  {
737  this->SetCellArrayStatus( cellType, a, status );
738  return;
739  }
740  }
741  vtkWarningMacro( "Cell array \"" << arrName << "\" (type " << cellType << ") does not exist" );
742 }
743 
744 inline int vtkLSDynaReader::GetCellArrayStatus( int cellType, const char* arrName )
745 {
746  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
747  {
748  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
749  {
750  return this->GetCellArrayStatus( cellType, a );
751  }
752  }
753  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
754  return 0;
755 }
756 
757 inline int vtkLSDynaReader::GetNumberOfComponentsInCellArray( int cellType, const char* arrName )
758 {
759  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
760  {
761  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
762  {
763  return this->GetNumberOfComponentsInCellArray( cellType, a );
764  }
765  }
766  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
767  return 0;
768 }
769 
770 inline void vtkLSDynaReader::SetSolidArrayStatus( const char* arrName, int status )
771 {
772  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
773  {
774  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
775  {
776  this->SetSolidArrayStatus( a, status );
777  return;
778  }
779  }
780  vtkWarningMacro( "Solid array \"" << arrName << "\" does not exist" );
781 }
782 
783 inline int vtkLSDynaReader::GetSolidArrayStatus( const char* arrName )
784 {
785  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
786  {
787  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
788  {
789  return this->GetSolidArrayStatus( a );
790  }
791  }
792  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
793  return 0;
794 }
795 
796 inline int vtkLSDynaReader::GetNumberOfComponentsInSolidArray( const char* arrName )
797 {
798  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
799  {
800  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
801  {
802  return this->GetNumberOfComponentsInSolidArray( a );
803  }
804  }
805  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
806  return 0;
807 }
808 
809 inline void vtkLSDynaReader::SetThickShellArrayStatus( const char* arrName, int status )
810 {
811  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
812  {
813  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
814  {
815  this->SetThickShellArrayStatus( a, status );
816  return;
817  }
818  }
819  vtkWarningMacro( "Thick shell array \"" << arrName << "\" does not exist" );
820 }
821 
822 inline int vtkLSDynaReader::GetThickShellArrayStatus( const char* arrName )
823 {
824  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
825  {
826  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
827  {
828  return this->GetThickShellArrayStatus( a );
829  }
830  }
831  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
832  return 0;
833 }
834 
836 {
837  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
838  {
839  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
840  {
841  return this->GetNumberOfComponentsInThickShellArray( a );
842  }
843  }
844  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
845  return 0;
846 }
847 
848 inline void vtkLSDynaReader::SetShellArrayStatus( const char* arrName, int status )
849 {
850  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
851  {
852  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
853  {
854  this->SetShellArrayStatus( a, status );
855  return;
856  }
857  }
858  vtkWarningMacro( "Shell array \"" << arrName << "\" does not exist" );
859 }
860 
861 inline int vtkLSDynaReader::GetShellArrayStatus( const char* arrName )
862 {
863  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
864  {
865  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
866  {
867  return this->GetShellArrayStatus( a );
868  }
869  }
870  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
871  return 0;
872 }
873 
874 inline int vtkLSDynaReader::GetNumberOfComponentsInShellArray( const char* arrName )
875 {
876  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
877  {
878  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
879  {
880  return this->GetNumberOfComponentsInShellArray( a );
881  }
882  }
883  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
884  return 0;
885 }
886 
887 inline void vtkLSDynaReader::SetBeamArrayStatus( const char* arrName, int status )
888 {
889  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
890  {
891  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
892  {
893  this->SetBeamArrayStatus( a, status );
894  return;
895  }
896  }
897  vtkWarningMacro( "Beam array \"" << arrName << "\" does not exist" );
898 }
899 
900 inline int vtkLSDynaReader::GetBeamArrayStatus( const char* arrName )
901 {
902  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
903  {
904  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
905  {
906  return this->GetBeamArrayStatus( a );
907  }
908  }
909  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
910  return 0;
911 }
912 
913 inline int vtkLSDynaReader::GetNumberOfComponentsInBeamArray( const char* arrName )
914 {
915  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
916  {
917  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
918  {
919  return this->GetNumberOfComponentsInBeamArray( a );
920  }
921  }
922  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
923  return 0;
924 }
925 
926 inline void vtkLSDynaReader::SetParticleArrayStatus( const char* arrName, int status )
927 {
928  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
929  {
930  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
931  {
932  this->SetParticleArrayStatus( a, status );
933  return;
934  }
935  }
936  vtkWarningMacro( "Particle array \"" << arrName << "\" does not exist" );
937 }
938 
939 inline int vtkLSDynaReader::GetParticleArrayStatus( const char* arrName )
940 {
941  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
942  {
943  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
944  {
945  return this->GetParticleArrayStatus( a );
946  }
947  }
948  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
949  return 0;
950 }
951 
953 {
954  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
955  {
956  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
957  {
958  return this->GetNumberOfComponentsInParticleArray( a );
959  }
960  }
961  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
962  return 0;
963 }
964 
965 inline void vtkLSDynaReader::SetRigidBodyArrayStatus( const char* arrName, int status )
966 {
967  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
968  {
969  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
970  {
971  this->SetRigidBodyArrayStatus( a, status );
972  return;
973  }
974  }
975  vtkWarningMacro( "Rigid body array \"" << arrName << "\" does not exist" );
976 }
977 
978 inline int vtkLSDynaReader::GetRigidBodyArrayStatus( const char* arrName )
979 {
980  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
981  {
982  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
983  {
984  return this->GetRigidBodyArrayStatus( a );
985  }
986  }
987  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
988  return 0;
989 }
990 
992 {
993  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
994  {
995  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
996  {
997  return this->GetNumberOfComponentsInRigidBodyArray( a );
998  }
999  }
1000  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1001  return 0;
1002 }
1003 
1004 inline void vtkLSDynaReader::SetRoadSurfaceArrayStatus( const char* arrName, int status )
1005 {
1006  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1007  {
1008  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1009  {
1010  this->SetRoadSurfaceArrayStatus( a, status );
1011  return;
1012  }
1013  }
1014  vtkWarningMacro( "Road surface array \"" << arrName << "\" does not exist" );
1015 }
1016 
1017 inline int vtkLSDynaReader::GetRoadSurfaceArrayStatus( const char* arrName )
1018 {
1019  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1020  {
1021  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1022  {
1023  return this->GetRoadSurfaceArrayStatus( a );
1024  }
1025  }
1026  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1027  return 0;
1028 }
1029 
1031 {
1032  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1033  {
1034  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1035  {
1036  return this->GetNumberOfComponentsInRoadSurfaceArray( a );
1037  }
1038  }
1039  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1040  return 0;
1041 }
1042 
1043 inline void vtkLSDynaReader::SetPartArrayStatus( const char* arrName, int status )
1044 {
1045  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1046  {
1047  if ( strcmp( arrName, this->GetPartArrayName(a) ) == 0 )
1048  {
1049  this->SetPartArrayStatus( a, status );
1050  return;
1051  }
1052  }
1053  vtkWarningMacro( "Part \"" << arrName << "\" does not exist" );
1054 }
1055 
1056 inline int vtkLSDynaReader::GetPartArrayStatus( const char* partName )
1057 {
1058  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1059  {
1060  if ( strcmp( partName, this->GetPartArrayName(a) ) == 0 )
1061  {
1062  return this->GetPartArrayStatus( a );
1063  }
1064  }
1065  //vtkWarningMacro( "PartArray \"" << partName << "\" does not exist" );
1066  return 0;
1067 }
1068 
1069 #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...
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:345
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:33
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:48
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)
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:33
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