vtkPEnSightReader.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkPEnSightReader.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.

  =========================================================================*/
#ifndef vtkPEnSightReader_h
#define vtkPEnSightReader_h

#include "vtkPGenericEnSightReader.h"
#include "vtkPVVTKExtensionsIOEnSightModule.h" //needed for exports

#include "vtkIdTypeArray.h" // For ivars
#include <algorithm>        // For ivars
#include <map>              // For ivars
#include <map>              // For ivars
#include <string>           // For ivars
#include <string>           // For ivars
#include <vector>           // For ivars

class vtkDataSet;
class vtkIdList;
class vtkMultiBlockDataSet;
class vtkInformation;
class vtkInformationVector;
class vtkUnsignedCharArray;
class vtkUnstructuredGrid;
class vtkFloatArray;
class vtkPEnSightReaderCellIdsType;

#define NEXTMODULO3(x) (x == 0) ? 1 : ((x == 1) ? 2 : 0)

class VTKPVVTKEXTENSIONSIOENSIGHT_EXPORT vtkPEnSightReader : public vtkPGenericEnSightReader
{
public:
  vtkTypeMacro(vtkPEnSightReader, vtkPGenericEnSightReader);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  //----------------------------------------------------------------------------
  // PointIds and CellIds must be stored in a different way:
  // std::vector in non distributed mode
  // std::map in distributed mode
  // note: Ensight Ids are INTEGERS, not longs
  class vtkPEnSightReaderCellIds
  {

  public:
    typedef std::map<int, int> IntIntMap;
    typedef std::vector<int> IntVector;

    vtkPEnSightReaderCellIds()
      : cellMap(NULL)
      , cellNumberOfIds(-1)
      , cellLocalNumberOfIds(-1)
      , cellVector(NULL)
      , ImplicitDimensions(NULL)
      , ImplicitLocalDimensions(NULL)
      , ImplicitSplitDimension(-1)
      , ImplicitSplitDimensionBeginIndex(-1)
      , ImplicitSplitDimensionEndIndex(-1)
      , mode(NON_SPARSE_MODE)
    {
    }

    vtkPEnSightReaderCellIds(EnsightReaderCellIdMode amode)
      : cellMap(NULL)
      , cellNumberOfIds(-1)
      , cellLocalNumberOfIds(-1)
      , cellVector(NULL)
      , ImplicitDimensions(NULL)
      , ImplicitLocalDimensions(NULL)
      , ImplicitSplitDimension(-1)
      , ImplicitSplitDimensionBeginIndex(-1)
      , ImplicitSplitDimensionEndIndex(-1)
      , mode(amode)
    {
      if (this->mode == SPARSE_MODE)
      {
        this->cellMap = new IntIntMap;
        this->cellNumberOfIds = 0;
        this->cellVector = NULL;
      }
      else if (this->mode == IMPLICIT_STRUCTURED_MODE)
      {
        this->ImplicitDimensions = new int[3];
        this->ImplicitSplitDimension = -1;
        this->ImplicitSplitDimensionBeginIndex = -1;
        this->ImplicitSplitDimensionEndIndex = -1;
      }
      else
      {
        this->cellMap = NULL;
        this->cellVector = new IntVector;
        this->cellNumberOfIds = -1;
        this->cellLocalNumberOfIds = -1;
      }
    }

    ~vtkPEnSightReaderCellIds()
    {
      delete this->cellMap;
      delete this->cellVector;
      delete[] this->ImplicitDimensions;
    }

    void SetMode(EnsightReaderCellIdMode amode)
    {
      this->mode = amode;
      if (this->mode == SPARSE_MODE)
      {
        this->cellMap = new IntIntMap;
        this->cellNumberOfIds = 0;
        this->cellVector = NULL;
      }
      else if (this->mode == IMPLICIT_STRUCTURED_MODE)
      {
        this->ImplicitDimensions = new int[3];
        this->ImplicitSplitDimension = -1;
        this->ImplicitSplitDimensionBeginIndex = -1;
        this->ImplicitSplitDimensionEndIndex = -1;
      }
      else
      {
        this->cellMap = NULL;
        this->cellVector = new IntVector;
        this->cellNumberOfIds = -1;
        this->cellLocalNumberOfIds = -1;
      }
    }

    void SetImplicitDimensions(int dim1, int dim2, int dim3)
    {
      this->ImplicitDimensions[0] = dim1;
      this->ImplicitDimensions[1] = dim2;
      this->ImplicitDimensions[2] = dim3;
    }

    void SetImplicitSplitDimension(int dim) { this->ImplicitSplitDimension = dim; }

