SM_Operator.h

#ifndef SM_Operator_H
#define SM_Operator_H
 
#include "SM_Object.h"
 
 
//system class
class SM_System;
 
//network class
#include "SM_Network.h"
 
//material class
#include "SM_Material.h"
 
//slice operator
#include "SM_SliceOperator.h"
 
//linear slice operator
#include "SM_LinearSliceOperator.h"
 
class SM_Operator : public virtual SM_Object {
    
    //attributes
private :
    
 
    //association
    CORE_UniquePointer<SM_SliceOperator> mSliceOperator;
    
   
protected:
    // CONSTRUCTORS 
    SM_Operator(void) {
       
    }
    
    // DESTRUCTORS 
    virtual ~SM_Operator(void) {
    }
    
public : 
 
    //Instance building
    //=================
 
    virtual CORE_UniquePointer<SM_Operator> NewInstance() const=0;
    
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        return mem;
    }
    
 
 
    //SET & GET
    //=========
protected:
 
   
 
    inline void setSliceOperator(CORE_UniquePointer<SM_SliceOperator> sliceOperator) {
        mSliceOperator=std::move(sliceOperator);
    }
    
public:
 
    inline SM_SliceOperator& getSliceOperator() {
        return *mSliceOperator.get();
    }
    inline const SM_SliceOperator& getSliceOperator() const {
        return *mSliceOperator.get();
    }
 
    virtual void copy(const SM_Operator& op) {
        getSliceOperator().copy(op.getSliceOperator());
    }
  
    inline tString getName() const {
        return getSliceOperator().getName();
    }
 
    inline tBoolean isLinear() const {
        return (dynamic_cast<const SM_LinearSliceOperator*>(&getSliceOperator())!=null);
    }
    
    inline void adimensionize(const tReal& cH)  {
        mSliceOperator->adimensionize(cH);
    }
   
    inline void discretize(const SM_Network& network, const SM_Material& material)  {
        mSliceOperator->discretize(network,material);
    }
 
 
    //state update
    //============
    inline void updateState(const tIndex& timeIndex,
                            const SM_Network& network,
                            const SM_Material& material,
                            const SM_RealField& S) {
        mSliceOperator->updateState(timeIndex,network,material,S);
    }
    
    //Fields computation
    //==================
 
     
    
    virtual void computeMagneticField(const tIndex& timeIndex,
                                      const SM_Network& network,
                                      const SM_Material& material,
                                      const SM_RealField& S,
                                      const tBoolean& alpha,
                                      SM_RealField& H) const=0;
    
    //Spin energy computation
    //=======================
 
    virtual tReal computeSpinEnergy(const tIndex& i,
                                    const tIndex& timeIndex,
                                    const SM_Network& network,
                                    const SM_Material& material,
                                    const SM_RealField& S) const {
        return mSliceOperator->computeSpinEnergy(i,timeIndex,network,material,S);
    }
   
  
    //Total energy computation
    //========================
 
 
    inline tReal computeEnergy(const SM_Network& network,
                               const SM_Material& material,
                               const SM_RealField& S) const {
        return computeEnergy(0,network,material,S);
    }
   
    virtual tReal computeEnergy(const tIndex& timeIndex,
                                const SM_Network& network,
                                const SM_Material& material,
                                const SM_RealField& S) const=0;
    
    virtual tReal computeEnergy(const SM_Network& network,
                                const SM_Material& material,
                                const SM_RealField& S,
                                const SM_RealField& H) const=0;
    
 
   
    virtual tString toString() const override {
        std::stringstream ss;
        ss<<getIdentityString();
        ss<<" slice Operator:"<<mSliceOperator->toString()<<"\n";
        return ss.str();
        
    }
};
 
 
#endif