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  void PrintSelf(ostream &os, vtkIndent indent) override;
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(vtkTypeBool);
468  vtkGetMacro(DeformedMesh,vtkTypeBool);
469  vtkBooleanMacro(DeformedMesh,vtkTypeBool);
471 
473 
483  vtkSetMacro(RemoveDeletedCells,vtkTypeBool);
484  vtkGetMacro(RemoveDeletedCells,vtkTypeBool);
485  vtkBooleanMacro(RemoveDeletedCells,vtkTypeBool);
487 
489 
493  vtkSetMacro(DeletedCellsAsGhostArray,vtkTypeBool);
494  vtkGetMacro(DeletedCellsAsGhostArray,vtkTypeBool);
495  vtkBooleanMacro(DeletedCellsAsGhostArray,vtkTypeBool);
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  ~vtkLSDynaReader() override;
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 );
610  virtual int ComputeDeflectionAndUpdateGeometry(vtkUnstructuredGrid* grid);
612 
616  virtual void ResetPartInfo();
617 
622  virtual int ReadInputDeck();
623 
629  virtual int ReadPartTitlesFromRootFile();
630 
636  virtual int ReadUserMaterialIds();
637 
639 
643  int ReadInputDeckXML( ifstream& deck );
644  int ReadInputDeckKeywords( ifstream& deck );
646 
651  int WriteInputDeckSummary( const char* fname );
652 
664  virtual void ReadDeletionArray(vtkUnsignedCharArray* arr, const int& pos, const int& size);
665 
669  virtual void ReadCellProperties(const int& type,const int& numTuples);
670 
672 
673  void ResetPartsCache();
674 private:
675 
676  //Helper templated methods to optimize reading. We cast the entire buffer
677  //to a given type instead of casting each element to improve performance
678  template<typename T>
679  void FillDeletionArray(T* buffer, vtkUnsignedCharArray* arr, const vtkIdType& start, const vtkIdType& numCells,
680  const int& deathPos, const int& cellSize);
681 
682  template<int wordSize, typename T>
683  int FillTopology(T* buffer);
684 
685  template<typename T, int blockType, vtkIdType numWordsPerCell, vtkIdType cellLength>
686  void ReadBlockCellSizes();
687 
688  template<typename T>
689  int FillPartSizes();
690 
691  vtkLSDynaReader( const vtkLSDynaReader& ) = delete;
692  void operator = ( const vtkLSDynaReader& ) = delete;
693 };
694 
695 inline void vtkLSDynaReader::SetPointArrayStatus( const char* arrName, int status )
696 {
697  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
698  {
699  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
700  {
701  this->SetPointArrayStatus( a, status );
702  return;
703  }
704  }
705  vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
706 }
707 
708 inline int vtkLSDynaReader::GetPointArrayStatus( const char* arrName )
709 {
710  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
711  {
712  if ( strcmp( arrName, this->GetPointArrayName(a) ) == 0 )
713  {
714  return this->GetPointArrayStatus( a );
715  }
716  }
717  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
718  return 0;
719 }
720 
721 inline int vtkLSDynaReader::GetNumberOfComponentsInPointArray( const char* arrName )
722 {
723  for ( int a=0; a<this->GetNumberOfPointArrays(); ++a )
724  {
725  if ( strcmp( arrName, this->GetPointArrayName( a ) ) == 0 )
726  {
727  return this->GetNumberOfComponentsInPointArray( a );
728  }
729  }
730  //vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
731  return 0;
732 }
733 
734 inline void vtkLSDynaReader::SetCellArrayStatus( int cellType, const char* arrName, int status )
735 {
736  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
737  {
738  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
739  {
740  this->SetCellArrayStatus( cellType, a, status );
741  return;
742  }
743  }
744  vtkWarningMacro( "Cell array \"" << arrName << "\" (type " << cellType << ") does not exist" );
745 }
746 
747 inline int vtkLSDynaReader::GetCellArrayStatus( int cellType, const char* arrName )
748 {
749  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
750  {
751  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
752  {
753  return this->GetCellArrayStatus( cellType, a );
754  }
755  }
756  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
757  return 0;
758 }
759 
760 inline int vtkLSDynaReader::GetNumberOfComponentsInCellArray( int cellType, const char* arrName )
761 {
762  for ( int a=0; a<this->GetNumberOfCellArrays( cellType ); ++a )
763  {
764  if ( strcmp( arrName, this->GetCellArrayName( cellType, a ) ) == 0 )
765  {
766  return this->GetNumberOfComponentsInCellArray( cellType, a );
767  }
768  }
769  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
770  return 0;
771 }
772 
773 inline void vtkLSDynaReader::SetSolidArrayStatus( const char* arrName, int status )
774 {
775  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
776  {
777  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
778  {
779  this->SetSolidArrayStatus( a, status );
780  return;
781  }
782  }
783  vtkWarningMacro( "Solid array \"" << arrName << "\" does not exist" );
784 }
785 
786 inline int vtkLSDynaReader::GetSolidArrayStatus( const char* arrName )
787 {
788  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
789  {
790  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
791  {
792  return this->GetSolidArrayStatus( a );
793  }
794  }
795  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
796  return 0;
797 }
798 
799 inline int vtkLSDynaReader::GetNumberOfComponentsInSolidArray( const char* arrName )
800 {
801  for ( int a=0; a<this->GetNumberOfSolidArrays(); ++a )
802  {
803  if ( strcmp( arrName, this->GetSolidArrayName(a) ) == 0 )
804  {
805  return this->GetNumberOfComponentsInSolidArray( a );
806  }
807  }
808  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
809  return 0;
810 }
811 
812 inline void vtkLSDynaReader::SetThickShellArrayStatus( const char* arrName, int status )
813 {
814  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
815  {
816  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
817  {
818  this->SetThickShellArrayStatus( a, status );
819  return;
820  }
821  }
822  vtkWarningMacro( "Thick shell array \"" << arrName << "\" does not exist" );
823 }
824 
825 inline int vtkLSDynaReader::GetThickShellArrayStatus( const char* arrName )
826 {
827  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
828  {
829  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
830  {
831  return this->GetThickShellArrayStatus( a );
832  }
833  }
834  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
835  return 0;
836 }
837 
839 {
840  for ( int a=0; a<this->GetNumberOfThickShellArrays(); ++a )
841  {
842  if ( strcmp( arrName, this->GetThickShellArrayName(a) ) == 0 )
843  {
844  return this->GetNumberOfComponentsInThickShellArray( a );
845  }
846  }
847  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
848  return 0;
849 }
850 
851 inline void vtkLSDynaReader::SetShellArrayStatus( const char* arrName, int status )
852 {
853  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
854  {
855  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
856  {
857  this->SetShellArrayStatus( a, status );
858  return;
859  }
860  }
861  vtkWarningMacro( "Shell array \"" << arrName << "\" does not exist" );
862 }
863 
864 inline int vtkLSDynaReader::GetShellArrayStatus( const char* arrName )
865 {
866  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
867  {
868  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
869  {
870  return this->GetShellArrayStatus( a );
871  }
872  }
873  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
874  return 0;
875 }
876 
877 inline int vtkLSDynaReader::GetNumberOfComponentsInShellArray( const char* arrName )
878 {
879  for ( int a=0; a<this->GetNumberOfShellArrays(); ++a )
880  {
881  if ( strcmp( arrName, this->GetShellArrayName(a) ) == 0 )
882  {
883  return this->GetNumberOfComponentsInShellArray( a );
884  }
885  }
886  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
887  return 0;
888 }
889 
890 inline void vtkLSDynaReader::SetBeamArrayStatus( const char* arrName, int status )
891 {
892  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
893  {
894  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
895  {
896  this->SetBeamArrayStatus( a, status );
897  return;
898  }
899  }
900  vtkWarningMacro( "Beam array \"" << arrName << "\" does not exist" );
901 }
902 
903 inline int vtkLSDynaReader::GetBeamArrayStatus( const char* arrName )
904 {
905  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
906  {
907  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
908  {
909  return this->GetBeamArrayStatus( a );
910  }
911  }
912  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
913  return 0;
914 }
915 
916 inline int vtkLSDynaReader::GetNumberOfComponentsInBeamArray( const char* arrName )
917 {
918  for ( int a=0; a<this->GetNumberOfBeamArrays(); ++a )
919  {
920  if ( strcmp( arrName, this->GetBeamArrayName(a) ) == 0 )
921  {
922  return this->GetNumberOfComponentsInBeamArray( a );
923  }
924  }
925  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
926  return 0;
927 }
928 
929 inline void vtkLSDynaReader::SetParticleArrayStatus( const char* arrName, int status )
930 {
931  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
932  {
933  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
934  {
935  this->SetParticleArrayStatus( a, status );
936  return;
937  }
938  }
939  vtkWarningMacro( "Particle array \"" << arrName << "\" does not exist" );
940 }
941 
942 inline int vtkLSDynaReader::GetParticleArrayStatus( const char* arrName )
943 {
944  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
945  {
946  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
947  {
948  return this->GetParticleArrayStatus( a );
949  }
950  }
951  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
952  return 0;
953 }
954 
956 {
957  for ( int a=0; a<this->GetNumberOfParticleArrays(); ++a )
958  {
959  if ( strcmp( arrName, this->GetParticleArrayName(a) ) == 0 )
960  {
961  return this->GetNumberOfComponentsInParticleArray( a );
962  }
963  }
964  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
965  return 0;
966 }
967 
968 inline void vtkLSDynaReader::SetRigidBodyArrayStatus( const char* arrName, int status )
969 {
970  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
971  {
972  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
973  {
974  this->SetRigidBodyArrayStatus( a, status );
975  return;
976  }
977  }
978  vtkWarningMacro( "Rigid body array \"" << arrName << "\" does not exist" );
979 }
980 
981 inline int vtkLSDynaReader::GetRigidBodyArrayStatus( const char* arrName )
982 {
983  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
984  {
985  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
986  {
987  return this->GetRigidBodyArrayStatus( a );
988  }
989  }
990  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
991  return 0;
992 }
993 
995 {
996  for ( int a=0; a<this->GetNumberOfRigidBodyArrays(); ++a )
997  {
998  if ( strcmp( arrName, this->GetRigidBodyArrayName(a) ) == 0 )
999  {
1000  return this->GetNumberOfComponentsInRigidBodyArray( a );
1001  }
1002  }
1003  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1004  return 0;
1005 }
1006 
1007 inline void vtkLSDynaReader::SetRoadSurfaceArrayStatus( const char* arrName, int status )
1008 {
1009  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1010  {
1011  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1012  {
1013  this->SetRoadSurfaceArrayStatus( a, status );
1014  return;
1015  }
1016  }
1017  vtkWarningMacro( "Road surface array \"" << arrName << "\" does not exist" );
1018 }
1019 
1020 inline int vtkLSDynaReader::GetRoadSurfaceArrayStatus( const char* arrName )
1021 {
1022  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1023  {
1024  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1025  {
1026  return this->GetRoadSurfaceArrayStatus( a );
1027  }
1028  }
1029  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1030  return 0;
1031 }
1032 
1034 {
1035  for ( int a=0; a<this->GetNumberOfRoadSurfaceArrays(); ++a )
1036  {
1037  if ( strcmp( arrName, this->GetRoadSurfaceArrayName(a) ) == 0 )
1038  {
1039  return this->GetNumberOfComponentsInRoadSurfaceArray( a );
1040  }
1041  }
1042  //vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
1043  return 0;
1044 }
1045 
1046 inline void vtkLSDynaReader::SetPartArrayStatus( const char* arrName, int status )
1047 {
1048  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1049  {
1050  if ( strcmp( arrName, this->GetPartArrayName(a) ) == 0 )
1051  {
1052  this->SetPartArrayStatus( a, status );
1053  return;
1054  }
1055  }
1056  vtkWarningMacro( "Part \"" << arrName << "\" does not exist" );
1057 }
1058 
1059 inline int vtkLSDynaReader::GetPartArrayStatus( const char* partName )
1060 {
1061  for ( int a=0; a<this->GetNumberOfPartArrays(); ++a )
1062  {
1063  if ( strcmp( partName, this->GetPartArrayName(a) ) == 0 )
1064  {
1065  return this->GetPartArrayStatus( a );
1066  }
1067  }
1068  //vtkWarningMacro( "PartArray \"" << partName << "\" does not exist" );
1069  return 0;
1070 }
1071 
1072 #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::RemoveDeletedCells
vtkTypeBool RemoveDeletedCells
Should cells marked as deleted be removed from the mesh? By default, this is true.
Definition: vtkLSDynaReader.h:548
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
Definition: vtkX3D.h:516
vtkIdType
int vtkIdType
Definition: vtkType.h:347
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.
vtkMultiBlockDataSetAlgorithm::RequestData
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
Definition: vtkMultiBlockDataSetAlgorithm.h:91
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:541
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
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:86
vtkLSDynaReader::SetParticleArrayStatus
virtual void SetParticleArrayStatus(int arr, int status)
vtkLSDynaReader::GetThickShellArrayStatus
int GetThickShellArrayStatus(int arr)
vtkLSDynaReader::DeletedCellsAsGhostArray
vtkTypeBool DeletedCellsAsGhostArray
Definition: vtkLSDynaReader.h:549
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:87
vtkLSDynaReader::GetNumberOfComponentsInPointArray
int GetNumberOfComponentsInPointArray(int arr)
vtkLSDynaReader::P
LSDynaMetaData * P
Definition: vtkLSDynaReader.h:671
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:83
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: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:35