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 optimize 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
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:33
vtkLSDynaReader::GetNumberOfComponentsInShellArray
int GetNumberOfComponentsInShellArray(int a)
vtkLSDynaReader::GetNumberOfParticleArrays
int GetNumberOfParticleArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkLSDynaReader::SetPointArrayStatus
virtual void SetPointArrayStatus(int arr, int status)
vtkLSDynaReader::GetCellArrayStatus
int GetCellArrayStatus(int cellType, int arr)
vtkLSDynaReader::GetSolidArrayName
const char * GetSolidArrayName(int)
vtkLSDynaReader::RemoveDeletedCells
vtkTypeBool RemoveDeletedCells
Should cells marked as deleted be removed from the mesh? By default, this is true.
Definition: vtkLSDynaReader.h:545
vtkLSDynaReader
Read LS-Dyna databases (d3plot)
Definition: vtkLSDynaReader.h:164
vtkLSDynaReader::GetCellArrayName
const char * GetCellArrayName(int cellType, int arr)
vtkLSDynaReader::GetShellArrayStatus
int GetShellArrayStatus(int arr)
vtkX3D::type
Definition: vtkX3D.h:516
vtkIdType
int vtkIdType
Definition: vtkType.h:347
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:35
vtkLSDynaReader::GetSolidArrayStatus
int GetSolidArrayStatus(int arr)
vtkLSDynaReader::SetThickShellArrayStatus
virtual void SetThickShellArrayStatus(int arr, int status)
vtkUnsignedCharArray
dynamic, self-adjusting array of unsigned char
Definition: vtkUnsignedCharArray.h:35
vtkMultiBlockDataSetAlgorithm::New
static vtkMultiBlockDataSetAlgorithm * New()
vtkLSDynaReader::SetPartArrayStatus
virtual void SetPartArrayStatus(int arr, int status)
vtkLSDynaReader::GetNumberOfComponentsInRigidBodyArray
int GetNumberOfComponentsInRigidBodyArray(int a)
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:48
vtkLSDynaReader::GetNumberOfPointArrays
int GetNumberOfPointArrays()
These methods allow you to load only selected subsets of the nodal variables defined over the mesh.
vtkLSDynaReader::GetNumberOfComponentsInCellArray
int GetNumberOfComponentsInCellArray(int cellType, int arr)
vtkLSDynaReader::GetThickShellArrayName
const char * GetThickShellArrayName(int)
vtkLSDynaReader::GetNumberOfBeamArrays
int GetNumberOfBeamArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkMultiBlockDataSetAlgorithm::RequestData
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
Definition: vtkMultiBlockDataSetAlgorithm.h:88
vtkLSDynaPartCollection
Definition: vtkLSDynaPartCollection.h:29
vtkLSDynaReader::GetPartArrayStatus
int GetPartArrayStatus(int arr)
vtkLSDynaReader::GetParticleArrayStatus
int GetParticleArrayStatus(int arr)
vtkLSDynaReader::GetNumberOfComponentsInParticleArray
int GetNumberOfComponentsInParticleArray(int a)
vtkLSDynaReader::GetPartArrayName
const char * GetPartArrayName(int)
vtkLSDynaReader::SetBeamArrayStatus
virtual void SetBeamArrayStatus(int arr, int status)
vtkLSDynaReader::GetNumberOfCellArrays
int GetNumberOfCellArrays(int cellType)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
vtkLSDynaReader::GetNumberOfComponentsInSolidArray
int GetNumberOfComponentsInSolidArray(int a)
vtkLSDynaReader::GetPointArrayStatus
int GetPointArrayStatus(int arr)
vtkLSDynaReader::GetPointArrayName
const char * GetPointArrayName(int)
vtkLSDynaReader::GetNumberOfShellArrays
int GetNumberOfShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkLSDynaReader::GetNumberOfPartArrays
int GetNumberOfPartArrays()
These methods allow you to load only selected parts of the input.
vtkLSDynaReader::GetRoadSurfaceArrayStatus
int GetRoadSurfaceArrayStatus(int arr)
vtkLSDynaReader::DeformedMesh
vtkTypeBool DeformedMesh
Should deflected coordinates be used, or should the mesh remain undeflected? By default,...
Definition: vtkLSDynaReader.h:538
vtkLSDynaReader::GetNumberOfThickShellArrays
int GetNumberOfThickShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkLSDynaReader::SetRoadSurfaceArrayStatus
virtual void SetRoadSurfaceArrayStatus(int arr, int status)
vtkLSDynaReader::GetParticleArrayName
const char * GetParticleArrayName(int)
vtkLSDynaReader::GetRoadSurfaceArrayName
const char * GetRoadSurfaceArrayName(int)
vtkX3D::size
Definition: vtkX3D.h:253
vtkMultiBlockDataSetAlgorithm.h
vtkLSDynaReader::GetRigidBodyArrayStatus
int GetRigidBodyArrayStatus(int arr)
vtkLSDynaReader::SetShellArrayStatus
virtual void SetShellArrayStatus(int arr, int status)
vtkLSDynaReader::GetNumberOfSolidArrays
int GetNumberOfSolidArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkLSDynaReader::GetShellArrayName
const char * GetShellArrayName(int)
vtkLSDynaReader::GetRigidBodyArrayName
const char * GetRigidBodyArrayName(int)
vtkLSDynaReader::GetBeamArrayStatus
int GetBeamArrayStatus(int arr)
vtkLSDynaReader::GetNumberOfComponentsInBeamArray
int GetNumberOfComponentsInBeamArray(int a)
vtkLSDynaReader::SetSolidArrayStatus
virtual void SetSolidArrayStatus(int arr, int status)
vtkMultiBlockDataSetAlgorithm::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:80
vtkLSDynaReader::SetParticleArrayStatus
virtual void SetParticleArrayStatus(int arr, int status)
vtkLSDynaReader::GetThickShellArrayStatus
int GetThickShellArrayStatus(int arr)
vtkLSDynaReader::DeletedCellsAsGhostArray
vtkTypeBool DeletedCellsAsGhostArray
Definition: vtkLSDynaReader.h:546
vtkLSDynaReader::SetRigidBodyArrayStatus
virtual void SetRigidBodyArrayStatus(int arr, int status)
vtkLSDynaReader::GetNumberOfRigidBodyArrays
int GetNumberOfRigidBodyArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkLSDynaReader::InputDeck
char * InputDeck
The name of a file containing part names and IDs.
Definition: vtkLSDynaReader.h:558
vtkLSDynaReader::GetBeamArrayName
const char * GetBeamArrayName(int)
vtkLSDynaReader::GetNumberOfComponentsInThickShellArray
int GetNumberOfComponentsInThickShellArray(int a)
vtkUnstructuredGrid
dataset represents arbitrary combinations of all possible cell types
Definition: vtkUnstructuredGrid.h:81
vtkLSDynaReader::GetNumberOfComponentsInPointArray
int GetNumberOfComponentsInPointArray(int arr)
vtkLSDynaReader::P
LSDynaMetaData * P
Definition: vtkLSDynaReader.h:668
vtkLSDynaReader::SetCellArrayStatus
virtual void SetCellArrayStatus(int cellType, int arr, int status)
vtkMultiBlockDataSetAlgorithm::RequestInformation
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
Definition: vtkMultiBlockDataSetAlgorithm.h:80
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkLSDynaReader::GetNumberOfRoadSurfaceArrays
int GetNumberOfRoadSurfaceArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkLSDynaReader::Parts
vtkLSDynaPartCollection * Parts
Definition: vtkLSDynaReader.h:532
vtkLSDynaReader::GetNumberOfComponentsInRoadSurfaceArray
int GetNumberOfComponentsInRoadSurfaceArray(int a)
LSDynaMetaData
Definition: LSDynaMetaData.h:38
vtkMultiBlockDataSetAlgorithm
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
Definition: vtkMultiBlockDataSetAlgorithm.h:32