SM_SliceOperator.h

#ifndef SM_SliceOperator_H
#define SM_SliceOperator_H
 
#include "SM_Object.h"
 
 
//system class
class SM_System;
 
//network class
#include "SM_Network.h"
 
//material class
#include "SM_Material.h"
 
class SM_SliceOperator : public virtual SM_Object {
    
    //attributes
private :
    
    
    //name of the operator
    tString mName;
    
  
 
    //association
  
    
   
protected:
    // CONSTRUCTORS 
    SM_SliceOperator(void) {
        mName="";
    }
    
    // DESTRUCTORS 
    virtual ~SM_SliceOperator(void) {
    }
    
public : 
 
    //Instance building
    //=================
 
    virtual CORE_UniquePointer<SM_SliceOperator> NewInstance() const=0;
    
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=mName.size();
        return mem;
    }
    
 
 
    //SET & GET
    //=========
protected:
    
    inline  void setName(const tString& name) {
        mName=name;
    }
public:
    inline const tString& getName() const {
        return mName;
    }
 
    
public:
 
    virtual void copy(const SM_SliceOperator& op) {
        mName=op.getName();
    }
    virtual void adimensionize(const tReal& cH)  {
    }
   
    virtual void discretize(const SM_Network& network, const SM_Material& material)  {
    }
 
    //Fields computation
    //==================
    
    virtual void updateState(const tIndex& timeIndex,
                             const SM_Network& network,
                             const SM_Material& material,
                             const SM_RealField& S) {
    }
    
    virtual void computeMagneticFieldSlice(const tIndex& timeIndex,
                                           const SM_Network& network,
                                           const SM_Material& material,
                                           const tIndex& startIndex,
                                           const tIndex& endIndex,
                                           const tReal *S,
                                           const tBoolean& alpha,
                                           const tIndex& nH,
                                           tReal *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=0;
    
    //Total energy computation
    //========================
 
    
    virtual tReal computeEnergySlice(const tIndex& timeIndex,
                                     const SM_Network& network,
                                     const SM_Material& material,
                                     const tIndex& startIndex,
                                     const tIndex& endIndex,
                                     const tReal *S) const=0;
 
    
 
   
    virtual tString toString() const override {
        return mName+":"+getIdentityString();
    }
};
 
 
#endif