SM_StochasticOutputComponent.h

#ifndef SM_StochasticOutputComponent_H
#define SM_StochasticOutputComponent_H
 
//stochastic data
#include "SM_Object.h"
 
class SM_Beam;
class SM_System;
 
 
#include "SM_Material.h"
#include "SM_Field.h"
 
class SM_StochasticOutputComponent  : public virtual SM_Object   {
  
    // ATTRIBUTES
  
public:
   
  
   
private:
 
    
    //output path
    tString mOutputPath;
    //output prefix
    tString mPrefix;
 
    //drawn number register
    tInteger mDrawnStepsNumber;
 
    //index of the packed simulations
    tInteger mPackedSimulationsIndex;
    
    //number of the packed simulations
    tInteger mPackedSimulationsNumber;
 
    //indicates if the statistic has  log per packed simulations
    tBoolean mHasLogPerPackedSimulations;
    
    //number of packed rw values
    tIndex mPackedRawValuesNumber;
 
    //packed raw values
    std::valarray<tReal> mPackedRawValues;
 
    //output value of the stochastic
    std::valarray<tReal> mOutput;
    std::vector<tString> mOutputDescription;
 
    //index of stochastic output components
    //mRootIndex=index of the main stochastic output in [0,mIndicesNumber]
    //mRootIndex>=mIndicesNumber ;: no root index
    //mIndex: index of the stochatic output in [0,mIndicesNumber[ 
    int mRootIndex,mIndex,mIndicesNumber;
    
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_StochasticOutputComponent(void) {
      
     
        mOutputPath="";
        mPrefix="";
        mDrawnStepsNumber=0;
        mPackedSimulationsNumber=1;
        mPackedSimulationsIndex=0;
        mHasLogPerPackedSimulations=true;
        mPackedRawValues.resize(1);
        mPackedRawValues[0]=0;
        mPackedRawValuesNumber=0;
        mRootIndex=-1;
        mIndex=0;
        mIndicesNumber=1;
    }
 
  
  
    // DESTRUCTORS 
public:
    
    virtual ~SM_StochasticOutputComponent(void) {
    }
 
 
 
public:
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=mOutputPath.size()*sizeof(tChar);
        mem+=mPrefix.size()*sizeof(tChar);
        mem+=sizeof(tReal)*mPackedRawValues.size();
        mem+=mOutput.size()*sizeof(tReal);
        for(const auto& d: mOutputDescription) mem+=sizeof(tChar)*d.length();
        return mem;
    }
    
   
 
    //SET & GET Methods
    //=================
   
    virtual void copy(const SM_StochasticOutputComponent& c) {
        mOutputPath=c.getOutputPath();
        mPrefix=c.getPrefix();
        mDrawnStepsNumber=c.getDrawnStepsNumber();
    }
    
   
    virtual void setOutputPath(const tString& path) {
        mOutputPath=path;
    }
    inline const tString& getOutputPath() const {
        return mOutputPath;
    }
    virtual void setPrefix(const tString& prefix) {
        mPrefix=prefix;
    }
    inline const tString& getPrefix() const {
        return mPrefix;
    }
 
    virtual void setIndex(const int& index,
                          const int& rootIndex,
                          const int& n) {
        mIndex=index;
        mRootIndex=rootIndex;
        mIndicesNumber=n;
    }
    inline void setIndex(const int& index,
                         const int& n) {
        
        setIndex(index,0,n);
    }
    inline const int& getIndex() const {
        return mIndex;
    }
    inline const int& getRootIndex() const {
        return mRootIndex;
    }
    inline const int& getIndicesNumber() const {
        return mIndicesNumber;
    }
    
    inline void  setDrawnStepsNumber(const tInteger& n)  {
        mDrawnStepsNumber=n;
     }
    inline const tInteger& getDrawnStepsNumber() const {
        return mDrawnStepsNumber;
     }
 
 
    inline void setPackedSimulationsIndex(const tInteger& i)  {
        mPackedSimulationsIndex=i;
    }
    inline const tInteger&  getPackedSimulationsIndex()  const {
        return mPackedSimulationsIndex;
    }
    inline void setPackedSimulationsNumber(const tInteger& n)  {
        mPackedSimulationsNumber=n;
    }
    inline const tInteger& getPackedSimulationsNumber()  const {
        return mPackedSimulationsNumber;
    }
    inline const tBoolean & hasLogPerPackedSimulations() const {
        return  mHasLogPerPackedSimulations;
    }
    inline void setHasLogPerPackedSimulations(const tBoolean & v)  {
        mHasLogPerPackedSimulations=v;
    }
    inline  const tIndex& getPackedRawValuesNumber() const  {
        return mPackedRawValuesNumber;
    }
    inline tIndex& getPackedRawValuesNumber()  {
        return mPackedRawValuesNumber;
    }
 
   
    
    inline std::valarray<tReal>& getPackedRawValues() {
        return mPackedRawValues;
    }
    
    inline const std::valarray<tReal>& getPackedRawValues() const {
        return mPackedRawValues;
    }
 
       
    inline const std::vector<tString>& getOutputDescription() const {
        return mOutputDescription;
    }
    inline void setOutputDescription(const std::vector<tString>& v)   {
        mOutputDescription=v;
    }
    
    inline const std::valarray<tReal>& getOutputValues() const {
        return mOutput;
    }
    
    inline std::valarray<tReal>& getOutputValues()  {
        return mOutput;
    }
    
public:
 
    //implemented templated methods
    //=============================
    virtual tBoolean openComponent(const SM_Beam& beam)=0;
        
    virtual tBoolean openComponent(const tIndex& s,const SM_System& system)=0;
 
 
    virtual  tBoolean  storeComponent(const SM_System& system)=0;
    
    virtual tBoolean closeComponent(const tIndex& s,const SM_System& system,const tBoolean& hasSucceeded)=0;
    
    virtual tBoolean closeComponent(const SM_Beam& beam)=0;
    
    virtual void closePackedSimulations(const SM_Beam& beam,
                                        const tIndex& rawValuesNumber,
                                        const std::valarray<tReal>& rawValues)=0;
 
    
    virtual void adimensionize(const SM_Material& material)=0;
 
 
public:
    // OTHERS methods
  
    
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SM_Object::toString()<<"\n";
        ret<<"\t outputPath:"<<mOutputPath<<"\n";
        ret<<"\t prefix:"<<mPrefix<<"\n";
        ret<<"\t drawn steps number:"<<mDrawnStepsNumber<<"\n";
        ret<<"\t output size: "<<mOutput.size()<<"\n";
        ret<<"\t pack:"<<mPackedSimulationsIndex<<"/"<<mPackedSimulationsNumber<<"\n";
        ret<<"\t output description: ";
        for(const auto& d:mOutputDescription) ret<<d<<"\t";
        ret<<"\n";
        ret<<"\t has log per packed simulations:"<<mHasLogPerPackedSimulations<<"\n";
        return ret.str();
    }
 
    
};
 
#endif