    void SetImplicitSplitDimensionBeginIndex(int begin)
    {
      this->ImplicitSplitDimensionBeginIndex = begin;
    }

    void SetImplicitSplitDimensionEndIndex(int end) { this->ImplicitSplitDimensionEndIndex = end; }

    // return -1 if not found
    int GetId(int id)
    {
      switch (this->mode)
      {
        case SINGLE_PROCESS_MODE:
        {
          // Single Process compatibility
          return id;
          break;
        }
        case IMPLICIT_STRUCTURED_MODE:
        {
          if (this->ImplicitSplitDimension == -1)
            return -1; // not initialized

          // Compute the global i j k index
          // id = i + j * dim[0] + k * dim[1] * dim[0]
          int index[3];
          index[2] = id / (this->ImplicitDimensions[0] * this->ImplicitDimensions[1]); // k
          index[1] = (id - (index[2] * this->ImplicitDimensions[0] * this->ImplicitDimensions[1])) /
            this->ImplicitDimensions[0]; // j
          index[0] = id - index[1] * this->ImplicitDimensions[0] -
            index[2] * this->ImplicitDimensions[1] * this->ImplicitDimensions[0]; // i
          if ((index[this->ImplicitSplitDimension] < this->ImplicitSplitDimensionBeginIndex) ||
            (index[this->ImplicitSplitDimension] >= this->ImplicitSplitDimensionEndIndex))
          {
            // not for me
            return -1;
          }
          else
          {
            // Compute the local id
            int localIndex[3];
            int localDim[3];
            int dim = this->ImplicitSplitDimension;
            localIndex[dim] = index[dim] - this->ImplicitSplitDimensionBeginIndex;
            localDim[dim] =
              this->ImplicitSplitDimensionEndIndex - this->ImplicitSplitDimensionBeginIndex;
            dim = NEXTMODULO3(dim);
            localIndex[dim] = index[dim];
            localDim[dim] = this->ImplicitDimensions[dim];
            dim = NEXTMODULO3(dim);
            localDim[dim] = this->ImplicitDimensions[dim];
            localIndex[dim] = index[dim];
            return localIndex[0] + localDim[0] * localIndex[1] +
              localDim[0] * localDim[1] * localIndex[2];
          }
        }
        case SPARSE_MODE:
        {
          std::map<int, int>::iterator it = this->cellMap->find(id);
          if (it == this->cellMap->end())
            return -1;
          else
            return (*this->cellMap)[id];
          break;
        }
        default:
        {
          if (this->cellVector->size() > (unsigned int)(id))
            return (*this->cellVector)[id];
          break;
        }
      }
      return -1;
    }

    void SetId(int id, int value)
    {
      switch (this->mode)
      {
        case SINGLE_PROCESS_MODE:
        case IMPLICIT_STRUCTURED_MODE:
        {
          // Compatibility Only
          // do noting
          break;
        }
        case SPARSE_MODE:
        {
          std::map<int, int>::iterator it = this->cellMap->find(id);
          if (it == this->cellMap->end())
            this->cellNumberOfIds++;

          (*this->cellMap)[id] = value;
          break;
        }
        default:
        {
          if (this->cellVector->size() < (unsigned int)(id + 1))
          {
            int k;
            int currentSize = static_cast<int>(this->cellVector->size());
            this->cellVector->resize(id + 1);
            for (k = currentSize; k < id; k++)
            {
              (*this->cellVector)[k] = -1;
            }
            (*this->cellVector)[id] = value;
          }
          else
          {
            (*this->cellVector)[id] = value;
          }
          break;
        }
      }
    }

    // In distributed mode, if id == -1, do not insert it in map
    int InsertNextId(int id)
    {
      switch (this->mode)
      {
        case SINGLE_PROCESS_MODE:
        case IMPLICIT_STRUCTURED_MODE:
        {
          // Single Process compatibility
          // do noting
          break;
        }
        case SPARSE_MODE:
        {
          if (id != -1)
          {
            (*this->cellMap)[this->cellNumberOfIds] = id;
          }
          // increment fake number of ids
          this->cellNumberOfIds++;
          return this->cellNumberOfIds - 1;
          break;
        }
        default:
        {
          this->cellVector->push_back(id);
          return static_cast<int>(this->cellVector->size() - 1);
          break;
        }
      }
      return static_cast<int>(this->cellVector->size() - 1);
    }

