vtkExodusIIWriter.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkExodusIIWriter.h,v $

  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 "vtkWriter.h"

#include <vtkstd/map> // For the map

class vtkUnstructuredGrid;
class vtkFloatArray;
class vtkDoubleArray;
class vtkDataArray;
class vtkUnsignedCharArray;
class vtkIntArray;
class vtkModelMetadata;

class VTK_PARALLEL_EXPORT vtkExodusIIWriter : public vtkWriter
{
public:
  static vtkExodusIIWriter *New();
  vtkTypeRevisionMacro(vtkExodusIIWriter,vtkWriter);
  void PrintSelf(ostream& os, vtkIndent indent);

  void SetInput(vtkUnstructuredGrid *ug);
  vtkUnstructuredGrid *GetInput();

  virtual void SetModelMetadata(vtkModelMetadata*);
  vtkGetObjectMacro(ModelMetadata, vtkModelMetadata);

  vtkModelMetadata* GetOrCreateModelMetadata();

  vtkSetStringMacro(FileName);
  vtkGetStringMacro(FileName);

  vtkSetMacro(StoreDoubles, int);
  vtkGetMacro(StoreDoubles, int);

  vtkSetMacro(GhostLevel, int);
  vtkGetMacro(GhostLevel, int);

  vtkSetStringMacro(BlockIdArrayName);
  vtkGetStringMacro(BlockIdArrayName);

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

  vtkSetStringMacro(GlobalNodeIdArrayName);
  vtkGetStringMacro(GlobalNodeIdArrayName);

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

  vtkSetStringMacro(GlobalElementIdArrayName);
  vtkGetStringMacro(GlobalElementIdArrayName);

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

  void SetTimeStepValues(int NumberOfTimeSteps, float *v);
  float *GetTimeStepValues(){return this->InputTimeStepValues;}
  int GetNumberOfTimeSteps(){return this->InputNumberOfTimeSteps;}

  void SetCurrentTimeStep(int ts);
  int GetCurrentTimeStep(){return this->InputCurrentTimeStep;}

  void SetAllBlockIds(int numEntries, int *blockIds);

  vtkSetMacro(ErrorStatus, int);
  vtkGetMacro(ErrorStatus, int);

protected:

  vtkExodusIIWriter();
  ~vtkExodusIIWriter();

  virtual int FillInputPortInformation(int port, vtkInformation* info);

  void WriteData();     

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

  vtkSetStringMacro(MyFileName);
  vtkGetStringMacro(MyFileName);


  vtkSetMacro(MyRank, int);
  vtkGetMacro(MyRank, int);

private:
  static char *StrDupWithNew(const char *s);

  void RemoveGhostCells();

  void SetPassDoubles();

  int CheckParameters();
  int CreateExodusModel();
  int CreateBlockIdInformationFromCellTypes(vtkModelMetadata *em);
  int CreateBlockIdInformation(vtkModelMetadata *em);

  static char **FlattenOutVariableNames(int narrays, int nScalarArrays, 
                                  char **nms, int *numComponents);
  static void CreateNamesForScalarArrays(const char *root, char **nms, 
                                         int numComponents);
  static char *GetCellTypeName(int t);
  static int FindCellType(int blockId, int *blockIdList, unsigned char *cellTypeList, 
                 int nCells);

  int CreateNewExodusFile();
  int OpenExodusFile();
  void CloseExodusFile();

  void InitializeVariableArrayNames();
  void ClearVariableArrayNames();
  void SetNewNodeVariableNames(vtkDataArray *da, char **nm);
  void SetNewElementVariableNames(vtkDataArray *da, char **nm);

  void InitializeBlockLists();
  void ClearBlockLists();
  int WriteBlockVariables();
//BTX
  vtkstd::map<int, int> *BuildBlockElementSearchStructure(int block);
//ETX

  int WriteInitializationParameters();
  int WriteQARecords();
  int WriteInformationRecords();
  int WritePoints();
  int WriteCoordinateNames();
  int WriteGlobalPointIds();
  int WriteGlobalElementIds();
  int WriteBlockInformation();
  int WriteVariableArrayNames();
  int WriteNodeSetInformation();
  int WriteSideSetInformation();
  int WriteProperties();

  int GetTimeStepIndex();
  float GetTimeStepValue(int timeStepIndex);
  int WriteNextTimeStep();
  float *ExtractComponentF(vtkDataArray *da, int comp, int *idx);
  double *ExtractComponentD(vtkDataArray *da, int comp, int *idx);

  vtkModelMetadata *ModelMetadata;

  int PassDoubles; // If set, we have to pass doubles to exodus library.
                   // If not set, we have to pass floats.
  int StoreDoubles;// If set, Exodus library will store doubles.
                   // If not set, Exodus library will store floats.
  int fid;

  char *FileName;    // base file name
  char *MyFileName;  // base plus number of processes and my rank  

  // The block IDs, the time step values, and the current time step index
  // may be provided if there is not vtkModelMetadata object.  The time
  // step may also be provided if only a subset (like every other one)
  // of the time steps are being written out.

  int *InputBlockIds;
  int InputBlockIdsLength;

  int InputNumberOfTimeSteps;
  float *InputTimeStepValues;
  int InputCurrentTimeStep;   
  int LastTimeStepWritten;

  // List of the global element ID of each cell in input

  char *GlobalElementIdArrayName;
  int *GlobalElementIdList;
//BTX
  vtkstd::map<int, int> *LocalElementIdMap;
//ETX
  int GetElementLocalId(int i);
  int WriteOutGlobalElementIdArray;

  // List of the global node ID of each cell in input

  char *GlobalNodeIdArrayName;
  int *GlobalNodeIdList;
//BTX
  vtkstd::map<int, int> *LocalNodeIdMap;
//ETX
  int GetNodeLocalId(int i);
  int WriteOutGlobalNodeIdArray;

  // Exodus II element blocks

  char *BlockIdArrayName;    // List of block ID of each cell in input
  int *BlockIdList;
  int WriteOutBlockIdArray;

  int NumberOfElementBlocks;
  int *BlockIds;             // list of every block ID in dataset
//BTX
  vtkstd::map<int, int> *LocalBlockIndexMap; // block ID -> block index
//ETX
  int GetBlockLocalIndex(int i);
  int *BlockElementStart;
  int *ElementIndex;

  char **BlockElementType;
  int *NumberOfElementsPerBlock;
  int *NumberOfNodesPerElementInBlock;
  int *NumberOfAttributesPerElementInBlock;
  float **BlockElementAttributesF;
  double **BlockElementAttributesD;
  int **BlockElementConnectivity;

  // 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);

  // Element variable arrays

  int NumberOfScalarElementArrays;
  char **InputElementArrayNames;    // input names (including vectors)
  char **OutputElementArrayNames;         // output names (all scalars)
  int *InputElementArrayComponent;

  // Point variable arrays

  int NumberOfScalarNodeArrays;
  char **InputNodeArrayNames;
  char **OutputNodeArrayNames;
  int *InputNodeArrayComponent;

  // Global application information

  int NumberOfProcesses;
  int MyRank;

  // The input less ghost cells

  vtkUnstructuredGrid *MyInput;

  // we don't use this variable - it's for ParaView

  int GhostLevel;

  int ErrorStatus;
};

#endif

---