SM_VTK.h

#ifndef SM_VTK_H
#define SM_VTK_H
 
//base header class
#include "CORE_Object.h"
 
//LL system header
#include "SM_System.h"
//network header
#include "SM_Network.h"
 
template<class VTK_Impl>
class SM_VTK : public  SM_Object {
  
    // ATTRIBUTES
public:
    static const tFlag CELL;
    static const tFlag POINT;
    
  
private:
 
    //the absolute file name without extension
    tString mFileName;
 
  
    //cell data
    std::vector<tString> mScalarFieldOnCellNames;//scalar field on cell
    std::vector<tString> mVectorFieldOnCellNames;//vector field on cell
    
    //point data
    std::vector<tString> mScalarFieldOnPointNames;//scalar field on point
    std::vector<tString> mVectorFieldOnPointNames;//vector field on point
 
    //indicates if the fiel is opened
    tBoolean mIsFileOpened;
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_VTK(void) {
        mIsFileOpened=false;
        mFileName="";
    }
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~SM_VTK(void) {
    }
  
  
 
public:
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=mFileName.size();
        for(const auto& name: mScalarFieldOnPointNames) mem+=name.size()*sizeof(unsigned char);
        for(const auto& name: mScalarFieldOnCellNames) mem+=name.size()*sizeof(unsigned char);
        for(const auto& name: mVectorFieldOnPointNames) mem+=name.size()*sizeof(unsigned char);
        for(const auto& name: mVectorFieldOnCellNames) mem+=name.size()*sizeof(unsigned char);
        return mem;
        
    }
    
    template<class T>
    tString getVTKType() const {
        return getVTKType(functions_type::getTypeName<T>());
    }
    tString getVTKType(const tString& typeName) const;
 
 
    inline void setFileName(const tString& fn) {
        tIndex iPt=fn.rfind(".");
        if (iPt!=tString::npos) {
            mFileName=fn.substr(0,iPt);
        }else {
            mFileName=fn;
        }
    }
    
    inline const tString&  getFileName() const {
        return mFileName;
    }
 
    inline void setFields(const tUCInt& dim,
                          const tFlag& support,
                          const std::vector<tString>& names) {
        switch(dim) {
        case 1:
            switch(support) {
            case POINT:
                mScalarFieldOnPointNames.clear();
                for(const auto& name : names) {
                    mScalarFieldOnPointNames.push_back(name);
                }
                break;
            case CELL:
                mScalarFieldOnCellNames.clear();
                for(const auto& name : names) {
                    mScalarFieldOnCellNames.push_back(name);
                }
                break;
            }
            break;
        default:
            switch(support) {
            case POINT:
                mVectorFieldOnPointNames.clear();
                for(const auto& name : names) {
                    mVectorFieldOnPointNames.push_back(name);
                }
                break;
            case CELL:
                mVectorFieldOnCellNames.clear();
                for(const auto& name : names) {
                    mVectorFieldOnCellNames.push_back(name);
                }
                break;
            }
        }
    }
    
  
 
   
    inline const tBoolean& isFileOpened() const {
        return mIsFileOpened;
    }
 
protected:
    inline void setIsFileOpened(const tBoolean& v) {
        mIsFileOpened=v;
    }
    