    int GetNumberOfIds()
    {
      switch (this->mode)
      {
        case SINGLE_PROCESS_MODE:
        {
          // Single Process compatibility
          return this->cellNumberOfIds;
          break;
        }
        case IMPLICIT_STRUCTURED_MODE:
        {
          return this->cellNumberOfIds;
        }
        case SPARSE_MODE:
        {
          return this->cellNumberOfIds;
          break;
        }
        default:
        {
          break;
        }
      }

      // Point Ids are directly injected in the vector,
      // contrary to cell Ids which are "stacked" with
      // InsertNextId. So the real total number of Ids
      // for Points cannot be the size of the vector.
      // So we must inject it manually
      if (this->cellNumberOfIds >= 0)
      {
        return this->cellNumberOfIds;
      }

      return static_cast<int>(this->cellVector->size());
    }

    // Just inject the real total number of Ids
    void SetNumberOfIds(int n)
    {
      if (this->mode == SPARSE_MODE)
      {
        // do nothing
      }
      else
      {
        // Non sparse Or Single Process
        this->cellNumberOfIds = n;
      }
    }

    void SetLocalNumberOfIds(int n)
    {
      if (this->mode == SPARSE_MODE)
      {
        // do nothing
      }
      else
      {
        // Non sparse Or Single Process
        // Used for Structured compatibility
        this->cellLocalNumberOfIds = n;
      }
    }

    void Reset()
    {
      if (this->mode == SPARSE_MODE)
      {
        this->cellMap->clear();
        this->cellNumberOfIds = 0;
      }
      else
      {
        if (this->mode == NON_SPARSE_MODE)
          this->cellVector->clear();
        if (this->cellNumberOfIds >= 0)
          this->cellNumberOfIds = -1;
        if (this->cellLocalNumberOfIds >= 0)
          this->cellLocalNumberOfIds = -1;
      }
    }

    int GetLocalNumberOfIds()
    {
      switch (this->mode)
      {
        case SINGLE_PROCESS_MODE:
        {
          // Single Process compatibility
          return this->cellNumberOfIds;
          break;
        }
        case IMPLICIT_STRUCTURED_MODE:
        {
          return this->cellLocalNumberOfIds;
        }
        case SPARSE_MODE:
        {
          return static_cast<int>(this->cellMap->size());
          break;
        }
        default:
        {
          break;
        }
      }

      // Return cellLocalNumberOfIds if valid
      if (this->cellLocalNumberOfIds >= 0)
      {
        return this->cellLocalNumberOfIds;
      }

      // Else compute the real size
      int result = 0;
      for (unsigned int i = 0; i < this->cellVector->size(); i++)
      {
        if ((*this->cellVector)[i] != -1)
          result++;
      }
      return result;
    }

    vtkIdTypeArray* GenerateGlobalIdsArray(const char* name)
    {
      // Generate a sorted Array For Global Ids
      // Your local Ids must be consistent !
      if (this->mode == IMPLICIT_STRUCTURED_MODE)
      {
        vtkIdTypeArray* array = vtkIdTypeArray::New();
        array->SetNumberOfComponents(1);
        array->SetName(name);
        int localDim[3];

        int dim = this->ImplicitSplitDimension;
        localDim[dim] =
          this->ImplicitSplitDimensionEndIndex - this->ImplicitSplitDimensionBeginIndex;
        dim = NEXTMODULO3(dim);
        localDim[dim] = this->ImplicitDimensions[dim];
        dim = NEXTMODULO3(dim);
        localDim[dim] = this->ImplicitDimensions[dim];
        array->SetNumberOfTuples(localDim[0] * localDim[1] * localDim[2]);

        int index = 0;
        for (int k = 0; k < this->ImplicitDimensions[2]; k++)
        {
          for (int j = 0; j < this->ImplicitDimensions[1]; j++)
          {
            for (int i = 0; i < this->ImplicitDimensions[0]; i++)
            {
              int n = (this->ImplicitSplitDimension == 0)
                ? i
                : ((this->ImplicitSplitDimension == 1) ? j : k);
              if ((n >= this->ImplicitSplitDimensionBeginIndex) &&
                (n < this->ImplicitSplitDimensionEndIndex))
              {
                vtkIdType nn = n;
                array->SetTypedTuple(index, &nn);
                index++;
              }
            }
          }
        }
        return array;
      }
      else
      {
        int i;
        vtkIdTypeArray* array = vtkIdTypeArray::New();
        array->SetNumberOfComponents(1);
        array->SetName(name);
        array->SetNumberOfTuples(this->GetLocalNumberOfIds());
        int min = 1000000000;
        int max = -1;
        for (i = 0; i < this->GetNumberOfIds(); i++)
        {
          int id = this->GetId(i);
          if (id != -1)
          {
            vtkIdType ii = i;
            if (ii < min)
              min = ii;
            if (ii > max)
              max = ii;
            array->SetTypedTuple(id, &ii);
          }
        }
        return array;
      }
    }

