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 
154 #ifndef vtkLSDynaReader_h
155 #define vtkLSDynaReader_h
156 
157 #include "vtkIOLSDynaModule.h" // For export macro
159 
160 class LSDynaMetaData;
162 class vtkPoints;
163 class vtkDataArray;
165 class vtkUnstructuredGrid;
166 
167 class VTKIOLSDYNA_EXPORT vtkLSDynaReader : public vtkMultiBlockDataSetAlgorithm
168 {
169 public:
171  virtual void PrintSelf(ostream &os, vtkIndent indent);
172  static vtkLSDynaReader *New();
173 
178  void Dump( ostream &os );
179 
184  void DebugDump();
185 
189  virtual int CanReadFile( const char* fname );
190 
192 
196  virtual void SetDatabaseDirectory( const char* );
197  const char* GetDatabaseDirectory();
200 
202 
208  virtual void SetFileName( const char* );
209  const char* GetFileName();
211 
217  char* GetTitle();
218 
225 
232 
242 
254 
261 
268 
275 
282 
289 
295 
302 
304 
310  virtual void SetTimeStep( vtkIdType );
313  vtkGetVector2Macro(TimeStepRange,int);
314  vtkSetVector2Macro(TimeStepRange,int);
316 
318 
323  const char* GetPointArrayName(int);
324  virtual void SetPointArrayStatus( int arr, int status );
325  virtual void SetPointArrayStatus( const char* arrName, int status );
326  int GetPointArrayStatus( int arr );
327  int GetPointArrayStatus( const char* arrName );
329  int GetNumberOfComponentsInPointArray( const char* arrName );
331 
333 
340  const char* GetCellArrayName( int cellType, int arr );
341  virtual void SetCellArrayStatus( int cellType, int arr, int status );
342  virtual void SetCellArrayStatus( int cellType, const char* arrName, int status );
343  int GetCellArrayStatus( int cellType, int arr );
344  int GetCellArrayStatus( int cellType, const char* arrName );
346  int GetNumberOfComponentsInCellArray( int cellType, const char* arrName );
348 
350 
355  const char* GetSolidArrayName(int);
356  virtual void SetSolidArrayStatus( int arr, int status );
357  virtual void SetSolidArrayStatus( const char* arrName, int status );
358  int GetSolidArrayStatus( int arr );
359  int GetSolidArrayStatus( const char* arrName );
361 
363  int GetNumberOfComponentsInSolidArray( const char* arrName );
364 
366 
371  const char* GetThickShellArrayName(int);
372  virtual void SetThickShellArrayStatus( int arr, int status );
373  virtual void SetThickShellArrayStatus( const char* arrName, int status );
374  int GetThickShellArrayStatus( int arr );
375  int GetThickShellArrayStatus( const char* arrName );
377 
379  int GetNumberOfComponentsInThickShellArray( const char* arrName );
380 
382 
387  const char* GetShellArrayName(int);
388  virtual void SetShellArrayStatus( int arr, int status );
389  virtual void SetShellArrayStatus( const char* arrName, int status );
390  int GetShellArrayStatus( int arr );
391  int GetShellArrayStatus( const char* arrName );
393 
395  int GetNumberOfComponentsInShellArray( const char* arrName );
396 
398 
403  const char* GetRigidBodyArrayName(int);
404  virtual void SetRigidBodyArrayStatus( int arr, int status );
405  virtual void SetRigidBodyArrayStatus( const char* arrName, int status );
406  int GetRigidBodyArrayStatus( int arr );
407  int GetRigidBodyArrayStatus( const char* arrName );
409 
411  int GetNumberOfComponentsInRigidBodyArray( const char* arrName );
412 
414 
419  const char* GetRoadSurfaceArrayName(int);
420  virtual void SetRoadSurfaceArrayStatus( int arr, int status );
421  virtual void SetRoadSurfaceArrayStatus( const char* arrName, int status );
423  int GetRoadSurfaceArrayStatus( const char* arrName );
425 
427  int GetNumberOfComponentsInRoadSurfaceArray( const char* arrName );
428 
430 
435  const char* GetBeamArrayName(int);
436  virtual void SetBeamArrayStatus( int arr, int status );
437  virtual void SetBeamArrayStatus( const char* arrName, int status );
438  int GetBeamArrayStatus( int arr );
439  int GetBeamArrayStatus( const char* arrName );
441 
443  int GetNumberOfComponentsInBeamArray( const char* arrName );
444 
446 
451  const char* GetParticleArrayName(int);
452  virtual void SetParticleArrayStatus( int arr, int status );
453  virtual void SetParticleArrayStatus( const char* arrName, int status );
454  int GetParticleArrayStatus( int arr );
455  int GetParticleArrayStatus( const char* arrName );
457 
459  int GetNumberOfComponentsInParticleArray( const char* arrName );
460 
462 
467  void SetDeformedMesh(int);
468  vtkGetMacro(DeformedMesh,int);
469  vtkBooleanMacro(DeformedMesh,int);
471 
473 
483  vtkSetMacro(RemoveDeletedCells,int);
484  vtkGetMacro(RemoveDeletedCells,int);
485  vtkBooleanMacro(RemoveDeletedCells,int);
487 
489 
493  vtkSetMacro(DeletedCellsAsGhostArray,int);
494  vtkGetMacro(DeletedCellsAsGhostArray,int);
495  vtkBooleanMacro(DeletedCellsAsGhostArray,int);
497 
499 
510  vtkSetStringMacro(InputDeck);
511  vtkGetStringMacro(InputDeck);
513 
515 
526  const char* GetPartArrayName(int);
527  virtual void SetPartArrayStatus( int arr, int status );
528  virtual void SetPartArrayStatus( const char* partName, int status );
529  int GetPartArrayStatus( int arr );
530  int GetPartArrayStatus( const char* partName );
532 
533 protected:
534  //holds all the parts and all the properties for each part
536 
542 
544 
551 
556  int TimeStepRange[2];
557 
561  char* InputDeck;
562 
564  virtual ~vtkLSDynaReader();
565 
574  int ReadHeaderInformation( int currentAdaptLevel );
575 
586 
589 
591 
600  virtual int ReadTopology();
601  virtual int ReadNodes();
602  virtual int ReadPartSizes();
604  virtual int ReadUserIds();
605  virtual int ReadState( vtkIdType );
606  virtual int ReadNodeStateInfo( vtkIdType );
607  virtual int ReadCellStateInfo( vtkIdType );
608  virtual int ReadDeletion();
609  virtual int ReadSPHState( vtkIdType );
611 
615  virtual void ResetPartInfo();
616 
621  virtual int ReadInputDeck();
622 
629 
635  virtual int ReadUserMaterialIds();
636 
638 
642  int ReadInputDeckXML( ifstream& deck );
643  int ReadInputDeckKeywords( ifstream& deck );
645 
650  int WriteInputDeckSummary( const char* fname );
651 
663  virtual void ReadDeletionArray(vtkUnsignedCharArray* arr, const int& pos, const int& size);
664 
668  virtual void ReadCellProperties(const int& type,const int& numTuples);
669 
671 
673 private:
674 
675  //Helper templated methods to optimze reading. We cast the entire buffer
676  //to a given type instead of casting each element to improve performance
677  template<typename T>
678  void FillDeletionArray(T* buffer, vtkUnsignedCharArray* arr, const vtkIdType& start, const vtkIdType& numCells,
679  const int& deathPos, const int& cellSize);
680 
681  template<int wordSize, typename T>
682  int FillTopology(T* buffer);
683 
684  template<typename T, int blockType, vtkIdType numWordsPerCell, vtkIdType cellLength>
685  void ReadBlockCellSizes();
686 
687  template<typename T>
688  int FillPartSizes();
689 
690  vtkLSDynaReader( const vtkLSDynaReader& ) VTK_DELETE_FUNCTION;
691  void operator = ( const vtkLSDynaReader& ) VTK_DELETE_FUNCTION;
692 };
693 
694 inline void vtkLSDynaReader::SetPointArrayStatus( const char* arrName, int status )
695 {
696  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
697  {
698  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
699  {
700  this->SetPointArrayStatus( a, status );
701  return;
702  }
703  }
704  vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
705 }
706 
707 inline int vtkLSDynaReader::GetPointArrayStatus( const char* arrName )
708 {
709  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
710  {
711  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
712  {
713  return this->GetPointArrayStatus( a );
714  }
715  }
716  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
717  return 0;
718 }
719 
720 inline int vtkLSDynaReader::GetNumberOfComponentsInPointArray( const char* arrName )
721 {
722  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
723  {
724  if ( strcmp( arrName, this->GetPointArrayName( a ) ) == 0 )
725  {
726  return this->GetNumberOfComponentsInPointArray( a );
727  }
728  }
729  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
730  return 0;
731 }
732 
733 inline void vtkLSDynaReader::SetCellArrayStatus( int cellType, const char* arrName, int status )
734 {
735  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
736  {
737  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
738  {
739  this->SetCellArrayStatus( cellType, a, status );
740  return;
741  }
742  }
743  vtkWarningMacro( "Cell array \"" << arrName << "\" (type " << cellType << ") does not exist" );
744 }
745 
746 inline int vtkLSDynaReader::GetCellArrayStatus( int cellType, const char* arrName )
747 {
748  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
749  {
750  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
751  {
752  return this->GetCellArrayStatus( cellType, a );
753  }
754  }
755  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
756  return 0;
757 }
758 
759 inline int vtkLSDynaReader::GetNumberOfComponentsInCellArray( int cellType, const char* arrName )
760 {
761  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
762  {
763  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
764  {
765  return this->GetNumberOfComponentsInCellArray( cellType, a );
766  }
767  }
768  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
769  return 0;
770 }
771 
772 inline void vtkLSDynaReader::SetSolidArrayStatus( const char* arrName, int status )
773 {
774  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
775  {
776  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
777  {
778  this->SetSolidArrayStatus( a, status );
779  return;
780  }
781  }
782  vtkWarningMacro( "Solid array \"" << arrName << "\" does not exist" );
783 }
784 
785 inline int vtkLSDynaReader::GetSolidArrayStatus( const char* arrName )
786 {
787  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
788  {
789  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
790  {
791  return this->GetSolidArrayStatus( a );
792  }
793  }
794  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
795  return 0;
796 }
797 
798 inline int vtkLSDynaReader::GetNumberOfComponentsInSolidArray( const char* arrName )
799 {
800  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
801  {
802  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
803  {
804  return this->GetNumberOfComponentsInSolidArray( a );
805  }
806  }
807  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
808  return 0;
809 }
810 
811 inline void vtkLSDynaReader::SetThickShellArrayStatus( const char* arrName, int status )
812 {
813  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
814  {
815  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
816  {
817  this->SetThickShellArrayStatus( a, status );
818  return;
819  }
820  }
821  vtkWarningMacro( "Thick shell array \"" << arrName << "\" does not exist" );
822 }
823 
824 inline int vtkLSDynaReader::GetThickShellArrayStatus( const char* arrName )
825 {
826  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
827  {
828  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
829  {
830  return this->GetThickShellArrayStatus( a );
831  }
832  }
833  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
834  return 0;
835 }
836 
838 {
839  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
840  {
841  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
842  {
843  return this->GetNumberOfComponentsInThickShellArray( a );
844  }
845  }
846  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
847  return 0;
848 }
849 
850 inline void vtkLSDynaReader::SetShellArrayStatus( const char* arrName, int status )
851 {
852  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
853  {
854  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
855  {
856  this->SetShellArrayStatus( a, status );
857  return;
858  }
859  }
860  vtkWarningMacro( "Shell array \"" << arrName << "\" does not exist" );
861 }
862 
863 inline int vtkLSDynaReader::GetShellArrayStatus( const char* arrName )
864 {
865  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
866  {
867  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
868  {
869  return this->GetShellArrayStatus( a );
870  }
871  }
872  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
873  return 0;
874 }
875 
876 inline int vtkLSDynaReader::GetNumberOfComponentsInShellArray( const char* arrName )
877 {
878  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
879  {
880  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
881  {
882  return this->GetNumberOfComponentsInShellArray( a );
883  }
884  }
885  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
886  return 0;
887 }
888 
889 inline void vtkLSDynaReader::SetBeamArrayStatus( const char* arrName, int status )
890 {
891  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
892  {
893  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
894  {
895  this->SetBeamArrayStatus( a, status );
896  return;
897  }
898  }
899  vtkWarningMacro( "Beam array \"" << arrName << "\" does not exist" );
900 }
901 
902 inline int vtkLSDynaReader::GetBeamArrayStatus( const char* arrName )
903 {
904  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
905  {
906  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
907  {
908  return this->GetBeamArrayStatus( a );
909  }
910  }
911  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
912  return 0;
913 }
914 
915 inline int vtkLSDynaReader::GetNumberOfComponentsInBeamArray( const char* arrName )
916 {
917  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
918  {
919  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
920  {
921  return this->GetNumberOfComponentsInBeamArray( a );
922  }
923  }
924  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
925  return 0;
926 }
927 
928 inline void vtkLSDynaReader::SetParticleArrayStatus( const char* arrName, int status )
929 {
930  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
931  {
932  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
933  {
934  this->SetParticleArrayStatus( a, status );
935  return;
936  }
937  }
938  vtkWarningMacro( "Particle array \"" << arrName << "\" does not exist" );
939 }
940 
941 inline int vtkLSDynaReader::GetParticleArrayStatus( const char* arrName )
942 {
943  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
944  {
945  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
946  {
947  return this->GetParticleArrayStatus( a );
948  }
949  }
950  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
951  return 0;
952 }
953 
955 {
956  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
957  {
958  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
959  {
960  return this->GetNumberOfComponentsInParticleArray( a );
961  }
962  }
963  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
964  return 0;
965 }
966 
967 inline void vtkLSDynaReader::SetRigidBodyArrayStatus( const char* arrName, int status )
968 {
969  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
970  {
971  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
972  {
973  this->SetRigidBodyArrayStatus( a, status );
974  return;
975  }
976  }
977  vtkWarningMacro( "Rigid body array \"" << arrName << "\" does not exist" );
978 }
979 
980 inline int vtkLSDynaReader::GetRigidBodyArrayStatus( const char* arrName )
981 {
982  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
983  {
984  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
985  {
986  return this->GetRigidBodyArrayStatus( a );
987  }
988  }
989  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
990  return 0;
991 }
992 
994 {
995  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
996  {
997  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
998  {
999  return this->GetNumberOfComponentsInRigidBodyArray( a );
1000  }
1001  }
1002  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1003  return 0;
1004 }
1005 
1006 inline void vtkLSDynaReader::SetRoadSurfaceArrayStatus( const char* arrName, int status )
1007 {
1008  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1009  {
1010  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1011  {
1012  this->SetRoadSurfaceArrayStatus( a, status );
1013  return;
1014  }
1015  }
1016  vtkWarningMacro( "Road surface array \"" << arrName << "\" does not exist" );
1017 }
1018 
1019 inline int vtkLSDynaReader::GetRoadSurfaceArrayStatus( const char* arrName )
1020 {
1021  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1022  {
1023  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1024  {
1025  return this->GetRoadSurfaceArrayStatus( a );
1026  }
1027  }
1028  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1029  return 0;
1030 }
1031 
1033 {
1034  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1035  {
1036  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1037  {
1038  return this->GetNumberOfComponentsInRoadSurfaceArray( a );
1039  }
1040  }
1041  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1042  return 0;
1043 }
1044 
1045 inline void vtkLSDynaReader::SetPartArrayStatus( const char* arrName, int status )
1046 {
1047  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1048  {
1049  if ( strcmp( arrName, this->GetPartArrayName(a) ) == 0 )
1050  {
1051  this->SetPartArrayStatus( a, status );
1052  return;
1053  }
1054  }
1055  vtkWarningMacro( "Part \"" << arrName << "\" does not exist" );
1056 }
1057 
1058 inline int vtkLSDynaReader::GetPartArrayStatus( const char* partName )
1059 {
1060  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1061  {
1062  if ( strcmp( partName, this->GetPartArrayName(a) ) == 0 )
1063  {
1064  return this->GetPartArrayStatus( a );
1065  }
1066  }
1067  //vtkWarningMacro( "PartArray \"" << partName << "\" does not exist" );
1068  return 0;
1069 }
1070 
1071 #endif // vtkLSDynaReader_h
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
a simple class to control print indentation
Definition: vtkIndent.h:40
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
Read LS-Dyna databases (d3plot)
int GetNumberOfParticleArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetRigidBodyArrayStatus(int arr)
virtual int ReadSPHState(vtkIdType)
const char * GetDatabaseDirectory()
virtual int ReadInputDeck()
Called from within ReadHeaderInformation() to read part names associated with material IDs.
virtual int ReadCellStateInfo(vtkIdType)
const char * GetPointArrayName(int)
void Dump(ostream &os)
Print out more complete information about the dataset (and less complete information about the VTK hi...
int ReadInputDeckXML(ifstream &deck)
ReadInputDeck determines the type of file (keyword or XML summary) and calls one of these two routine...
int GetRoadSurfaceArrayStatus(int arr)
virtual int ReadPartTitlesFromRootFile()
Called from within ReadHeaderInformation to read part names from the end of the first d3plot file.
vtkIdType GetNumberOfCells()
Retrieve the number of cells of a given type in the database.
void SetDeformedMesh(int)
Should deflected coordinates be used, or should the mesh remain undeflected? By default,...
int GetNumberOfComponentsInParticleArray(int a)
int GetParticleArrayStatus(int arr)
virtual int ReadUserIds()
virtual void SetThickShellArrayStatus(int arr, int status)
vtkIdType GetNumberOfShellCells()
Retrieve the number of cells of a given type in the database.
const char * GetParticleArrayName(int)
int GetNumberOfComponentsInCellArray(int cellType, int arr)
virtual void SetShellArrayStatus(int arr, int status)
int GetNumberOfComponentsInBeamArray(int a)
int ReadHeaderInformation(int currentAdaptLevel)
This function populates the reader's private dictionary with information about the database.
char * InputDeck
The name of a file containing part names and IDs.
virtual int CanReadFile(const char *fname)
Determine if the file can be readed with this reader.
virtual void SetDatabaseDirectory(const char *)
Get/Set the directory containing the LS-Dyna database and determine whether it is valid.
virtual void SetSolidArrayStatus(int arr, int status)
void ResetPartsCache()
virtual int ReadUserMaterialIds()
Called from within ReadHeaderInformation() to read arbitrary material IDs (if present) or manufacture...
int GetThickShellArrayStatus(int arr)
int GetNumberOfSolidArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetBeamArrayStatus(int arr)
virtual int ReadNodeStateInfo(vtkIdType)
vtkLSDynaPartCollection * Parts
void DebugDump()
A routine to call Dump() from within a lame debugger that won't properly pass a C++ iostream object l...
int GetNumberOfRigidBodyArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadState(vtkIdType)
int GetNumberOfPartArrays()
These methods allow you to load only selected parts of the input.
vtkIdType GetNumberOfRigidBodyCells()
Retrieve the number of cells of a given type in the database.
int RemoveDeletedCells
Should cells marked as deleted be removed from the mesh? By default, this is true.
const char * GetFileName()
const char * GetPartArrayName(int)
int GetNumberOfComponentsInPointArray(int arr)
virtual void SetFileName(const char *)
Get/Set the filename.
virtual void ReadDeletionArray(vtkUnsignedCharArray *arr, const int &pos, const int &size)
Read an array of deletion data.
int WriteInputDeckSummary(const char *fname)
ReadInputDeckKeywords calls this function if it was successful in reading part names for materials.
int GetDimensionality()
Retrieve the dimension of points in the database.
int ReadInputDeckKeywords(ifstream &deck)
vtkIdType GetNumberOfThickShellCells()
Retrieve the number of cells of a given type in the database.
virtual void SetParticleArrayStatus(int arr, int status)
int GetNumberOfShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
int GetShellArrayStatus(int arr)
const char * GetRigidBodyArrayName(int)
const char * GetCellArrayName(int cellType, int arr)
virtual void PrintSelf(ostream &os, vtkIndent indent)
Methods invoked by print to print information about the object including superclasses.
virtual void SetPointArrayStatus(int arr, int status)
int GetNumberOfComponentsInRigidBodyArray(int a)
int GetNumberOfThickShellArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
double GetTimeValue(vtkIdType)
const char * GetBeamArrayName(int)
int GetNumberOfCellArrays(int cellType)
Routines that allow the status of a cell variable to be adjusted or queried independent of the output...
int GetNumberOfRoadSurfaceArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual int ReadPartSizes()
virtual void SetBeamArrayStatus(int arr, int status)
vtkIdType GetTimeStep()
vtkIdType GetNumberOfParticleCells()
Retrieve the number of cells of a given type in the database.
virtual ~vtkLSDynaReader()
int GetNumberOfBeamArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
virtual void SetPartArrayStatus(int arr, int status)
int DeformedMesh
Should deflected coordinates be used, or should the mesh remain undeflected? By default,...
virtual int RequestInformation(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
char * GetTitle()
The title of the database is a 40 or 80 character text description stored at the front of a d3plot fi...
virtual int ReadConnectivityAndMaterial()
virtual void ResetPartInfo()
Resets the Part information to the default state.
virtual int ReadNodes()
vtkIdType GetNumberOfNodes()
Retrieve the number of points in the database.
const char * GetSolidArrayName(int)
virtual void SetRoadSurfaceArrayStatus(int arr, int status)
virtual int ReadTopology()
These functions read various parts of the database.
int GetNumberOfComponentsInRoadSurfaceArray(int a)
int GetNumberOfComponentsInSolidArray(int a)
int GetNumberOfPointArrays()
These methods allow you to load only selected subsets of the nodal variables defined over the mesh.
virtual void SetCellArrayStatus(int cellType, int arr, int status)
int GetNumberOfComponentsInThickShellArray(int a)
const char * GetThickShellArrayName(int)
vtkIdType GetNumberOfSolidCells()
Retrieve the number of cells of a given type in the database.
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
LSDynaMetaData * P
virtual void ReadCellProperties(const int &type, const int &numTuples)
Read all the cell properties of a given part type.
int ScanDatabaseTimeSteps()
This function scans the list of files in the database and bookmarks the start of each time step's sta...
const char * GetRoadSurfaceArrayName(int)
vtkIdType GetNumberOfTimeSteps()
Retrieve information about the time extents of the LS-Dyna database.
int GetCellArrayStatus(int cellType, int arr)
int GetPointArrayStatus(int arr)
vtkIdType GetNumberOfRoadSurfaceCells()
Retrieve the number of cells of a given type in the database.
vtkIdType GetNumberOfBeamCells()
Retrieve the number of cells of a given type in the database.
int GetNumberOfComponentsInShellArray(int a)
virtual void SetTimeStep(vtkIdType)
int GetSolidArrayStatus(int arr)
virtual void SetRigidBodyArrayStatus(int arr, int status)
vtkIdType GetNumberOfContinuumCells()
Retrieve the number of cells of a given type in the database.
const char * GetShellArrayName(int)
virtual int ReadDeletion()
int GetPartArrayStatus(int arr)
static vtkLSDynaReader * New()
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
represent and manipulate 3D points
Definition: vtkPoints.h:40
dynamic, self-adjusting array of unsigned char
dataset represents arbitrary combinations of all possible cell types
CellTypeInDataSet cellType(vtkDataSet *input)
@ type
Definition: vtkX3D.h:516
@ size
Definition: vtkX3D.h:253
vtkSetMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkBooleanMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
int vtkIdType
Definition: vtkType.h:287