SM_StochasticHysteresis.h

#ifndef SM_StochasticHysteresis_H
#define SM_StochasticHysteresis_H
 
//inherited class header
#include "SM_StochasticOutput.h"
 
//beam class header
#include "SM_LandauLifschitzBeam.h"
 
//suystem class header
#include "SM_System.h"
 
//runner header
#include "CORE_Run.h"
 
//string utility header
#include "core_string.h"
#include "core_numeric.h"
 
 
 
class SM_StochasticHysteresis  : public SM_StochasticOutput<SM_StochasticHysteresis>  {
  
    // ATTRIBUTES
  
public:
   
  
   
private:
 
    //class types definition
    typedef SM_StochasticHysteresis Self;
    typedef SM_StochasticOutput<Self> SuperClass;
    
    std::array<tReal,SM_Constants::DIM> mD;//direction of computing
    std::array<tReal,SM_Constants::DIM> mEpS;//mean over the particles of S
    
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_StochasticHysteresis(void) {
      
        setOutputDescription({
                "<E_{s}(E_p(<S(s,p),D>))",
                "<samples number>",
                "<number of simulations>",
                });
        
        std::valarray<tReal>& outputs=getOutputValues();
        outputs.resize(3);
        
        memset(&outputs[0],0,outputs.size()*sizeof(tReal));
 
    }
 
  
  
    // DESTRUCTORS 
public:
    
    virtual ~SM_StochasticHysteresis(void) {
        tString routineName="SM_StochasticHysteresis::~SM_StochasticHysteresis()";
        CORE_Profiler::StartCallRoutine(routineName);
        CORE_Profiler::EndCallRoutine(routineName);
    }
 
 
 
public:
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=mEpS.size()*sizeof(tReal);
        mem+=mD.size()*sizeof(tReal);
        return mem;
    }
 
    inline static CORE_UniquePointer<Self> New() {
        return CORE_UniquePointer<Self>(new Self(),
                                        SM_Object::Delete());
    }
    inline static CORE_UniquePointer<Self> New(const Self& c) {
        CORE_UniquePointer<Self> p=New();
        p->copy(c);
        return p;
    }
 
    //SET & GET Methods
    //=================
    virtual void copy(const SM_StochasticOutputComponent& c) override {
        SuperClass::copy(c);
    }
   
    
    virtual void adimensionize(const SM_Material& material) override {
    }
 
 
    inline  void  setHysteresisDirection(const std::array<tReal,SM_Constants::DIM>& D) {
        mD=D;
    }
    
    inline  const std::array<tReal,SM_Constants::DIM>& getHysteresisDirection() const {
        return mD;
    }
    
 
    
     
  
    
    //implemented templated methods
    //=============================
    
    inline tBoolean open(const SM_Beam& beam) {
     
        if (getIndex()==0) {
            //number of raws values number is null
            tIndex &nRaws=getPackedRawValuesNumber();
            nRaws=0;
            
            //set the size of the distribution
            std::valarray<tReal>& rawValues=getPackedRawValues();
            //rawValues[0]=sum_s <E_p(S),D>
            //rawValues[1]=s
            rawValues.resize(2);
            //initialize to 0
            memset(&rawValues[0],0,rawValues.size()*sizeof(tReal));
        }
        
        return true;
    }
    
  
  
 
    inline tBoolean open(const tIndex& s,const SM_System& system) {
        tBoolean ok=true;
        return ok;
    }
    
    inline tBoolean  store(const SM_System& system) {
 
        
        return true;
    }
    
 
    
    inline tBoolean close(const tIndex& s,const SM_System& system,const tBoolean& hasSucceeded) {
        tBoolean ok=true;
       
        //std::cout<<"begin SM_SHysteresis::close("<<s<<","<<getIndex()<<")\n";
        if (hasSucceeded) {
            if ((getIndex()==0) || (getRootIndex()==-1)) {
 
                //mEps=1/P \sum_R \sum_{p \in R}  S(P) : sum over the networks P=\sum card{R} 
                system.computeMagneticMomentDirectionsMeanOverNetworks(0,mEpS);
 
                if (getIndex()==0) {
                    //compute <E_p(S,s,p),D> mean of S projected on D
                    tReal sED=0;
                    const tReal *iEpS=mEpS.data();
                    for (const auto& Dk:mD) {
                        sED+=Dk*(*iEpS);
                        iEpS++;
                    }
                    getPackedRawValues()[0]+=sED;
                    getPackedRawValuesNumber()++;
                }
            }
        }
        
        //std::cout<<"SM_SHysteresis::close("<<s<<","<<getIndex()<<") hysValue="<<getPackedRawValues()[0]<<"\n";
        return ok;
    }
 
    inline tBoolean close(const SM_Beam& beam) {
        //std::cout<<"begin SM_SHysteresis::close("<<getIndex()<<")\n";
        if (getIndex()==0) {
            //get the esperance to compute
            std::valarray<tReal> &rawValues=getPackedRawValues();
            tIndex& rawValuesNumber=getPackedRawValuesNumber();
            
            //number of simulation of the beam
            rawValues[1]=beam.getBeamSize();
            
            //set the output of the stochatic data if mono core beam case
            if (getPackedSimulationsNumber()==1) {
                updateOutputs(rawValuesNumber,rawValues,getOutputValues());
            }
        }
        //std::cout<<"end SM_SHysteresis::close("<<getIndex()<<")\n";
        return true;
    
    }
 
 
    virtual void closePackedSimulations(const SM_Beam& beam,
                                        const tIndex& rawValuesNumber,
                                        const std::valarray<tReal>& rawValues) override {
        if (getIndex()==0) {
            //std::cout<<"begin SM_SHysteresis::closePackedSimulations("<<getIndex()<<")\n";
            updateOutputs(rawValuesNumber,rawValues,getOutputValues());
            //std::cout<<"end SM_SHysteresis::closePackedSimulations("<<getIndex()<<")\n";
        }
    }
    
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString();
        return ret.str();
    }
 
    
private:
 
    inline void updateOutputs(const tIndex& rawValuesNumber,
                             const std::valarray<tReal>& rawValues,
                             std::valarray<tReal>& outputs)  {
        if (outputs.size()<3) outputs.resize(3);
        outputs[0]=rawValues[0]/rawValuesNumber;//E_s(<E_p(S),D>) mean on samples
        outputs[1]=rawValuesNumber;//total number of samples
        outputs[2]=rawValues[1];//total number of simlations
        
    }
  
};
 
#endif