  protected:
    IntIntMap* cellMap;
    int cellNumberOfIds;
    int cellLocalNumberOfIds;
    IntVector* cellVector;
    // Implicit Structured Real (global) dimensions
    int* ImplicitDimensions;
    // Implicit Structured local dimensions
    int* ImplicitLocalDimensions;
    // Implicit Structured Split Dimension
    int ImplicitSplitDimension;
    // Implicit Structured Split Dimension Begin Index. Inclusive
    int ImplicitSplitDimensionBeginIndex;
    // Implicit StructuredSplit Dimension End Index. Exclusive
    int ImplicitSplitDimensionEndIndex;

    EnsightReaderCellIdMode mode;
  };

  enum ElementTypesList
  {
    POINT = 0,
    BAR2 = 1,
    BAR3 = 2,
    NSIDED = 3,
    TRIA3 = 4,
    TRIA6 = 5,
    QUAD4 = 6,
    QUAD8 = 7,
    NFACED = 8,
    TETRA4 = 9,
    TETRA10 = 10,
    PYRAMID5 = 11,
    PYRAMID13 = 12,
    HEXA8 = 13,
    HEXA20 = 14,
    PENTA6 = 15,
    PENTA15 = 16,
    NUMBER_OF_ELEMENT_TYPES = 17
  };

  enum VariableTypesList
  {
    SCALAR_PER_NODE = 0,
    VECTOR_PER_NODE = 1,
    TENSOR_SYMM_PER_NODE = 2,
    SCALAR_PER_ELEMENT = 3,
    VECTOR_PER_ELEMENT = 4,
    TENSOR_SYMM_PER_ELEMENT = 5,
    SCALAR_PER_MEASURED_NODE = 6,
    VECTOR_PER_MEASURED_NODE = 7,
    COMPLEX_SCALAR_PER_NODE = 8,
    COMPLEX_VECTOR_PER_NODE = 9,
    COMPLEX_SCALAR_PER_ELEMENT = 10,
    COMPLEX_VECTOR_PER_ELEMENT = 11
  };

  enum SectionTypeList
  {
    COORDINATES = 0,
    BLOCK = 1,
    ELEMENT = 2
  };


  vtkGetStringMacro(MeasuredFileName);


  vtkGetStringMacro(MatchFileName);

protected:
  vtkPEnSightReader();
  ~vtkPEnSightReader() override;

  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  /*int RequestUpdateExtent(
    vtkInformation *vtkNotUsed(request),
    vtkInformationVector **inputVector,
    vtkInformationVector *outputVector);
  */


  vtkSetStringMacro(MeasuredFileName);


  vtkSetStringMacro(MatchFileName);


  int ReadCaseFile();
  int ReadCaseFileGeometry(char* line);
  int ReadCaseFileVariable(char* line);
  int ReadCaseFileTime(char* line);
  int ReadCaseFileFile(char* line);

  // set in UpdateInformation to value returned from ReadCaseFile
  int CaseFileRead;

  virtual int ReadGeometryFile(
    const char* fileName, int timeStep, vtkMultiBlockDataSet* output) = 0;

  virtual int ReadMeasuredGeometryFile(
    const char* fileName, int timeStep, vtkMultiBlockDataSet* output) = 0;

  int ReadVariableFiles(vtkMultiBlockDataSet* output);

  virtual int ReadScalarsPerNode(const char* fileName, const char* description, int timeStep,
    vtkMultiBlockDataSet* output, int measured = 0, int numberOfComponents = 1,
    int component = 0) = 0;

  virtual int ReadVectorsPerNode(const char* fileName, const char* description, int timeStep,
    vtkMultiBlockDataSet* output, int measured = 0) = 0;

  virtual int ReadTensorsPerNode(
    const char* fileName, const char* description, int timeStep, vtkMultiBlockDataSet* output) = 0;

  virtual int ReadScalarsPerElement(const char* fileName, const char* description, int timeStep,
    vtkMultiBlockDataSet* output, int numberOfComponents = 1, int component = 0) = 0;

  virtual int ReadVectorsPerElement(
    const char* fileName, const char* description, int timeStep, vtkMultiBlockDataSet* output) = 0;

  virtual int ReadTensorsPerElement(
    const char* fileName, const char* description, int timeStep, vtkMultiBlockDataSet* output) = 0;

  virtual int CreateUnstructuredGridOutput(
    int partId, char line[80], const char* name, vtkMultiBlockDataSet* output) = 0;

