SIMoutput.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _SIM_OUTPUT_H
#define _SIM_OUTPUT_H
 
#include "SIMinput.h"
#include "Vec3.h"
 
class ElementBlock;
class VTF;
 
 
class SIMoutput : public SIMinput
{
protected:
  explicit SIMoutput(IntegrandBase* itg);
 
public:
  virtual ~SIMoutput();
 
  virtual void clearProperties();
 
  using SIMinput::parse;
  virtual bool parse(char* keyWord, std::istream& is);
 
  virtual bool merge(SIMbase* that, const std::map<int,int>* old2new, int poff);
 
  bool getElementSet(int iset, std::string& name, RealArray& elSet) const;
 
protected:
  virtual bool parseOutputTag(const tinyxml2::XMLElement* elem);
 
  virtual ElementBlock* tesselatePatch(size_t pidx) const;
 
public:
  virtual bool writeGlvG(int& nBlock, const char* inpFile, bool doClear = true);
 
  bool writeGlvG(int& nBlock, double time);
 
  virtual bool writeGlvA(int&, int, double, int = 1) const { return true; }
 
  bool writeGlvBC(int& nBlock, int iStep = 1) const;
 
  bool writeGlvNo(int& nBlock, int& idBlock,
                  int maxBlock = 20, int iStep = 1) const;
 
  bool writeGlvT(int iStep, int& geoBlk, int& nBlock) const;
 
  bool writeGlvV(const RealArray& vec, const char* fieldName,
                 int iStep, int& nBlock, int idBlock = 2, int ncmp = 0) const;
 
  bool writeGlvS(const Vector& scl, const char* fieldName,
                 int iStep, int& nBlock, int idBlock = 2) const;
 
  bool writeGlvS(const Vector& psol, int iStep, int& nBlock, double time = 0.0,
                 const char* pvecName = nullptr, int idBlock = 10,
                 int psolComps = 0);
 
  virtual int writeGlvS1(const Vector& psol, int iStep, int& nBlock,
                         double time = 0.0, const char* pvecName = nullptr,
                         int idBlock = 10, int psolComps = 0,
                         bool scalarOnly = false);
 
  virtual int writeGlvS2(const Vector& psol, int iStep, int& nBlock,
                         double time = 0.0, int idBlock = 20,
                         int psolComps = 0);
 
  bool eval2ndSolution(const Vector& psol, double time, int psolComps = 0);
 
  bool writeGlvP(const RealArray& ssol, int iStep, int& nBlock,
                 int idBlock = 100, const char* prefix = "Global projected",
                 std::vector<PointValues>* maxVal = nullptr);
 
  bool writeGlvM(const Mode& mode, bool freq, int& nBlock);
 
  bool writeGlvE(const Vector& field, int iStep, int& nBlock,
                 const char* name, int idBlock = 300,
                 bool internalOrder = false) const;
 
  bool writeGlvN(const Matrix& norms, int iStep, int& nBlock,
                 const std::vector<std::string>& prefix = {},
                 int idBlock = 200, const char* dualPrefix = nullptr);
 
  bool writeGlvF(const RealFunc& f, const char* fname, int iStep, int& nBlock,
                 const Vector* state = nullptr,
                 int idBlock = 50, double time = 0.0,
                 const ASMbase* patch = nullptr);
 
  bool writeGlvStep(int iStep, double value = 0.0, int itype = 0);
 
  void closeGlv();
 
  VTF* getVTF() const { return myVtf; }
  void setVTF(VTF* vtf) { myVtf = vtf; }
 
  int getStartGeo() const { return myGeomID; }
  void setStartGeo(int gID) { myGeomID = gID; }
 
  bool dumpMatlabGrid(std::ostream& os, const std::string& name = "IFEM_Mesh",
                      const std::vector<std::string>& sets = {},
                      double scale = 1.0) const;
 
  bool dumpGeometry(std::ostream& os) const;
 
  void dumpPrimSol(const Vector& psol, utl::LogStream& os,
                   bool withID = true) const;
  bool dumpSolution(const Vector& psol, utl::LogStream& os) const;
  bool dumpResults(const Vector& psol, double time, utl::LogStream& os,
                   bool formatted = false, std::streamsize precision = 3) const;
  bool dumpVector(const Vector& vsol, const char* fname,
                  utl::LogStream& os, std::streamsize precision = 3) const;
  virtual void dumpMoreResults(double, utl::LogStream&,
                               std::streamsize = 3) const {}
 
  bool savePoints(const Vector& psol, double time, int step) const;
 
  bool saveResults(const Vectors& psol, double time, int step) const;
 
  bool hasResultPoints() const { return !myPoints.empty(); }
  bool hasPointResultFile() const;
  void setPointResultFile(const std::string& filename, bool dumpCoord = false);
 
  virtual bool serialize(std::map<std::string,std::string>&) const;
 
  virtual double getReferenceNorm(const Vectors&, size_t) const = 0;
  virtual double getEffectivityIndex(const Vectors&, size_t, size_t) const = 0;
  virtual void printNorms(const Vectors&, size_t = 36) const = 0;
  virtual void printIFforces(const Vector&, RealArray&) {}
  virtual int printNRforces(const IntVec& glbNodes = {}) const;
 
protected:
  void addAddFunc(const std::string& fn, RealFunc* f) { myAddScalars[fn] = f; }
 
  virtual bool writeAddFuncs(int& nBlock, int& idBlock, const Vector& psol,
                             int iStep, double time);
 
private:
  bool initPatchForEvaluation(int patchNo) const;
 
  bool extractNodeVec(const RealArray& glbVec, Vector& locVec,
                      const ASMbase* patch, int nodalCmps,
                      bool& emptyPatches) const;
 
  bool writeScalarFields(const Matrix& field, int geomID, int& nBlock,
                         std::vector<IntVec>& sID, size_t* nScl = nullptr,
                         ASM::ResultClass resClass = ASM::PRIMARY);
 
protected:
  std::map<int,int> addDisBlk; 
 
  struct ResultPoint
  {
    short int    npar;  
    unsigned int patch; 
    double       u[3];  
    Vec3         X;     
 
    int inod; 
    int iel;  
 
    ResultPoint(short int n = 0) : npar(n), patch(1), inod(0), iel(0)
    { u[0] = u[1] = u[2] = 0.0; }
  };
 
  using ResPointVec = std::vector<ResultPoint>;
  using ResPtPair = std::pair<std::string,ResPointVec>;
 
  std::vector<ResPtPair> myPoints; 
 
  virtual void preprocessResultPoints();
 
private:
  void preprocessResPtGroup(std::string& ptFile, ResPointVec& points);
 
  bool dumpResults(const Vector& psol, double time,
                   utl::LogStream& os, const ResPointVec& gPoints,
                   bool formatted, std::streamsize precision) const;
 
  bool evalResults(const Vectors& psol, const ResPointVec& gPoints,
                   const ASMbase* patch, IntVec& points, IntVec& elms,
                   Vec3Vec& Xp, Matrix& sol1, Matrix& sol2,
                   std::vector<std::string>* compNames = nullptr) const;
 
  std::map<std::string,RealFunc*> myAddScalars; 
 
  std::set<std::string> wantComps; 
 
  int    myPrec;   
  double myPtSize; 
  int    myGeomID; 
  int    myGeofs1; 
  int    myGeofs2; 
  VTF*   myVtf;    
  bool   mergeVtf; 
  bool   logRpMap; 
  int    idxGrid;  
};
 
#endif