VTF.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _VTF_H
#define _VTF_H
 
#include <vector>
#include <cstddef>
 
class ElementBlock;
class RealFunc;
class Tensor;
class Vec3;
 
using Vec3Pair  = std::pair<Vec3,Vec3>; 
using IntPair   = std::pair<int,int>;   
using GridBlock = std::pair<IntPair,const ElementBlock*>; 
 
class VTFAFile;
class VTFAStateInfoBlock;
class VTFATransformationBlock;
class VTFADisplacementBlock;
class VTFAVectorBlock;
class VTFAScalarBlock;
class VTFAGeometryBlock;
 
#if HAS_VTFAPI == 2
class VTFXAFile;
class VTFXADatabase;
class VTFXAStateInfoBlock;
class VTFXAResultBlock;
class VTFXAGeometryBlock;
#define VTFAFile                VTFXAFile
#define VTFAStateInfoBlock      VTFXAStateInfoBlock
#define VTFATransformationBlock VTFXAResultBlock
#define VTFADisplacementBlock   VTFXAResultBlock
#define VTFAVectorBlock         VTFXAResultBlock
#define VTFAScalarBlock         VTFXAResultBlock
#define VTFAGeometryBlock       VTFXAGeometryBlock
#endif
 
 
class VTF
{
public:
  VTF(const char* filename, int type);
  VTF(const VTF&) = delete;
  ~VTF();
 
  bool writeGrid(const ElementBlock* block, const char* gName,
                 int elemID, int nodeID = 0);
 
  bool writeTransformation(const Vec3& X, const Tensor& T,
                           int idBlock = 1, int gID = 1);
  bool writeNres(const std::vector<Real>& nodalResult,
                 int idBlock = 1, int geomID = 1);
  bool writeEres(const std::vector<Real>& elementResult,
                 int idBlock = 1, int geomID = 1);
  bool writeVres(const std::vector<Real>& nodeResult,
                 int idBlock = 1, int geomID = 1, size_t nvc = 0);
  bool writeNfunc(const RealFunc& f, const Real* u = nullptr,
                  Real time = Real(0), int idBlock = 1, int gID = 1);
  bool writeVectors(const std::vector<Vec3Pair>& pntResult, int& gID,
                    int idBlock = 1, const char* resultName = nullptr,
                    int iStep = 0, int iBlock = 1);
  bool writePoints(const std::vector<Vec3>& points, int& gID);
 
  bool writeSblk(int sBlockID, const char* resultName = nullptr,
                 int idBlock = 1, int iStep = 1, bool elementData = false);
  bool writeSblk(const std::vector<int>& sBlockIDs,
                 const char* resultName = nullptr, int idBlock = 1,
                 int iStep = 1, bool elementData = false);
  bool writeVblk(int vBlockID, const char* resultName = nullptr,
                 int idBlock = 1, int iStep = 1);
  bool writeVblk(const std::vector<int>& vBlockIDs,
                 const char* resultName = nullptr,
                 int idBlock = 1, int iStep = 1);
  bool writeDblk(const std::vector<int>& dBlockIDs,
                 const char* resultName = nullptr,
                 int idBlock = 1, int iStep = 1);
  bool writeTblk(const std::vector<int>& tBlockIDs,
                 const char* resultName = nullptr,
                 int idBlock = 1, int iStep = 1);
 
  bool writeState(int iStep, const char* fmt, Real refValue, int refType = 0);
 
  const ElementBlock* getBlock(int geomID) const;
  int getNodeBlock(int geomID) const;
 
  void writeGeometryBlocks(int iStep);
  void clearGeometryBlocks();
 
private:
  bool writeNodes(int iBlockID);
  bool writeElements(const char* partName, int partID,
                     int iBlockID, int iNodeBlockID);
 
public:
  static Real vecOffset[3]; 
 
private:
  VTFAFile* myFile; 
#if HAS_VTFAPI == 2
  VTFXADatabase* myDatabase; 
#endif
  VTFAStateInfoBlock* myState; 
  VTFAGeometryBlock* myGBlock; 
  std::vector<VTFATransformationBlock*> myTBlock; 
  std::vector<VTFADisplacementBlock*>   myDBlock; 
  std::vector<VTFAVectorBlock*>         myVBlock; 
  std::vector<VTFAScalarBlock*>         mySBlock; 
 
  int myPartID;                    
  int pointGeoID;                  
  int lastStep;                    
  std::vector<GridBlock> myBlocks; 
};
 
#endif