EMMG_StaticMagneticTensorOperator.h

Go to the documentation of this file.

#ifndef EMMG_StaticMagneticTensorOperator_H
#define EMMG_StaticMagneticTensorOperator_H


#include "EMM_StaticMagneticTensorOperator.h"

DEFINE_SPTR(EMMG_StaticMagneticTensorOperator);
class EMMG_StaticMagneticTensorOperator : public virtual EMM_StaticMagneticTensorOperator {
    
    SP_OBJECT(EMMG_StaticMagneticTensorOperator);
    // ATTRIBUTES
    
    
private:

    
public:
   

    // ASSOCIATION
 
private:
   
protected: 

    // METHODS
  
    // CONSTRUCTORS 
  
    EMMG_StaticMagneticTensorOperator(void) {
    }
  
    // DESTRUCTORS 
    
    virtual ~EMMG_StaticMagneticTensorOperator(void) {
    }
  
  
public:
    inline static SP::EMMG_StaticMagneticTensorOperator New() {
        SP::EMMG_StaticMagneticTensorOperator p(new EMMG_StaticMagneticTensorOperator(),
                                                  EMMG_StaticMagneticTensorOperator::Delete());
        p->setThis(p);
        return p;
    };
   

public:
    virtual void computeMagneticExcitationField(const EMM_RealArray& sigma,
                                                const EMM_RealField& M,
                                                EMM_RealField& H) const {
        tUIndex nCells=M.getSize();
        const tDimension& dim=M.getDimension();
        
        //set the size of the magnetic excitation field
        H.setSize(nCells);
        
        //no computation
        if (nCells==0) return;
        
        //verify the type of M
        const EMMG_RealField *gM=dynamic_cast<const EMMG_RealField *>(&M);
        if (gM==null) throw EMM_Exception("generic","EMMG_MagneticTensorOperator::computeMagneticExcitationField(..)",
                                          "M is an incompatible real field");
        
        
        //verify the type of H
        EMMG_RealField *gH=dynamic_cast<EMMG_RealField *>(&H);
        if (gH==null) throw EMM_Exception("generic","EMMG_MagneticTensorOperator:: computeMagneticExcitationField(..)",
                                          "H is an incompatible real field");
        
        EMM_StaticMagneticTensorOperator::computeMagneticExcitationField(nCells,dim,sigma,&(*gM)[0],&(*gH)[0]);
    }
    
    virtual tBoolean computeMagneticExcitationFieldGradient(const EMM_RealArray& sigma,
                                                            const EMM_RealField& M,
                                                            const EMM_RealField& D,
                                                            EMM_RealField& gradH) const {
        tUIndex nCells=M.getSize();
        const tDimension& dim=M.getDimension();
        
        //set the size of the gradient magnetic excitation field
        gradH.setSize(nCells);
        
        //no computation
        if (nCells==0) return false;
        
        //verify the type of M
        const EMMG_RealField *gM=dynamic_cast<const EMMG_RealField *>(&M);
        if (gM==null) throw EMM_Exception("generic","EMMG_MagneticTensorOperator::computeMagneticExcitationFieldGradient(..)",
                                          "M is an incompatible real field");
        
        
        //verify the type of D
        const EMMG_RealField *gD=dynamic_cast<const EMMG_RealField *>(&D);
        if (gD==null) throw EMM_Exception("generic","EMMG_MagneticTensorOperator:: computeMagneticExcitationFieldGradient(..)",
                                          "D is an incompatible real field");

        //verify the type of gradH
        EMMG_RealField *gGradH=dynamic_cast<EMMG_RealField *>(&gradH);
        if (gGradH==null) throw EMM_Exception("generic","EMMG_MagneticTensorOperator:: computeMagneticExcitationFieldGradient(..)",
                                              "GradH is an incompatible real field");
        
        return EMM_StaticMagneticTensorOperator::computeMagneticExcitationFieldGradient(nCells,dim,sigma,&(*gM)[0],&(*gD)[0],&(*gGradH)[0]);
                                                    
    }
    
public:
    virtual tReal computeEnergyWithMagneticExcitation(const tReal& t,
                                                      const EMM_RealArray& sigma,const EMM_RealField& M,const EMM_RealField& H) const {
        // size of the operator
        tUIndex nCells=M.getSize();
        const tDimension& dim=M.getDimension();
        
        //no computation
        if (nCells==0) return 0;
        
        //verify the type of M
        const EMMG_RealField *gM=dynamic_cast<const EMMG_RealField *>(&M);
        if (gM==null) throw EMM_Exception("generic","EMMG_MagnetostrictionOperator::computeMagneticExcitationField(..)",
                                          "M is an incompatible real field");
        
        const EMMG_RealField *gH=dynamic_cast<const EMMG_RealField *>(&H);
        if (gH==null) throw EMM_Exception("generic","EMMG_MagnetostrictionOperator::computeMagneticExcitationField(..)",
                                          "H is an incompatible real field");
        
        
        return EMM_StaticMagneticTensorOperator::computeEnergy(t,nCells,dim,sigma,&(*gM)[0]);
    }
    virtual tReal computeEnergy(const tReal& t, const EMM_RealArray& sigma,const EMM_RealField& M,EMM_RealField& W) const {
        // size of the operator
        tUIndex nCells=M.getSize();
        const tDimension& dim=M.getDimension();
        
       
        //no computation
        if (nCells==0) return 0;
        
        //verify the type of M
        const EMMG_RealField *gM=dynamic_cast<const EMMG_RealField *>(&M);
        if (gM==null) throw EMM_Exception("generic","EMMG_StaticMagneticTensorOperator:: computeEnergy(..)",
                                      "M is an incompatible real field");
        
       
        return EMM_StaticMagneticTensorOperator::computeEnergy(t,nCells,dim,sigma,&(*gM)[0]);
    }
    

};

#endif