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();
198  int IsDatabaseValid();
200 
202 
208  virtual void SetFileName( const char* );
209  const char* GetFileName();
211 
217  char* GetTitle();
218 
224  int GetDimensionality();
225 
231  vtkIdType GetNumberOfNodes();
232 
241  vtkIdType GetNumberOfCells();
242 
253  vtkIdType GetNumberOfContinuumCells();
254 
260  vtkIdType GetNumberOfSolidCells();
261 
267  vtkIdType GetNumberOfThickShellCells();
268 
274  vtkIdType GetNumberOfShellCells();
275 
281  vtkIdType GetNumberOfRigidBodyCells();
282 
288  vtkIdType GetNumberOfRoadSurfaceCells();
289 
294  vtkIdType GetNumberOfBeamCells();
295 
301  vtkIdType GetNumberOfParticleCells();
302 
304 
309  vtkIdType GetNumberOfTimeSteps();
310  virtual void SetTimeStep( vtkIdType );
311  vtkIdType GetTimeStep();
312  double GetTimeValue( vtkIdType );
313  vtkGetVector2Macro(TimeStepRange,int);
314  vtkSetVector2Macro(TimeStepRange,int);
316 
318 
322  int GetNumberOfPointArrays();
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 );
328  int GetNumberOfComponentsInPointArray( int arr );
329  int GetNumberOfComponentsInPointArray( const char* arrName );
331 
333 
339  int GetNumberOfCellArrays( int cellType );
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 );
345  int GetNumberOfComponentsInCellArray( int cellType, int arr );
346  int GetNumberOfComponentsInCellArray( int cellType, const char* arrName );
348 
350 
354  int GetNumberOfSolidArrays();
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 
362  int GetNumberOfComponentsInSolidArray( int a );
363  int GetNumberOfComponentsInSolidArray( const char* arrName );
364 
366 
370  int GetNumberOfThickShellArrays();
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 
378  int GetNumberOfComponentsInThickShellArray( int a );
379  int GetNumberOfComponentsInThickShellArray( const char* arrName );
380 
382 
386  int GetNumberOfShellArrays();
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 
394  int GetNumberOfComponentsInShellArray( int a );
395  int GetNumberOfComponentsInShellArray( const char* arrName );
396 
398 
402  int GetNumberOfRigidBodyArrays();
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 
410  int GetNumberOfComponentsInRigidBodyArray( int a );
411  int GetNumberOfComponentsInRigidBodyArray( const char* arrName );
412 
414 
418  int GetNumberOfRoadSurfaceArrays();
419  const char* GetRoadSurfaceArrayName(int);
420  virtual void SetRoadSurfaceArrayStatus( int arr, int status );
421  virtual void SetRoadSurfaceArrayStatus( const char* arrName, int status );
422  int GetRoadSurfaceArrayStatus( int arr );
423  int GetRoadSurfaceArrayStatus( const char* arrName );
425 
426  int GetNumberOfComponentsInRoadSurfaceArray( int a );
427  int GetNumberOfComponentsInRoadSurfaceArray( const char* arrName );
428 
430 
434  int GetNumberOfBeamArrays();
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 
442  int GetNumberOfComponentsInBeamArray( int a );
443  int GetNumberOfComponentsInBeamArray( const char* arrName );
444 
446 
450  int GetNumberOfParticleArrays();
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 
458  int GetNumberOfComponentsInParticleArray( int a );
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 
525  int GetNumberOfPartArrays();
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 
563  vtkLSDynaReader();
564  virtual ~vtkLSDynaReader();
565 
574  int ReadHeaderInformation( int currentAdaptLevel );
575 
585  int ScanDatabaseTimeSteps();
586 
589 
591 
600  virtual int ReadTopology();
601  virtual int ReadNodes();
602  virtual int ReadPartSizes();
603  virtual int ReadConnectivityAndMaterial();
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 
628  virtual int ReadPartTitlesFromRootFile();
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 
672  void ResetPartsCache();
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
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:39
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::DeformedMesh
int DeformedMesh
Should deflected coordinates be used, or should the mesh remain undeflected? By default,...
Definition: vtkLSDynaReader.h:541
vtkLSDynaReader
Read LS-Dyna databases (d3plot)
Definition: vtkLSDynaReader.h:167
vtkLSDynaReader::GetCellArrayName
const char * GetCellArrayName(int cellType, int arr)
vtkLSDynaReader::GetShellArrayStatus
int GetShellArrayStatus(int arr)
vtkX3D::type
@ type
Definition: vtkX3D.h:516
vtkIdType
int vtkIdType
Definition: vtkType.h:287
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:41
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:41
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:54
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.
vtkLSDynaReader::DeletedCellsAsGhostArray
int DeletedCellsAsGhostArray
Definition: vtkLSDynaReader.h:549
vtkMultiBlockDataSetAlgorithm::RequestData
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
Definition: vtkMultiBlockDataSetAlgorithm.h:88
vtkLSDynaPartCollection
Definition: vtkLSDynaPartCollection.h:28
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::RemoveDeletedCells
int RemoveDeletedCells
Should cells marked as deleted be removed from the mesh? By default, this is true.
Definition: vtkLSDynaReader.h:548
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::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:39
vtkLSDynaReader::SetRoadSurfaceArrayStatus
virtual void SetRoadSurfaceArrayStatus(int arr, int status)
vtkLSDynaReader::GetParticleArrayName
const char * GetParticleArrayName(int)
vtkLSDynaReader::GetRoadSurfaceArrayName
const char * GetRoadSurfaceArrayName(int)
vtkX3D::size
@ size
Definition: vtkX3D.h:253
vtkMultiBlockDataSetAlgorithm.h
vtkLSDynaReader::GetRigidBodyArrayStatus
int GetRigidBodyArrayStatus(int arr)
vtkLSDynaReader::SetShellArrayStatus
virtual void SetShellArrayStatus(int arr, int status)
vtkDax::detail::cellType
CellTypeInDataSet cellType(vtkDataSet *input)
Definition: vtkDaxDetailCommon.h:36
vtkLSDynaReader::GetNumberOfSolidArrays
int GetNumberOfSolidArrays()
These methods allow you to load only selected subsets of the cell variables defined over the mesh.
vtkGetStringMacro
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
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.
vtkBooleanMacro
vtkBooleanMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:86
vtkLSDynaReader::SetParticleArrayStatus
virtual void SetParticleArrayStatus(int arr, int status)
vtkSetMacro
vtkSetMacro(IgnoreDriverBugs, bool)
Updates the extensions string.
vtkLSDynaReader::GetThickShellArrayStatus
int GetThickShellArrayStatus(int arr)
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:561
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:670
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
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:535
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