SM_Operator.h

Go to the documentation of this file.

#ifndef SM_Operator_H
#define SM_Operator_H
 
#include "SM_Object.h"
 
 
//system class
class SM_System;
//network class
#include "SM_Network.h"
 
class SM_Operator : public SM_Object {
    
    //attributes
private :
    
    
    tString mName;
    
    //association
  
    
   
protected:
    // CONSTRUCTORS 
    SM_Operator(void) {
        mName="";
    }
    
    // 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();
        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_Operator& op) {
        mName=op.getName();
    }
    virtual void discretize(const SM_System& system) {
       
    }
   
    virtual void computeMagneticField(const tIndex& t,
                                      const SM_Network& network,
                                      const tReal *mu,
                                      tReal *B) const=0;
    virtual void computeMagneticFieldAndEnergy(const tIndex& t,
                                               const SM_Network& network,
                                               const tReal *mu,
                                               tReal *B,
                                               tReal& E) const=0;
    
    inline void computeMagneticField(const tIndex& t,
                                     const SM_Network& network,
                                     const SM_RealField& Mu,
                                     SM_RealField& B) const {
        const tIndex& N=Mu.getElementsNumber();
        //set the output field dimension
        B.setElementsNumber(N);
        B=0;
        computeMagneticField(t,network,&Mu[0],&B[0]);
    }
 
    inline tReal computeEnergy(const tIndex& t,
                               const SM_Network& network,
                               const  SM_RealField& mu) const {
        return computeEnergy(t,network,&mu[0]);
    }
    
    virtual tReal computeEnergy(const tIndex& t,
                                const SM_Network& network,
                                const tReal *mu) const=0;
    
    virtual tReal computeEnergy(const SM_Network& network,
                                const tReal *mu,
                                const tReal *H) const {
        //get the size of the network
        tIndex i,N=network.getParticlesNumber()*network.getDimension();
        tReal E=0;
        const tReal *mu_i=mu;
        const tReal *H_i=H;
        for (i=0;i<N;i++) {
            E-=(*mu_i)*(*H_i);
            mu_i++;
            H_i++;
        }
        return E*0.5;
    }
};
 
 
#endif