SM_XDMF.h

Go to the documentation of this file.

#ifndef SM_XDMF_H
#define SM_XDMF_H
 
//base class header
#include "SM_VTK.h"
 
//file header
#include "CORE_OutputFile.h"
 
//vector header
#include <vector>
 
class SM_XDMF : public SM_VTK  {
  
    // ATTRIBUTES
 
 
private:
 
    // the format of the data
    tString mFormat;
    tString mName;
    tString mExternalFileName;
 
 
    //output stream
    CORE_UniquePointer<CORE_OutputFile> mFile;
    
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_XDMF(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~SM_XDMF(void);   
  
  
 
public:
    inline static CORE_UniquePointer<SM_XDMF> New() {
        return CORE_UniquePointer<SM_XDMF>(new SM_XDMF(),SM_XDMF::Delete());
    };
    inline static CORE_UniquePointer<SM_XDMF> New(const tString& format) {
        CORE_UniquePointer<SM_XDMF>  p=New();
        p->setFormat(format);
        return p;
    };
 
      //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_VTK::getContentsMemorySize();
        mem+=mFormat.size();
        mem+=mName.size();
        mem+=mExternalFileName.size();
        mem+=(mFile.get()==null)?0:mFile->getContentsMemorySize();
        return mem;
        
    }
    
    //Virtual classes for writing  VTK files
    //======================================
     
    virtual tBoolean open() override;
    
 
    virtual tBoolean open(const tIndex& t) override {
        
        return true;
    }
  
    
    virtual tBoolean writeGeometryHeader(const tIndex&t,const SM_Network& network) override;
    
    virtual tBoolean writeGeometryData(const tIndex& t,const SM_Network& network) override;
    
    virtual tBoolean writeContentHeader(const tIndex& t,
                                        const tFlag& support,
                                        const std::vector<tString>& scalarNames,
                                        const std::vector<tString>& vectorNames) override;
    
    virtual tBoolean writeContentData(const tIndex& t,
                                      const SM_Network& network,
                                      const tFlag& support,
                                      const tString& name,
                                      const tReal* f) override;
 
    virtual tBoolean writeContentFooter(const tIndex& t,const tFlag& support) override;
    
 
    virtual tBoolean writeGeometryFooter(const tIndex& t)override;
 
   
    
    virtual tBoolean close(const tIndex& t) override {
        return true;
    }
    
    virtual tBoolean close() override;
       
    inline void setExternalFileName(const tString& f) {
        mExternalFileName=f;
    }
    
public:
    inline void setFormat(const tString& f) {
        mFormat=f;
    }
 
 
    
protected:
 
    //XDMF writing method
    //===================
    
    inline const tString& getFormat() const {
        return mFormat;
    }
    inline const tString& getExternalFileName() const {
        return mExternalFileName;
    }
 
protected:
    virtual tBoolean writeVertices(CORE_OutputFile& file,
                                   const SM_Network& mesh,
                                   const tString& tag) const;
    
    virtual tBoolean writeVertices(CORE_OutputFile& file,
                                   const SM_Network& mesh) {
        return writeVertices(file,mesh,"");
    }
    virtual tBoolean writeConnectivity(CORE_OutputFile& file,
                                       const tIndex& nVertexCells,const tIndex& nEdgeCells,
                                       const std::valarray<tUInt>& neighborsNumber,
                                       const std::valarray<tIndex>& neighborIndices,
                                       const tString& tagN) const;
 
    virtual tBoolean writeConnectivity(CORE_OutputFile& file,
                                       const tIndex& nVertexCells,const tIndex& nEdgeCells,
                                       const std::valarray<tUInt>& neighbors,
                                       const std::valarray<tIndex>& neighborIndices) const {
        return writeConnectivity(file,nVertexCells,nEdgeCells,neighbors,neighborIndices,"");
    }
    
        
   
    virtual tBoolean writeField(CORE_OutputFile& file,
                                const tIndex& t,
                                const tFlag& contentType,
                                const tString& name,
                                const tString& tagName,
                                const tIndex& n,
                                const tDimension& dim,
                                const tReal* f) const;
    
    
    virtual tBoolean writeField(CORE_OutputFile& file,
                                const tIndex& t,
                                const tFlag& contentType,
                                const tString& name,
                                const tIndex& n,
                                const tDimension& dim,
                                const tReal* f) const {
        return writeField(file,t,contentType,name,"",n,dim,f);
    }
 
    
  
    
   
   
 
 
    
};
 
#endif