SM_XDMF.h

#ifndef SM_XDMF_H
#define SM_XDMF_H
 
 
//constants header
#include "SM_Constants.h"
 
//base class header
#include "SM_VTK.h"
 
//file header
#include "CORE_OutputFile.h"
 
 
class SM_XDMF : public SM_VTK<SM_XDMF>  {
  
    // ATTRIBUTES
 
public:
    static const tFlag XML;
    static const tFlag HDF;
   
 
private:
    static const tString FILE_TYPES[];
    
    // the format of the data
    tFlag mFormat;
    tString mName;
    tString mExternalFileName;
 
 
    //output stream
    CORE_UniquePointer<CORE_OutputFile> mFile;
    
  
public:
    // 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 tFlag& 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+=mName.size();
        mem+=mExternalFileName.size();
        mem+=(mFile.get()==null)?0:mFile->getContentsMemorySize();
        return mem;
        
    }
 
 
    //set & get methods
    //==================
public:
    inline void setExternalFileName(const tString& f) {
        mExternalFileName=f;
    }
    
    inline void setFormat(const tFlag& f) {
        mFormat=f;
    }
 
      
    inline const tFlag& getFormat() const {
        return mFormat;
    }
    inline const tString& getExternalFileName() const {
        return mExternalFileName;
    }
 
    
    
    //Virtual templated classes for writing  VTK files
    //=================================================
