v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


  Program:   Visualization Toolkit

  Module:    vtkExodusIIWriter.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 vtkExodusIIWriter_h

#define vtkExodusIIWriter_h


#include "vtkIOExodusModule.h" // For export macro

#include "vtkWriter.h"

#include "vtkSmartPointer.h" // For vtkSmartPointer


#include <vector> // STL Header

#include <map>    // STL Header

#include <string> // STL Header


class vtkModelMetadata;

class vtkDoubleArray;

class vtkIntArray;

class vtkUnstructuredGrid;


class VTKIOEXODUS_EXPORT vtkExodusIIWriter : public vtkWriter

{

public:

  static vtkExodusIIWriter *New ();

  vtkTypeMacro(vtkExodusIIWriter,vtkWriter);

  void PrintSelf (ostream& os, vtkIndent indent);


  void SetModelMetadata (vtkModelMetadata*);

  vtkGetObjectMacro(ModelMetadata, vtkModelMetadata);


  vtkSetStringMacro(FileName);

  vtkGetStringMacro(FileName);


  vtkSetMacro(StoreDoubles, int);

  vtkGetMacro(StoreDoubles, int);


  vtkSetMacro(GhostLevel, int);

  vtkGetMacro(GhostLevel, int);


  vtkSetMacro(WriteOutBlockIdArray, int);

  vtkGetMacro(WriteOutBlockIdArray, int);

  vtkBooleanMacro(WriteOutBlockIdArray, int);


  vtkSetMacro(WriteOutGlobalNodeIdArray, int);

  vtkGetMacro(WriteOutGlobalNodeIdArray, int);

  vtkBooleanMacro(WriteOutGlobalNodeIdArray, int);


  vtkSetMacro(WriteOutGlobalElementIdArray, int);

  vtkGetMacro(WriteOutGlobalElementIdArray, int);

  vtkBooleanMacro(WriteOutGlobalElementIdArray, int);


  vtkSetMacro(WriteAllTimeSteps, int);

  vtkGetMacro(WriteAllTimeSteps, int);

  vtkBooleanMacro(WriteAllTimeSteps, int);


  vtkSetStringMacro(BlockIdArrayName);

  vtkGetStringMacro(BlockIdArrayName);


protected:

  vtkExodusIIWriter ();

  ~vtkExodusIIWriter ();


  vtkModelMetadata* ModelMetadata;


  char *BlockIdArrayName;


  char *FileName;

  int fid;


  int NumberOfProcesses;

  int MyRank;


  int PassDoubles;


  int StoreDoubles;

  int GhostLevel;

  int WriteOutBlockIdArray;

  int WriteOutGlobalNodeIdArray;

  int WriteOutGlobalElementIdArray;

  int WriteAllTimeSteps;

  int NumberOfTimeSteps;


  vtkDoubleArray* TimeValues;

  int CurrentTimeIndex;

  int FileTimeOffset;

  bool TopologyChanged;


//BTX

  vtkDataObject *OriginalInput;

  std::vector< vtkSmartPointer<vtkUnstructuredGrid> > FlattenedInput;

  std::vector< vtkSmartPointer<vtkUnstructuredGrid> > NewFlattenedInput;


  std::vector< vtkIntArray* > BlockIdList;


  struct Block

  {

    Block ()

      {

      this->Type = 0;

      this->NumElements = 0;

      this->ElementStartIndex = -1;

      this->NodesPerElement = 0;

      this->EntityCounts = std::vector<int>();

      this->EntityNodeOffsets = std::vector<int>();

      this->GridIndex = 0;

      this->OutputIndex = -1;

      this->NumAttributes = 0;

      this->BlockAttributes = 0;

      };

    int Type;

    int NumElements;

    int ElementStartIndex;

    int NodesPerElement;

    std::vector<int> EntityCounts;

    std::vector<int> EntityNodeOffsets;

    size_t GridIndex;

    // std::vector<int> CellIndex;

    int OutputIndex;

    int NumAttributes;

    float *BlockAttributes; // Owned by metamodel or null.  Don't delete.

  };

  std::map<int, Block> BlockInfoMap;

  int NumCells, NumPoints, MaxId;


  std::vector<vtkIdType*> GlobalElementIdList;

  std::vector<vtkIdType*> GlobalNodeIdList;

//ETX

  int AtLeastOneGlobalElementIdList;

  int AtLeastOneGlobalNodeIdList;


//BTX

  struct VariableInfo

  {

    int NumComponents;

    int InIndex;

    int ScalarOutOffset;

