SM_StochasticXDMF.h

#ifndef SM_StochasticXDMF_H
#define SM_StochasticXDMF_H
 
//stochastic data
#include "SM_StochasticOutput.h"
 
//system data
#include "SM_LandauLifschitzSystem.h"
 
//XDMF header
#include "SM_XDMF.h"
 
 
class SM_StochasticXDMF  : public SM_StochasticOutput<SM_StochasticXDMF>  {
  
    // ATTRIBUTES
  
public:
   
  
   
private:
 
    //type class
    typedef SM_StochasticXDMF SelfClass;
    typedef SM_StochasticOutput<SelfClass> SuperClass;
 
    //index of simulations to save
    std::vector<tIndex> mSimulations;
    std::vector<tIndex>::const_iterator mISimulation;
    tRelativeInteger mLastTimeIndexSaved;
   
    
    //vtk file
    SM_XDMF mVTK;
   
 
  
    
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_StochasticXDMF(void) {
      
        //plot only first simulation by default
        mSimulations.resize(1);
        mSimulations[0]=0;
        mLastTimeIndexSaved=-1;
    }
 
  
  
    // DESTRUCTORS 
public:
    
    virtual ~SM_StochasticXDMF(void) {
    }
 
 
 
public:
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_StochasticOutput< SM_StochasticXDMF>::getContentsMemorySize();
        mem+=mSimulations.size()*sizeof(tIndex);
        mem+=mVTK.getContentsMemorySize();
        return mem;
    }
    
    inline static CORE_UniquePointer<SM_StochasticXDMF> New() {
        return CORE_UniquePointer<SM_StochasticXDMF>(new SM_StochasticXDMF(),SM_StochasticXDMF::Delete());
    }
    inline static CORE_UniquePointer<SM_StochasticXDMF> New(const SM_StochasticXDMF& c) {
        CORE_UniquePointer<SM_StochasticXDMF>  p=New();
        p->copy(c);
        return p;
    }
    //SET & GET Methods
    //=================
    virtual void copy(const SM_StochasticOutputComponent& c) override {
        SM_StochasticOutput<SM_StochasticXDMF>::copy(c);
        const SM_StochasticXDMF *cc=dynamic_cast<const SM_StochasticXDMF*>(&c);
        if (cc!=null) setSimulations(cc->getSimulations());
    }
 
    
    inline void setSimulations(std::initializer_list<tIndex>&& simulationIndices) {
        mSimulations=simulationIndices;
    }
    inline void setSimulations(const std::vector<tIndex>& simulationIndices) {
        mSimulations=simulationIndices;
    }
 
    
    inline const std::vector<tIndex>& getSimulations() const {
        return mSimulations;
    }
  
   
    virtual void adimensionize(const SM_Material& material) override {
    }
public:
 
    //implemented templated methods
    //=============================
    inline tBoolean open(const SM_Beam& beam) {
        //sort the index of simulation
        std::sort(mSimulations.begin(),mSimulations.end());
        mISimulation=mSimulations.begin();
        return (dynamic_cast< const SM_LandauLifschitzSystem *>(&beam.getSystem())!=null);
    }
    
    inline tBoolean open(const tIndex& s,const SM_System& system) {
        tBoolean ok=true;
        while (mISimulation!=mSimulations.end()) {//loop on simulations index
            if (s<(*mISimulation)) {
                break;//simulations is not saved
            }
            if (s==(*mISimulation)) {
                //save the simulation
                if (getRootIndex()==-1) {
                    //save the S state for each stochastic output
                    mVTK.setFileName(CORE_IO::GetAbsolutePath(getOutputPath()+"/"+getPrefix()+
                                                              "-s"+std::to_string(s)+
                                                              "_c"+std::to_string(getIndex())+
                                                              +"p"+std::to_string(getIndicesNumber()))+".xmf");
 
                    //std::cout<<"open vtk file : "<<mVTK.getFileName()<<"\n";
                    ok=ok && mVTK.open();
                    mLastTimeIndexSaved=0;
                    mVTK.save(system,mLastTimeIndexSaved,0.0);
                    mLastTimeIndexSaved=-1;
                    
                }
                else if (getIndex()==getRootIndex()) {
                    //save the S only for root index stochastic output
                    mVTK.setFileName(CORE_IO::GetAbsolutePath(getOutputPath()+"/"+getPrefix()+
                                                              "-s"+std::to_string(s)));
                    ok=ok && mVTK.open();
                    mLastTimeIndexSaved=0;
                    mVTK.save(system,mLastTimeIndexSaved,0.0);
                }
                break;
            }
            
            //next simulation
            mISimulation++;
        }
        return ok;
    }
   
 
 
    inline tBoolean  store(const SM_System& system) {
        //write  mu at time step i
        if (mVTK.isFileOpened()) {
            const SM_LandauLifschitzSystem *llSystem=dynamic_cast< const SM_LandauLifschitzSystem *>(&system);
            if (((tRelativeInteger)llSystem->getTimeIndex())!=mLastTimeIndexSaved) {
                mLastTimeIndexSaved=llSystem->getTimeIndex();
                mVTK.save(*llSystem,mLastTimeIndexSaved,llSystem->getTime());
            }
        }
        return true;
    }
    inline tBoolean close(const tIndex& s,const SM_System& system,const tBoolean& hasSucceeded) {
      
        if (mVTK.isFileOpened()) {
            return mVTK.close();  
        }
        return true;
    }
    inline tBoolean close(const SM_Beam& beam) {
        return true;
    }
 
    
    virtual void closePackedSimulations(const SM_Beam& beam,
                                        const tIndex& rawValuesNumber,
                                        const std::valarray<tReal>& rawValues) override {
       
        
    }
 
   
    
public:
    // OTHERS methods
  
    
 
 
};
 
#endif