public:
  
    inline tBoolean save(const SM_Network& network,const tIndex& it,const tReal& time) {
         tBoolean ok=true;
         if (mIsFileOpened) {
             ok=ok && open(it);
             //write the geometry header
             ok=ok && writeGeometryHeader(it,network);
             //write the network
             ok=ok && writeGeometryData(it,network);
             //write the header of point data
             ok=ok && writeContentHeader(it,POINT,mScalarFieldOnPointNames,mVectorFieldOnPointNames);
             
             //wrtite the footer of point data
             ok=ok && writeContentFooter(it,POINT);
             
             //write the header of cell data
             ok=ok && writeContentHeader(it,CELL,mScalarFieldOnCellNames,mVectorFieldOnCellNames);
             //no cell data to write
             //write the footer of cell data
             ok=ok && writeContentFooter(it,CELL);
        
             //write the footer of the geometry 
             ok=ok &&  writeGeometryFooter(it);
             
             //clse for writing the time step
             ok=ok && close(it);
         }
         return ok;
    
   
    }
    
    inline tBoolean save(const SM_System& system,const tIndex& it,const tReal& time) {
        return save(system.getNetwork(),"S",1,system.getMagneticMomentDirections(),it,time);
    }
    inline tBoolean save(const tString& vtkFileName,
                         const SM_Network& network,
                         const tString& Sname,const tReal& alpha,SM_RealField& S) {
        tBoolean ok=true;
        setFileName(vtkFileName);
        setFields(3,POINT,{Sname});
        ok=ok && open();
        ok=ok && save(network,Sname,alpha,S,0,0);
        ok=ok & close();
        return ok;
    }
    
    inline tBoolean save(const SM_Network& network,const tString& Sname,const tReal& alpha,
                         const SM_RealField& S,const tIndex& it,const tReal& time) {
         tBoolean ok=true;
         if (mIsFileOpened) {
             ok=ok && open(it);
             //write the geometry header
             ok=ok && writeGeometryHeader(it,network);
             //write the network
             ok=ok && writeGeometryData(it,network);
             //write the header of point data
             ok=ok && writeContentHeader(it,POINT,mScalarFieldOnPointNames,mVectorFieldOnPointNames);
             //write magnetic moment
             ok=ok && writeContentData(time,
                                       network,
                                       POINT,
                                       Sname,alpha,
                                       S.getValues());
             
             //wrtite the footer of point data
             ok=ok && writeContentFooter(it,POINT);
             
             //write the header of cell data
             ok=ok && writeContentHeader(it,CELL,mScalarFieldOnCellNames,mVectorFieldOnCellNames);
             //no cell data to write
             //write the footer of cell data
             ok=ok && writeContentFooter(it,CELL);
        
             //write the footer of the geometry 
             ok=ok &&  writeGeometryFooter(it);
             
             //clse for writing the time step
             ok=ok && close(it);
         }
         return ok;
    
   
    }
    //Virtual templated classes for writing  VTK files
    //=================================================
 
public:
    inline tBoolean open() {
        return static_cast<VTK_Impl*>(this)->open();
    }
 
    inline tBoolean open(const tIndex& t) {
        return static_cast<VTK_Impl*>(this)->open(t);
    }
    
    inline tBoolean writeGeometryHeader(const tIndex& t,const SM_Network& network) {
        return static_cast<VTK_Impl*>(this)->writeGeometryHeader(t,network);
    }
    
    inline tBoolean writeGeometryData(const tIndex& t,const SM_Network& network) {
        return static_cast<VTK_Impl*>(this)->writeGeometryData(t,network);
    }
    
    inline  tBoolean writeContentHeader(const tIndex& t,
                                        const tFlag& support,
                                        const std::vector<tString>& scalarNames,
                                        const std::vector<tString>& vectorNames) {
        return static_cast<VTK_Impl*>(this)->writeContentHeader(t,support,scalarNames,vectorNames);
    }
    
    inline tBoolean writeContentData(const tReal& t,
                                     const SM_Network& network,
                                     const tFlag& support,
                                     const tString& name,const tReal& alpha,
                                     const tReal* f) {
        return static_cast<VTK_Impl*>(this)->writeContentData(t,network,support,name,alpha,f);
    }
 
    inline  tBoolean writeContentFooter(const tIndex& t,const tFlag& support) {
        return static_cast<VTK_Impl*>(this)->writeContentFooter(t,support);
    }
    
 
    inline  tBoolean writeGeometryFooter(const tIndex& t) {
        return static_cast<VTK_Impl*>(this)->writeGeometryFooter(t);
    }
  
    inline tBoolean close(const tIndex& t) {
        return static_cast<VTK_Impl*>(this)->close(t);
    }
    
    inline tBoolean close() {
         return static_cast<VTK_Impl*>(this)->close();
    }
 
};
 
#include "SM_VTK.hpp"
 
#endif