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) VTK_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(int);
465  vtkGetMacro(DeformedMesh,int);
466  vtkBooleanMacro(DeformedMesh,int);
468 
470 
480  vtkSetMacro(RemoveDeletedCells,int);
481  vtkGetMacro(RemoveDeletedCells,int);
482  vtkBooleanMacro(RemoveDeletedCells,int);
484 
486 
490  vtkSetMacro(DeletedCellsAsGhostArray,int);
491  vtkGetMacro(DeletedCellsAsGhostArray,int);
492  vtkBooleanMacro(DeletedCellsAsGhostArray,int);
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() VTK_OVERRIDE;
562 
571  int ReadHeaderInformation( int currentAdaptLevel );
572 
582  int ScanDatabaseTimeSteps();
583 
584  int RequestInformation( vtkInformation*, vtkInformationVector**, vtkInformationVector* ) VTK_OVERRIDE;
585  int RequestData( vtkInformation*, vtkInformationVector**, vtkInformationVector* ) VTK_OVERRIDE;
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 );
608 
612  virtual void ResetPartInfo();
613 
618  virtual int ReadInputDeck();
619 
625  virtual int ReadPartTitlesFromRootFile();
626 
632  virtual int ReadUserMaterialIds();
633 
635 
639  int ReadInputDeckXML( ifstream& deck );
640  int ReadInputDeckKeywords( ifstream& deck );
642 
647  int WriteInputDeckSummary( const char* fname );
648 
660  virtual void ReadDeletionArray(vtkUnsignedCharArray* arr, const int& pos, const int& size);
661 
665  virtual void ReadCellProperties(const int& type,const int& numTuples);
666 
668 
669  void ResetPartsCache();
670 private:
671 
672  //Helper templated methods to optimze reading. We cast the entire buffer
673  //to a given type instead of casting each element to improve performance
674  template<typename T>
675  void FillDeletionArray(T* buffer, vtkUnsignedCharArray* arr, const vtkIdType& start, const vtkIdType& numCells,
676  const int& deathPos, const int& cellSize);
677 
678  template<int wordSize, typename T>
679  int FillTopology(T* buffer);
680 
681  template<typename T, int blockType, vtkIdType numWordsPerCell, vtkIdType cellLength>
682  void ReadBlockCellSizes();
683 
684  template<typename T>
685  int FillPartSizes();
686 
687  vtkLSDynaReader( const vtkLSDynaReader& ) VTK_DELETE_FUNCTION;
688  void operator = ( const vtkLSDynaReader& ) VTK_DELETE_FUNCTION;
689 };
690 
691 inline void vtkLSDynaReader::SetPointArrayStatus( const char* arrName, int status )
692 {
693  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
694  {
695  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
696  {
697  this->SetPointArrayStatus( a, status );
698  return;
699  }
700  }
701  vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
702 }
703 
704 inline int vtkLSDynaReader::GetPointArrayStatus( const char* arrName )
705 {
706  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
707  {
708  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
709  {
710  return this->GetPointArrayStatus( a );
711  }
712  }
713  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
714  return 0;
715 }
716 
717 inline int vtkLSDynaReader::GetNumberOfComponentsInPointArray( const char* arrName )
718 {
719  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
720  {
721  if ( strcmp( arrName, this->GetPointArrayName( a ) ) == 0 )
722  {
723  return this->GetNumberOfComponentsInPointArray( a );
724  }
725  }
726  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
727  return 0;
728 }
729 
730 inline void vtkLSDynaReader::SetCellArrayStatus( int cellType, const char* arrName, int status )
731 {
732  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
733  {
734  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
735  {
736  this->SetCellArrayStatus( cellType, a, status );
737  return;
738  }
739  }
740  vtkWarningMacro( "Cell array \"" << arrName << "\" (type " << cellType << ") does not exist" );
741 }
742 
743 inline int vtkLSDynaReader::GetCellArrayStatus( int cellType, const char* arrName )
744 {
745  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
746  {
747  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
748  {
749  return this->GetCellArrayStatus( cellType, a );
750  }
751  }
752  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
753  return 0;
754 }
755 
756 inline int vtkLSDynaReader::GetNumberOfComponentsInCellArray( int cellType, const char* arrName )
757 {
758  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
759  {
760  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
761  {
762  return this->GetNumberOfComponentsInCellArray( cellType, a );
763  }
764  }
765  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
766  return 0;
767 }
768 
769 inline void vtkLSDynaReader::SetSolidArrayStatus( const char* arrName, int status )
770 {
771  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
772  {
773  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
774  {
775  this->SetSolidArrayStatus( a, status );
776  return;
777  }
778  }
779  vtkWarningMacro( "Solid array \"" << arrName << "\" does not exist" );
780 }
781 
782 inline int vtkLSDynaReader::GetSolidArrayStatus( const char* arrName )
783 {
784  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
785  {
786  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
787  {
788  return this->GetSolidArrayStatus( a );
789  }
790  }
791  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
792  return 0;
793 }
794 
795 inline int vtkLSDynaReader::GetNumberOfComponentsInSolidArray( const char* arrName )
796 {
797  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
798  {
799  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
800  {
801  return this->GetNumberOfComponentsInSolidArray( a );
802  }
803  }
804  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
805  return 0;
806 }
807 
808 inline void vtkLSDynaReader::SetThickShellArrayStatus( const char* arrName, int status )
809 {
810  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
811  {
812  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
813  {
814  this->SetThickShellArrayStatus( a, status );
815  return;
816  }
817  }
818  vtkWarningMacro( "Thick shell array \"" << arrName << "\" does not exist" );
819 }
820 
821 inline int vtkLSDynaReader::GetThickShellArrayStatus( const char* arrName )
822 {
823  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
824  {
825  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
826  {
827  return this->GetThickShellArrayStatus( a );
828  }
829  }
830  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
831  return 0;
832 }
833 
835 {
836  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
837  {
838  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
839  {
840  return this->GetNumberOfComponentsInThickShellArray( a );
841  }
842  }
843  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
844  return 0;
845 }
846 
847 inline void vtkLSDynaReader::SetShellArrayStatus( const char* arrName, int status )
848 {
849  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
850  {
851  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
852  {
853  this->SetShellArrayStatus( a, status );
854  return;
855  }
856  }
857  vtkWarningMacro( "Shell array \"" << arrName << "\" does not exist" );
858 }
859 
860 inline int vtkLSDynaReader::GetShellArrayStatus( const char* arrName )
861 {
862  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
863  {
864  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
865  {
866  return this->GetShellArrayStatus( a );
867  }
868  }
869  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
870  return 0;
871 }
872 
873 inline int vtkLSDynaReader::GetNumberOfComponentsInShellArray( const char* arrName )
874 {
875  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
876  {
877  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
878  {
879  return this->GetNumberOfComponentsInShellArray( a );
880  }
881  }
882  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
883  return 0;
884 }
885 
886 inline void vtkLSDynaReader::SetBeamArrayStatus( const char* arrName, int status )
887 {
888  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
889  {
890  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
891  {
892  this->SetBeamArrayStatus( a, status );
893  return;
894  }
895  }
896  vtkWarningMacro( "Beam array \"" << arrName << "\" does not exist" );
897 }
898 
899 inline int vtkLSDynaReader::GetBeamArrayStatus( const char* arrName )
900 {
901  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
902  {
903  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
904  {
905  return this->GetBeamArrayStatus( a );
906  }
907  }
908  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
909  return 0;
910 }
911 
912 inline int vtkLSDynaReader::GetNumberOfComponentsInBeamArray( const char* arrName )
913 {
914  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
915  {
916  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
917  {
918  return this->GetNumberOfComponentsInBeamArray( a );
919  }
920  }
921  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
922  return 0;
923 }
924 
925 inline void vtkLSDynaReader::SetParticleArrayStatus( const char* arrName, int status )
926 {
927  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
928  {
929  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
930  {
931  this->SetParticleArrayStatus( a, status );
932  return;
933  }
934  }
935  vtkWarningMacro( "Particle array \"" << arrName << "\" does not exist" );
936 }
937 
938 inline int vtkLSDynaReader::GetParticleArrayStatus( const char* arrName )
939 {
940  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
941  {
942  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
943  {
944  return this->GetParticleArrayStatus( a );
945  }
946  }
947  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
948  return 0;
949 }
950 
952 {
953  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
954  {
955  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
956  {
957  return this->GetNumberOfComponentsInParticleArray( a );
958  }
959  }
960  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
961  return 0;
962 }
963 
964 inline void vtkLSDynaReader::SetRigidBodyArrayStatus( const char* arrName, int status )
965 {
966  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
967  {
968  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
969  {
970  this->SetRigidBodyArrayStatus( a, status );
971  return;
972  }
973  }
974  vtkWarningMacro( "Rigid body array \"" << arrName << "\" does not exist" );
975 }
976 
977 inline int vtkLSDynaReader::GetRigidBodyArrayStatus( const char* arrName )
978 {
979  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
980  {
981  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
982  {
983  return this->GetRigidBodyArrayStatus( a );
984  }
985  }
986  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
987  return 0;
988 }
989 
991 {
992  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
993  {
994  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
995  {
996  return this->GetNumberOfComponentsInRigidBodyArray( a );
997  }
998  }
999  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1000  return 0;
1001 }
1002 
1003 inline void vtkLSDynaReader::SetRoadSurfaceArrayStatus( const char* arrName, int status )
1004 {
1005  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1006  {
1007  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1008  {
1009  this->SetRoadSurfaceArrayStatus( a, status );
1010  return;
1011  }
1012  }
1013  vtkWarningMacro( "Road surface array \"" << arrName << "\" does not exist" );
1014 }
1015 
1016 inline int vtkLSDynaReader::GetRoadSurfaceArrayStatus( const char* arrName )
1017 {
1018  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1019  {
1020  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1021  {
1022  return this->GetRoadSurfaceArrayStatus( a );
1023  }
1024  }
1025  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1026  return 0;
1027 }
1028 
1030 {
1031  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1032  {
1033  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1034  {
1035  return this->GetNumberOfComponentsInRoadSurfaceArray( a );
1036  }
1037  }
1038  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1039  return 0;
1040 }
1041 
1042 inline void vtkLSDynaReader::SetPartArrayStatus( const char* arrName, int status )
1043 {
1044  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1045  {
1046  if ( strcmp( arrName, this->GetPartArrayName(a) ) == 0 )
1047  {
1048  this->SetPartArrayStatus( a, status );
1049  return;
1050  }
1051  }
1052  vtkWarningMacro( "Part \"" << arrName << "\" does not exist" );
1053 }
1054 
1055 inline int vtkLSDynaReader::GetPartArrayStatus( const char* partName )
1056 {
1057  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1058  {
1059  if ( strcmp( partName, this->GetPartArrayName(a) ) == 0 )
1060  {
1061  return this->GetPartArrayStatus( a );
1062  }
1063  }
1064  //vtkWarningMacro( "PartArray \"" << partName << "\" does not exist" );
1065  return 0;
1066 }
1067 
1068 #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
int GetThickShellArrayStatus(int arr)
These methods allow you to load only selected subsets of the cell variables defined over the mesh...
Store vtkAlgorithm input/output information.
int GetNumberOfComponentsInBeamArray(int a)
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)
int DeletedCellsAsGhostArray
Should cells marked as deleted be removed from the mesh? By default, this is true.
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 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 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 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...
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...
a simple class to control print indentation
Definition: vtkIndent.h:33
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
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
int DeformedMesh
Should deflected coordinates be used, or should the mesh remain undeflected? By default, this is true.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
dynamic, self-adjusting array of unsigned char
int GetNumberOfComponentsInShellArray(int a)
int RemoveDeletedCells
Should cells marked as deleted be removed from the mesh? By default, this is true.
int GetNumberOfComponentsInRigidBodyArray(int a)
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...
vtkBooleanMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
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.
int GetNumberOfComponentsInRoadSurfaceArray(int a)
int GetNumberOfComponentsInParticleArray(int a)
represent and manipulate 3D points
Definition: vtkPoints.h:33
int GetNumberOfComponentsInPointArray(int arr)
These methods allow you to load only selected subsets of the nodal variables defined over the mesh...