EMMG_DisplacementFVM_VTEGROperator.h

Go to the documentation of this file.

#ifndef EMMG_DisplacementFVM_VTEGROperator_H
#define EMMG_DisplacementFVM_VTEGROperator_H


#include "EMM_DisplacementFVM_VTEGROperator.h"


DEFINE_SPTR(EMMG_DisplacementFVM_VTEGROperator);
class EMMG_DisplacementFVM_VTEGROperator : public virtual EMM_DisplacementFVM_VTEGROperator {
    
    SP_OBJECT(EMMG_DisplacementFVM_VTEGROperator);
    // ATTRIBUTES
    
    
private:

    
public:
   

    // ASSOCIATION
 
private:
   
protected: 

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

public:
  


    virtual void computeElasticStress(const EMM_RealField& U, EMM_RealField& S) const {
        tUIndex nCells=U.getSize();
        const tDimension& dim=U.getDimension();
        
        //verify the type of U
        const EMMG_RealField *gU=dynamic_cast<const EMMG_RealField *>(&U);
        if (gU==null) throw EMM_Exception("generic","EMMG_DisplacementFVM_VTEGROperator::computeElasticStress(..)",
                                          "U is an incompatible real field");
        
        S.setDimension(dim);
        S.setSize(nCells);
        //verify the type of S
        EMMG_RealField *gS=dynamic_cast<EMMG_RealField *>(&S);
        if (gS==null) throw EMM_Exception("generic","EMMG_DisplacementFVM_VTEGROperator::computeElasticStress(..)",
                                          "S is an incompatible real field");
        
        EMM_DisplacementFVM_VTEGROperator::computeElasticStress(true,1,nCells,dim,&(*gU)[0],&(*gS)[0]);
    }

    virtual void computeMagneticStress(const tReal& alpha,const tReal& beta,const EMM_RealArray& sigma,const EMM_RealField& M, EMM_RealField& S) const {
        tUIndex nCells=M.getSize();
        const tDimension& dim=M.getDimension();
        
        //verify the type of M
        const EMMG_RealField *gM=dynamic_cast<const EMMG_RealField *>(&M);
        if (gM==null) throw EMM_Exception("generic","EMMG_DisplacementFVM_VTEGROperator::computeMagneticStress(..)",
                                          "M is an incompatible real field");
        
        //verify the type of S
        EMMG_RealField *gS=dynamic_cast<EMMG_RealField *>(&S);
        
        if (gS==null) throw EMM_Exception("generic","EMMG_DisplacementFVM_VTEGROperator::computeMagneticStress(..)",
                                          "S is an incompatible real field");

        //verify the dimension
        if (S.getSize()*S.getDimension()!=nCells*dim) {
            throw EMM_Exception("generic","EMMG_DisplacementFVM_VTEGROperator::computeMagneticStress(sigma,M,S)",
                                          "M & S has incompatible size");
        }
        EMM_DisplacementFVM_VTEGROperator::computeMagneticStress(alpha,beta,nCells,dim,sigma,&(*gM)[0],nCells,&(*gS)[0]);

      
    }
      
};

#endif