    std::vector<std::string> OutNames;

  };

  std::map<std::string, VariableInfo> GlobalVariableMap;

  std::map<std::string, VariableInfo> BlockVariableMap;

  std::map<std::string, VariableInfo> NodeVariableMap;

  int NumberOfScalarGlobalArrays;

  int NumberOfScalarElementArrays;

  int NumberOfScalarNodeArrays;

//ETX


//BTX

  std::vector< std::vector<int> > CellToElementOffset;

//ETX

  // By BlockId, and within block ID by element variable, with variables

  // appearing in the same order in which they appear in OutputElementArrayNames


  int *BlockElementVariableTruthTable;

  int AllVariablesDefinedInAllBlocks;


  int BlockVariableTruthValue(int blockIdx, int varIdx);


//BTX

  char *StrDupWithNew (const char *s);

  void StringUppercase (std::string& str);

//ETX


  int ProcessRequest (vtkInformation* request,

                      vtkInformationVector** inputVector,

                      vtkInformationVector* outputVector);


  int RequestInformation (vtkInformation* request,

                          vtkInformationVector** inputVector,

                          vtkInformationVector* outputVector);


  virtual int RequestUpdateExtent (vtkInformation* request,

                                   vtkInformationVector** inputVector,

                                   vtkInformationVector* outputVector);


  int FillInputPortInformation (int port, vtkInformation* info);


  int RequestData (vtkInformation* request,

                   vtkInformationVector** inputVector,

                   vtkInformationVector* outputVector);


  void WriteData ();


  int FlattenHierarchy (vtkDataObject* input, bool& changed);


  int CreateNewExodusFile ();

  void CloseExodusFile ();


  int IsDouble ();

  void RemoveGhostCells ();

  int CheckParametersInternal (int NumberOfProcesses, int MyRank);

  virtual int CheckParameters ();

  // If writing in parallel multiple time steps exchange after each time step

  // if we should continue the execution. Pass local continueExecution as a

  // parameter and return the global continueExecution.

  virtual int GlobalContinueExecuting(int localContinueExecution);

  int CheckInputArrays ();

  virtual void CheckBlockInfoMap();

  int ConstructBlockInfoMap ();

  int ConstructVariableInfoMaps ();

  int ParseMetadata ();

  int CreateDefaultMetadata ();

  char *GetCellTypeName (int t);


  int CreateBlockIdMetadata(vtkModelMetadata *em);

  int CreateBlockVariableMetadata (vtkModelMetadata* em);

  int CreateSetsMetadata (vtkModelMetadata* em);


//BTX

  void ConvertVariableNames (std::map<std::string, VariableInfo>& variableMap);

  char **FlattenOutVariableNames (

            int nScalarArrays,

            const std::map<std::string, VariableInfo>& variableMap);

  std::string CreateNameForScalarArray (const char *root,

                                           int component,

                                           int numComponents);


  std::map<vtkIdType, vtkIdType> *LocalNodeIdMap;

  std::map<vtkIdType, vtkIdType> *LocalElementIdMap;

//ETX

  vtkIdType GetNodeLocalId(vtkIdType id);

  vtkIdType GetElementLocalId(vtkIdType id);

  int GetElementType(vtkIdType id);


  int WriteInitializationParameters ();

  int WriteInformationRecords ();

  int WritePoints ();

  int WriteCoordinateNames ();

  int WriteGlobalPointIds ();

  int WriteBlockInformation ();

  int WriteGlobalElementIds ();

  int WriteVariableArrayNames ();

  int WriteNodeSetInformation ();

  int WriteSideSetInformation ();

  int WriteProperties ();

  int WriteNextTimeStep ();

  vtkIntArray* GetBlockIdArray (

    const char* BlockIdArrayName, vtkUnstructuredGrid* input);

  static bool SameTypeOfCells (vtkIntArray* cellToBlockId,

                               vtkUnstructuredGrid* input);


//BTX

  double ExtractGlobalData (const char *name, int comp, int ts);

  int WriteGlobalData (int timestep, vtkDataArray *buffer);

  void ExtractCellData (const char *name, int comp, vtkDataArray *buffer);

  int WriteCellData (int timestep, vtkDataArray *buffer);

  void ExtractPointData (const char *name, int comp, vtkDataArray *buffer);

  int WritePointData (int timestep, vtkDataArray *buffer);

//ETX


private:

  vtkExodusIIWriter (const vtkExodusIIWriter&); // Not Implemented

  void operator= (const vtkExodusIIWriter&); // Not Implemented

};


#endif