  virtual int CreateStructuredGridOutput(
    int partId, char line[80], const char* name, vtkMultiBlockDataSet* output) = 0;

  void AddVariableFileName(const char* fileName1, const char* fileName2 = NULL);

  void AddVariableDescription(const char* description);

  void AddVariableType();

  int GetElementType(const char* line);

  int GetSectionType(const char* line);

  void ReplaceWildcards(char* filename, int num);

  void RemoveLeadingBlanks(char* line);

  vtkPEnSightReaderCellIds* GetCellIds(int index, int cellType);


  vtkIdType GetTotalNumberOfCellIds(int index);
  vtkIdType GetLocalTotalNumberOfCellIds(int index);

  vtkPEnSightReaderCellIds* GetPointIds(int index);

  void AddToBlock(vtkMultiBlockDataSet* output, unsigned int blockNo, vtkDataSet* dataset);

  vtkDataSet* GetDataSetFromBlock(vtkMultiBlockDataSet* output, unsigned int blockNo);

  void SetBlockName(vtkMultiBlockDataSet* output, unsigned int blockNo, const char* name);


  void InsertNextCellAndId(vtkUnstructuredGrid*, int vtkCellType, vtkIdType numPoints,
    vtkIdType* points, int partId, int ensightCellType, vtkIdType globalId, vtkIdType numElements,
    const std::vector<vtkIdType>& faces = {});
  void InsertVariableComponent(vtkFloatArray* array, int i, int component, float* content,
    int partId, int ensightCellType, int insertionType);

  void MapToGlobalIds(
    const vtkIdType* inputIds, vtkIdType numPoints, int partId, vtkIdType* globalIds);

  void PrepareStructuredDimensionsForDistribution(int partId, int* oldDimensions,
    int* newDimensions, int* splitDimension, int* splitDimensionBeginIndex, int ghostLevel,
    vtkUnsignedCharArray* pointGhostArray, vtkUnsignedCharArray* cellGhostArray);

  char* MeasuredFileName;
  char* MatchFileName; // may not actually be necessary to read this file

  // pointer to lists of list (cell ids per element type per part)
  vtkPEnSightReaderCellIdsType* CellIds;

  // pointer to lists of list (point ids per element type per part)
  vtkPEnSightReaderCellIdsType* PointIds;

  // part ids of unstructured outputs
  vtkIdList* UnstructuredPartIds;
  // part ids of structured outputs
  vtkIdList* StructuredPartIds;

  bool CoordinatesAtEnd;
  bool InjectGlobalElementIds;
  bool InjectGlobalNodeIds;
  int LastPointId;

  int VariableMode;

  // pointers to lists of filenames
  char** VariableFileNames; // non-complex
  char** ComplexVariableFileNames;

  // array of time sets
  vtkIdList* VariableTimeSetIds;
  vtkIdList* ComplexVariableTimeSetIds;

  // array of file sets
  vtkIdList* VariableFileSetIds;
  vtkIdList* ComplexVariableFileSetIds;

  // collection of filename numbers per time set
  vtkIdListCollection* TimeSetFileNameNumbers;
  vtkIdList* TimeSetsWithFilenameNumbers;

  // collection of filename numbers per file set
  vtkIdListCollection* FileSetFileNameNumbers;
  vtkIdList* FileSetsWithFilenameNumbers;

  // collection of number of steps per file per file set
  vtkIdListCollection* FileSetNumberOfSteps;

  // ids of the time and file sets
  vtkIdList* TimeSetIds;
  vtkIdList* FileSets;

  int GeometryTimeSet;
  int GeometryFileSet;
  int MeasuredTimeSet;
  int MeasuredFileSet;

  float GeometryTimeValue;
  float MeasuredTimeValue;

  int UseTimeSets;
  vtkSetMacro(UseTimeSets, int);
  vtkGetMacro(UseTimeSets, int);
  vtkBooleanMacro(UseTimeSets, int);

  int UseFileSets;
  vtkSetMacro(UseFileSets, int);
  vtkGetMacro(UseFileSets, int);
  vtkBooleanMacro(UseFileSets, int);

  int NumberOfGeometryParts;

  // global list of points for measured geometry
  int NumberOfMeasuredPoints;

  int NumberOfNewOutputs;
  int InitialRead;

  int CheckOutputConsistency();

  double ActualTimeValue;

  int GhostLevels;

  std::map<std::string, std::map<int, long> > FileOffsets;

private:
  vtkPEnSightReader(const vtkPEnSightReader&) = delete;
  void operator=(const vtkPEnSightReader&) = delete;
};

#endif