public:
    inline tBoolean open()  {
        //get the file name
        tString fileName=getFileName();
        //set the extension
        tString xdmfFile=fileName+".xmf";
        
        //open the file
        if (!mFile->open(xdmfFile)) return false;
        
        //file is open
        setIsFileOpened(true);
        
        //get the  file
        CORE_OutputFile &f=*mFile.get();
        
        //write the header
        f<<"<?xml version=\"1.0\" encoding=\"utf-8\"?>"<<"\n";
        f<<"<Xdmf xmlns:xi=\"http://www.w3.org/2001/XInclude\" Version=\"3.3\">"<<"\n";
        f<<"\t<Domain>"<<"\n";
        f<<"\t\t<Grid CollectionType=\"Temporal\" GridType=\"Collection\" Name=\"Collection\">"<<"\n";
        
        
        return true;
    }
    
 
    inline tBoolean open(const tIndex& t){
        
        return true;
    }
  
    
    inline tBoolean writeGeometryHeader(const tIndex& it,const SM_Network& network)  {
        tBoolean succeeds=true;
        //write the connectivity of the mesh
        if (it==0) {
            //get the  file
            CORE_OutputFile &f=*mFile.get();
            
            tString tab="\t\t\t";
            
            //write the number of cellules
            
            //compute the number of  particles without connection
            tIndex nAloneParticles=network.computeAloneParticlesNumber();
            
            
            f<<tab<<"<Topology name=\"topology\" Dimensions=\""<<nAloneParticles+network.getHaloParticlesNumber()+ network.getNeighboringParticlesList().size()<<"\" Type=\"Mixed\">"<<"\n";
            //write the connectivity
            succeeds = succeeds && WriteConnectivity(f,
                                                     mFormat,getExternalFileName(),
                                                     nAloneParticles,network.getHaloParticlesNumber(),
                                                     network.getNeighboringParticlesNumberOffset(),
                                                     network.getNeighboringParticlesList(),"");
            f<<tab<<"</Topology>"<<"\n";
        }
        return succeeds;
    }
    
    inline  tBoolean writeGeometryData(const tIndex& t,const SM_Network& network) {
           
        tBoolean succeeds=true;
        
        if (t==0) {
            //get the  file
            CORE_OutputFile &f=*mFile.get();
            
            tString tab="\t\t\t";
            f<<tab<<"<Geometry name=\"geometry\" Type=\"XYZ\">"<<"\n";
            succeeds = succeeds && WriteVertices(f,mFormat,getExternalFileName(),network,"");
            f<<tab<<"</Geometry>"<<"\n";
        }
        return succeeds;
    
    }
    
    inline tBoolean writeContentHeader(const tIndex& t,
                                       const tFlag& support,
                                       const std::vector<tString>& scalarNames,
                                       const std::vector<tString>& vectorNames)  {
        return true;
    }
    
    inline tBoolean writeContentData(const tReal& t,
                                     const SM_Network& network,
                                     const tFlag& support,
                                     const tString& name,const tReal& alpha,
                                     const tReal* f)  {
        tBoolean ok=true;
        tString tab="\t\t\t";
        tString tab2=tab+"\t";
        
        //get the  file
        CORE_OutputFile &file=*mFile.get();
        
        file<<tab<<"<Grid Name=\"Grid\">"<<"\n";
        
        file<<tab2<<"<Time Value=\""<<std::setprecision(10)<<t<<"\"/>"<<"\n";
        
        file<<tab2<<"<Geometry Reference=\"/Xdmf/Domain/Grid/Geometry[1]\"/>"<<"\n";
        // file<<tab2<<"<Geometry Type=\"XYZ\">"<<"\n";
        // ok = ok && writeVertices(file,network);
        // file<<tab2<<"</Geometry>"<<"\n";
        
        file<<tab2<<"<Topology Reference=\"/Xdmf/Domain/Grid/Topology[1]\"/>"<<"\n";
        // file<<tab2<<"<Topology Dimensions=\""<<network.getPointsNumber()<<"\" Type=\"Mixed\">"<<"\n";
        // ok = ok && writeConnectivity(file,
        //                              network.getNeighbors(),
        //                              network.getNeighborIndices());
        // file<<tab2<<"</Topology>"<<"\n";
        
        
        
        ok=WriteField(file,getFormat(),getExternalFileName(),t,support,name,"",
                      alpha,network.getParticlesNumber()+network.getHaloParticlesNumber(),SM_Constants::DIM,f);
        
        file<<tab<<"</Grid>"<<"\n";
        
        return ok;
    }
 
    inline tBoolean writeContentFooter(const tIndex& t,const tFlag& support)  {
        return true;
    }
    
 
    inline tBoolean writeGeometryFooter(const tIndex& t) {
        return true;
    }
 
   
    
    inline tBoolean close(const tIndex& t) {
        return true;
    }
    
    inline tBoolean close() {
        
        //get the  file
        CORE_OutputFile &f=*mFile.get();
        
        //close the file at end time
        f<<"\t\t</Grid>"<<"\n";
        f<<"\t</Domain>"<<"\n";
        f<<"</Xdmf>\n";
        
        f.close();
        //file is open
        setIsFileOpened(false);
        
        return true;
    }
 
 
    
    
protected:
 
    //XDMF writing method
    //===================
  
 
protected:
   
    
    static tBoolean WriteVertices(CORE_OutputFile& file,
                                  const tFlag& fileType,const tString& linkHDFFile,
                                  const SM_Network& mesh,
                                  const tString& tag);
   
     
    static tBoolean WriteConnectivity(CORE_OutputFile& file,
                                      const tFlag& fileType,const tString& linkHDFFile,
                                      const tIndex& nAloneParticles,
                                      const tIndex& nHaloParticles,
                                      const std::valarray<tIndex>& neighboringParticlesListOffset,
                                      const std::valarray<tIndex>& neighboringParticlesList,
                                      const tString& tagN);
    
   
    
    static tBoolean WriteField(CORE_OutputFile& file,
                               const tFlag& fileType,const tString& linkHDFFile,
                               const tIndex& t,
                               const tFlag& contentType,
                               const tString& name,
                               const tString& tagName,
                               const tReal& alpha,
                               const tIndex& n,
                               const tDimension& dim,
                               const tReal* f);
    
    
    
  
    
   
   
 
 
    
};
 
#endif