vtkLSDynaReader.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkLSDynaReader.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
/*----------------------------------------------------------------------------
 Copyright (c) Sandia Corporation
 See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
----------------------------------------------------------------------------*/
 
#ifndef vtkLSDynaReader_h
#define vtkLSDynaReader_h
 
#include "vtkIOLSDynaModule.h" // For export macro
#include "vtkLegacy.h"         // For VTK_LEGACY_REMOVE
#include "vtkMultiBlockDataSetAlgorithm.h"
#include <string> // for method signature
 
class LSDynaMetaData;
class vtkLSDynaPartCollection;
class vtkPoints;
class vtkDataArray;
class vtkUnsignedCharArray;
class vtkUnstructuredGrid;
 
class VTKIOLSDYNA_EXPORT vtkLSDynaReader : public vtkMultiBlockDataSetAlgorithm
{
public:
  vtkTypeMacro(vtkLSDynaReader, vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkLSDynaReader* New();
 
  void Dump(ostream& os);
 
  void DebugDump();
 
  virtual int CanReadFile(VTK_FILEPATH const char* fname);
 
 
  virtual void SetDatabaseDirectory(VTK_FILEPATH const std::string&);
  virtual void SetDatabaseDirectory(VTK_FILEPATH const char*);
#ifdef VTK_LEGACY_REMOVE
  VTK_FILEPATH std::string GetDatabaseDirectory();
#else
  VTK_LEGACY(VTK_FILEPATH const char* GetDatabaseDirectory());
#endif
  int IsDatabaseValid();
 
 
  virtual void SetFileName(VTK_FILEPATH const std::string&);
  virtual void SetFileName(VTK_FILEPATH const char*);
#ifdef VTK_LEGACY_REMOVE
  VTK_FILEPATH std::string GetFileName();
#else
  VTK_LEGACY(VTK_FILEPATH const char* GetFileName());
#endif
 
  char* GetTitle();
 
  int GetDimensionality();
 
  vtkIdType GetNumberOfNodes();
 
  vtkIdType GetNumberOfCells();
 
  vtkIdType GetNumberOfContinuumCells();
 
  vtkIdType GetNumberOfSolidCells();
 
  vtkIdType GetNumberOfThickShellCells();
 
  vtkIdType GetNumberOfShellCells();
 
  vtkIdType GetNumberOfRigidBodyCells();
 
  vtkIdType GetNumberOfRoadSurfaceCells();
 
  vtkIdType GetNumberOfBeamCells();
 
  vtkIdType GetNumberOfParticleCells();
 
 
  vtkIdType GetNumberOfTimeSteps();
  virtual void SetTimeStep(vtkIdType);
  vtkIdType GetTimeStep();
  double GetTimeValue(vtkIdType);
  vtkGetVector2Macro(TimeStepRange, int);
  vtkSetVector2Macro(TimeStepRange, int);
 
 
  int GetNumberOfPointArrays();
  const char* GetPointArrayName(int);
  virtual void SetPointArrayStatus(int arr, int status);
  virtual void SetPointArrayStatus(const char* arrName, int status);
  int GetPointArrayStatus(int arr);
  int GetPointArrayStatus(const char* arrName);
  int GetNumberOfComponentsInPointArray(int arr);
  int GetNumberOfComponentsInPointArray(const char* arrName);
 
 
  int GetNumberOfCellArrays(int cellType);
  const char* GetCellArrayName(int cellType, int arr);
  virtual void SetCellArrayStatus(int cellType, int arr, int status);
  virtual void SetCellArrayStatus(int cellType, const char* arrName, int status);
  int GetCellArrayStatus(int cellType, int arr);
  int GetCellArrayStatus(int cellType, const char* arrName);
  int GetNumberOfComponentsInCellArray(int cellType, int arr);
  int GetNumberOfComponentsInCellArray(int cellType, const char* arrName);
 
 
  int GetNumberOfSolidArrays();
  const char* GetSolidArrayName(int);
  virtual void SetSolidArrayStatus(int arr, int status);
  virtual void SetSolidArrayStatus(const char* arrName, int status);
  int GetSolidArrayStatus(int arr);
  int GetSolidArrayStatus(const char* arrName);
 
  int GetNumberOfComponentsInSolidArray(int a);
  int GetNumberOfComponentsInSolidArray(const char* arrName);
 
 
  int GetNumberOfThickShellArrays();
  const char* GetThickShellArrayName(int);
  virtual void SetThickShellArrayStatus(int arr, int status);
  virtual void SetThickShellArrayStatus(const char* arrName, int status);
  int GetThickShellArrayStatus(int arr);
  int GetThickShellArrayStatus(const char* arrName);
 
  int GetNumberOfComponentsInThickShellArray(int a);
  int GetNumberOfComponentsInThickShellArray(const char* arrName);
 
 
  int GetNumberOfShellArrays();
  const char* GetShellArrayName(int);
  virtual void SetShellArrayStatus(int arr, int status);
  virtual void SetShellArrayStatus(const char* arrName, int status);
  int GetShellArrayStatus(int arr);
  int GetShellArrayStatus(const char* arrName);
 
  int GetNumberOfComponentsInShellArray(int a);
  int GetNumberOfComponentsInShellArray(const char* arrName);
 
 
  int GetNumberOfRigidBodyArrays();
  const char* GetRigidBodyArrayName(int);
  virtual void SetRigidBodyArrayStatus(int arr, int status);
  virtual void SetRigidBodyArrayStatus(const char* arrName, int status);
  int GetRigidBodyArrayStatus(int arr);
  int GetRigidBodyArrayStatus(const char* arrName);
 
  int GetNumberOfComponentsInRigidBodyArray(int a);
  int GetNumberOfComponentsInRigidBodyArray(const char* arrName);
 
 
  int GetNumberOfRoadSurfaceArrays();
  const char* GetRoadSurfaceArrayName(int);
  virtual void SetRoadSurfaceArrayStatus(int arr, int status);
  virtual void SetRoadSurfaceArrayStatus(const char* arrName, int status);
  int GetRoadSurfaceArrayStatus(int arr);
  int GetRoadSurfaceArrayStatus(const char* arrName);
 
  int GetNumberOfComponentsInRoadSurfaceArray(int a);
  int GetNumberOfComponentsInRoadSurfaceArray(const char* arrName);
 
 
  int GetNumberOfBeamArrays();
  const char* GetBeamArrayName(int);
  virtual void SetBeamArrayStatus(int arr, int status);
  virtual void SetBeamArrayStatus(const char* arrName, int status);
  int GetBeamArrayStatus(int arr);
  int GetBeamArrayStatus(const char* arrName);
 
  int GetNumberOfComponentsInBeamArray(int a);
  int GetNumberOfComponentsInBeamArray(const char* arrName);
 
 
  int GetNumberOfParticleArrays();
  const char* GetParticleArrayName(int);
  virtual void SetParticleArrayStatus(int arr, int status);
  virtual void SetParticleArrayStatus(const char* arrName, int status);
  int GetParticleArrayStatus(int arr);
  int GetParticleArrayStatus(const char* arrName);
 
  int GetNumberOfComponentsInParticleArray(int a);
  int GetNumberOfComponentsInParticleArray(const char* arrName);
 
 
  void SetDeformedMesh(vtkTypeBool);
  vtkGetMacro(DeformedMesh, vtkTypeBool);
  vtkBooleanMacro(DeformedMesh, vtkTypeBool);
 
 
  vtkSetMacro(RemoveDeletedCells, vtkTypeBool);
  vtkGetMacro(RemoveDeletedCells, vtkTypeBool);
  vtkBooleanMacro(RemoveDeletedCells, vtkTypeBool);
 
 
  vtkSetMacro(DeletedCellsAsGhostArray, vtkTypeBool);
  vtkGetMacro(DeletedCellsAsGhostArray, vtkTypeBool);
  vtkBooleanMacro(DeletedCellsAsGhostArray, vtkTypeBool);
 
 
  vtkSetStringMacro(InputDeck);
  vtkGetStringMacro(InputDeck);
 
 
  int GetNumberOfPartArrays();
  const char* GetPartArrayName(int);
  virtual void SetPartArrayStatus(int arr, int status);
  virtual void SetPartArrayStatus(const char* partName, int status);
  int GetPartArrayStatus(int arr);
  int GetPartArrayStatus(const char* partName);
 
protected:
  // holds all the parts and all the properties for each part
  vtkLSDynaPartCollection* Parts;
 
  vtkTypeBool DeformedMesh;
 
 
  vtkTypeBool RemoveDeletedCells;
  vtkTypeBool DeletedCellsAsGhostArray;
 
  int TimeStepRange[2];
 
  char* InputDeck;
 
  vtkLSDynaReader();
  ~vtkLSDynaReader() override;
 
  int ReadHeaderInformation(int currentAdaptLevel);
 
  int ScanDatabaseTimeSteps();
 
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
 
  virtual int ReadTopology();
  virtual int ReadNodes();
  virtual int ReadPartSizes();
  virtual int ReadConnectivityAndMaterial();
  virtual int ReadUserIds();
  virtual int ReadState(vtkIdType);
  virtual int ReadNodeStateInfo(vtkIdType);
  virtual int ReadCellStateInfo(vtkIdType);
  virtual int ReadDeletion();
  virtual int ReadSPHState(vtkIdType);
  virtual int ComputeDeflectionAndUpdateGeometry(vtkUnstructuredGrid* grid);
 
  virtual void ResetPartInfo();
 
  virtual int ReadInputDeck();
 
  virtual int ReadPartTitlesFromRootFile();
 
  virtual int ReadUserMaterialIds();
 
 
  int ReadInputDeckXML(istream& deck);
  int ReadInputDeckKeywords(istream& deck);
 
  int WriteInputDeckSummary(const char* fname);
 
  virtual void ReadDeletionArray(vtkUnsignedCharArray* arr, const int& pos, const int& size);
 
  virtual void ReadCellProperties(const int& type, const int& numTuples);
 
  LSDynaMetaData* P;
 
  void ResetPartsCache();
 
private:
  // Helper templated methods to optimize reading. We cast the entire buffer
  // to a given type instead of casting each element to improve performance
  template <typename T>
  void FillDeletionArray(T* buffer, vtkUnsignedCharArray* arr, const vtkIdType& start,
    const vtkIdType& numCells, const int& deathPos, const int& cellSize);
 
  template <int wordSize, typename T>
  int FillTopology(T* buffer);
 
  template <typename T, int blockType, vtkIdType numWordsPerCell, vtkIdType cellLength>
  void ReadBlockCellSizes();
 
  template <typename T>
  int FillPartSizes();
 
  vtkLSDynaReader(const vtkLSDynaReader&) = delete;
  void operator=(const vtkLSDynaReader&) = delete;
};
 
inline void vtkLSDynaReader::SetPointArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfPointArrays(); ++a)
  {
    if (strcmp(arrName, this->GetPointArrayName(a)) == 0)
    {
      this->SetPointArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Point array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetPointArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfPointArrays(); ++a)
  {
    if (strcmp(arrName, this->GetPointArrayName(a)) == 0)
    {
      return this->GetPointArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInPointArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfPointArrays(); ++a)
  {
    if (strcmp(arrName, this->GetPointArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInPointArray(a);
    }
  }
  // vtkWarningMacro( "Point array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetCellArrayStatus(int cellType, const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfCellArrays(cellType); ++a)
  {
    if (strcmp(arrName, this->GetCellArrayName(cellType, a)) == 0)
    {
      this->SetCellArrayStatus(cellType, a, status);
      return;
    }
  }
  vtkWarningMacro("Cell array \"" << arrName << "\" (type " << cellType << ") does not exist");
}
 
inline int vtkLSDynaReader::GetCellArrayStatus(int cellType, const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfCellArrays(cellType); ++a)
  {
    if (strcmp(arrName, this->GetCellArrayName(cellType, a)) == 0)
    {
      return this->GetCellArrayStatus(cellType, a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInCellArray(int cellType, const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfCellArrays(cellType); ++a)
  {
    if (strcmp(arrName, this->GetCellArrayName(cellType, a)) == 0)
    {
      return this->GetNumberOfComponentsInCellArray(cellType, a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetSolidArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfSolidArrays(); ++a)
  {
    if (strcmp(arrName, this->GetSolidArrayName(a)) == 0)
    {
      this->SetSolidArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Solid array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetSolidArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfSolidArrays(); ++a)
  {
    if (strcmp(arrName, this->GetSolidArrayName(a)) == 0)
    {
      return this->GetSolidArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInSolidArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfSolidArrays(); ++a)
  {
    if (strcmp(arrName, this->GetSolidArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInSolidArray(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetThickShellArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfThickShellArrays(); ++a)
  {
    if (strcmp(arrName, this->GetThickShellArrayName(a)) == 0)
    {
      this->SetThickShellArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Thick shell array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetThickShellArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfThickShellArrays(); ++a)
  {
    if (strcmp(arrName, this->GetThickShellArrayName(a)) == 0)
    {
      return this->GetThickShellArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInThickShellArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfThickShellArrays(); ++a)
  {
    if (strcmp(arrName, this->GetThickShellArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInThickShellArray(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetShellArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfShellArrays(); ++a)
  {
    if (strcmp(arrName, this->GetShellArrayName(a)) == 0)
    {
      this->SetShellArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Shell array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetShellArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfShellArrays(); ++a)
  {
    if (strcmp(arrName, this->GetShellArrayName(a)) == 0)
    {
      return this->GetShellArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInShellArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfShellArrays(); ++a)
  {
    if (strcmp(arrName, this->GetShellArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInShellArray(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetBeamArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfBeamArrays(); ++a)
  {
    if (strcmp(arrName, this->GetBeamArrayName(a)) == 0)
    {
      this->SetBeamArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Beam array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetBeamArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfBeamArrays(); ++a)
  {
    if (strcmp(arrName, this->GetBeamArrayName(a)) == 0)
    {
      return this->GetBeamArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInBeamArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfBeamArrays(); ++a)
  {
    if (strcmp(arrName, this->GetBeamArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInBeamArray(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetParticleArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfParticleArrays(); ++a)
  {
    if (strcmp(arrName, this->GetParticleArrayName(a)) == 0)
    {
      this->SetParticleArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Particle array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetParticleArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfParticleArrays(); ++a)
  {
    if (strcmp(arrName, this->GetParticleArrayName(a)) == 0)
    {
      return this->GetParticleArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInParticleArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfParticleArrays(); ++a)
  {
    if (strcmp(arrName, this->GetParticleArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInParticleArray(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetRigidBodyArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfRigidBodyArrays(); ++a)
  {
    if (strcmp(arrName, this->GetRigidBodyArrayName(a)) == 0)
    {
      this->SetRigidBodyArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Rigid body array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetRigidBodyArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfRigidBodyArrays(); ++a)
  {
    if (strcmp(arrName, this->GetRigidBodyArrayName(a)) == 0)
    {
      return this->GetRigidBodyArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInRigidBodyArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfRigidBodyArrays(); ++a)
  {
    if (strcmp(arrName, this->GetRigidBodyArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInRigidBodyArray(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetRoadSurfaceArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfRoadSurfaceArrays(); ++a)
  {
    if (strcmp(arrName, this->GetRoadSurfaceArrayName(a)) == 0)
    {
      this->SetRoadSurfaceArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Road surface array \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetRoadSurfaceArrayStatus(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfRoadSurfaceArrays(); ++a)
  {
    if (strcmp(arrName, this->GetRoadSurfaceArrayName(a)) == 0)
    {
      return this->GetRoadSurfaceArrayStatus(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline int vtkLSDynaReader::GetNumberOfComponentsInRoadSurfaceArray(const char* arrName)
{
  for (int a = 0; a < this->GetNumberOfRoadSurfaceArrays(); ++a)
  {
    if (strcmp(arrName, this->GetRoadSurfaceArrayName(a)) == 0)
    {
      return this->GetNumberOfComponentsInRoadSurfaceArray(a);
    }
  }
  // vtkWarningMacro( "Cell array \"" << arrName << "\" does not exist" );
  return 0;
}
 
inline void vtkLSDynaReader::SetPartArrayStatus(const char* arrName, int status)
{
  for (int a = 0; a < this->GetNumberOfPartArrays(); ++a)
  {
    if (strcmp(arrName, this->GetPartArrayName(a)) == 0)
    {
      this->SetPartArrayStatus(a, status);
      return;
    }
  }
  vtkWarningMacro("Part \"" << arrName << "\" does not exist");
}
 
inline int vtkLSDynaReader::GetPartArrayStatus(const char* partName)
{
  for (int a = 0; a < this->GetNumberOfPartArrays(); ++a)
  {
    if (strcmp(partName, this->GetPartArrayName(a)) == 0)
    {
      return this->GetPartArrayStatus(a);
    }
  }
  // vtkWarningMacro( "PartArray \"" << partName << "\" does not exist" );
  return 0;
}
 
#endif // vtkLSDynaReader_h