EMM_DisplacementOperator.h

Go to the documentation of this file.

#ifndef EMM_DisplacementOperator_H
#define EMM_DisplacementOperator_H

#include "EMM_Operator.h"

#include "EMM_2PackedSymmetricTensors.h"
#include "EMM_4SymmetricTensors.h"

#include "CORE_MorseArray.h"

#include "MATH_GaussLegendreIntegration.h"

#include "EMM_BlockEquilibriumMatrix.h"

#include "MATH_Solver.h"

DEFINE_SPTR(EMM_DisplacementOperator);
class EMM_DisplacementOperator : public virtual EMM_Operator {
    
    SP_OBJECT(EMM_DisplacementOperator);
    // ATTRIBUTES

public:
    //limit condition types
    //time integation methods
    static const tFlag P1;
    static const tFlag TE;

    //is steady state : mElasticityState & 1 = 1 true :
    //    - FROZEN
    //    - EQUILIBRIUM_STATE
    //is equilibrium :
    //     - EQUILIBRIUM_STATE
    static const tFlag FROZEN_STATE;//10
    static const tFlag EQUILIBRIUM_STATE;//11
    static const tFlag UNSTEADY_STATE;//00
private:

    //elastic constraint tensor
    SP::EMM_4SymmetricTensors mLe;

 
    //elastic constraints tensor of the magnetic excitation : \f$ L^{me}= \lambda^m : \lambda^e \f$
    SP::EMM_4Tensors mLme;

    //elastic constraints tensor of the magnetic excitation : \f$ L^{em}= \lambda^e : \lambda^m \f$
    SP::EMM_4Tensors mLem;

      
    //magnetic constraint tensor of the magnetic excitation \f$ L^{mem} = (\lambda^m : (\lambda^e:\lambda^m))  \f$
    SP::EMM_4SymmetricTensors  mLmem;


 
    //indicates the elasticity state
    tFlag mElasticityState;
   

    //integration time method P1|TE
    tFlag mTimeIntegrationMethod;

    //integration time order 1|2
    tUCInt mTimeIntegrationOrder;
    
    //adimensionized size of a cell
    tReal mL[3];

    //time step between \f$ t_{n-1} \f$ and \f$ t_n\f$
    tReal mCFL;
    tReal mDt;
    
    //normalized volumic mass distribution per cell
    EMM_RealArray mKappa;
    
    //limit condition on point i in[0,nPoints[
    // - dirichlet point 1
    // - neumann points 0
    SP::EMM_LimitConditionArray mLimitConditionOnPoints;

  
    //elastic tensor for each cell : \f$ \varepsilon(u)_{ij}=\displaystyle \frac{1}{2} \left ( \frac{\partial u_i}{\partial x_j} + \frac{\partial u_j}{\partial x_i} \right ) \f$
    EMM_2PackedSymmetricTensors mEpsilonUt;
  
    //displacement field at time \f$ t_{n-1} \f$ (for TE)
    SP::EMM_RealField mUnm1;
    
    //displacement field at \f$ t_n \f$
    SP::EMM_RealField mUn;

    //displacement field at \f$ t > t_n \f$
    SP::EMM_RealField mUt;

    //displacement velocity at time (for GLi)
    SP::EMM_RealField mVt;

    //displacement velocity at time  \f$ t_n \f$ 
    SP::EMM_RealField mVn;
   
    //the stress of size n x mDimension \f$ \displaystyle \frac{\partial^2 u}{\partial t^2} = div(sigma) \f$ at time \f$ t_n \f$
    SP::EMM_RealField mAccelerator;

    //the stress of size n x mDimension at time t (for GL4)
    SP::EMM_RealField mAccelerator_t;


    //init data file for displacement
    tString mInitUFile;
    //scale factor for file
    tReal mInitUFileScale;
    //init uniform data for displacement
    SP::EMM_RealField mInitU;
    //init data file for velocity
    tString mInitVFile;
    //scale factor for file
    tReal mInitVFileScale;
    //init uniform data for velocity
    SP::EMM_RealField mInitV;

    //constraint face indicator
    tFlag mConstraintFaces;
    
    //constraints defined on points
    SP::EMM_RealField mConstraints;

    //adimensionized parameters
    tReal mElasticTensorAdimensionizedParameter;//parameter of adimensioning the constraint
    tReal mTc;//caracteristic time
    tReal mLc;//caracteristic length
    tReal mMsat;//magnetization at saturation
     
    //ASSOCIATIONS:
    
    //gauss lagrange integration for next time step fields computing (for GL4)
    SP::MATH_GaussLegendreIntegration mIntegrator; 
    
    //for gauss legendre integration (for  GL4)
    SP::EMM_RealField mUs;
    SP::EMM_RealField mMs;

    //solver
    SP::MATH_Solver mSolver;
    
    //equilibrium matrix
    tBoolean mIsEquilibriumMatrixConditioned;
    SP::EMM_BlockEquilibriumMatrix mEquilibriumMatrix;
    
protected: 

    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_DisplacementOperator(void);
  
    // DESTRUCTORS 
    
    virtual ~EMM_DisplacementOperator(void);
  
  
public:
    //NEW constructor
protected:
    virtual void toDoAfterThisSetting() {
        EMM_Object::toDoAfterThisSetting();
    };

  
public:
   
    //physical data input
    //====================
    virtual void adimensionize(const tReal& Le,const tReal& Ms,const tReal& T,const tReal& L) {
        mElasticTensorAdimensionizedParameter=Le;
        mTc=T;
        mLc=L;
        mMsat=Ms;
    }
    inline const tReal* getAdimensionizedSegmentsSize() const {
        return mL;
    }
    

    inline const EMM_RealArray& getAdimensionizedVolumicMass() const {
        return mKappa;
    }

    inline const EMM_4SymmetricTensors & getLambdaE() const {
        return *mLe.get();
    }
  
    inline const EMM_4Tensors& getLambdaEDoubleDotLambdaM() const {
        return *mLem.get();
    }

    inline const EMM_4Tensors& getLambdaMDoubleDotLambdaE() const {
        return *mLme.get();
    }
    inline const EMM_4SymmetricTensors& getLambdaMDoubleDotLambdaEDoubleDotLambdaM() const {
        return *mLmem.get();
    }

    //initial data
    //=============
    
    inline void setInitialDisplacement(const tReal& scale,const tString& dataFile) {
        mInitUFile=dataFile;
        mInitUFileScale=scale;
    }
    inline void setInitialDisplacement(const tReal data[3]) {
        mInitU->setSize(1);
        EMM_RealField &U=*mInitU.get();
        U.setValue(0,data);
        mInitUFile="";
    }
    inline void setInitialDisplacement(const tReal U0,const tReal& U1,const tReal& U2) {
        mInitU->setSize(1);
        EMM_RealField &U=*mInitU.get();
        U.initField(U0,U1,U2);
        mInitUFile="";
    }
    inline void setInitialDisplacement(const EMM_RealField& data) {
        mInitU->copy(data);
        mInitUFile="";
    }
    inline void setInitialVelocity(const tReal& scale,const tString& dataFile) {
        mInitVFile=dataFile;
        mInitVFileScale=scale;
    }
    inline void setInitialVelocity(const EMM_RealField& data) {
        mInitV->copy(data);
        mInitVFile="";
    }
    
    inline void setInitialVelocity(const tReal data[3]) {
        mInitV->setSize(1);
        EMM_RealField &V=*mInitV.get();
        V.setValue(0,data);
        mInitVFile="";
    }
    inline void setInitialVelocity(const tReal& V0,const tReal& V1,const tReal& V2) {
        mInitV->setSize(1);
        EMM_RealField &V=*mInitV.get();
        V.initField(V0,V1,V2);
        mInitVFile="";
    }

   

    //limit conditions input data
    //===========================
    
    inline void setLimitConditionOnPoints(const EMM_IntArray& lc) {
        mLimitConditionOnPoints->copy(lc);
    }
   
    inline void setLimitConditionOnPoints(const tLimitCondition& lc) {
        mLimitConditionOnPoints->setSize(1);
        (*mLimitConditionOnPoints.get())[0]=lc;
    }

    inline void setConstraints(const tFlag& C,const tString& dataFile) {
        mConstraintFaces=C;
        if (!mConstraints->loadFromFile(dataFile))
            throw EMM_Exception("emicrom/operator/magnetostriction",
                                "EMM_DisplacementOperator::setConstraints(fileName)",
                                "error in reading the file "+dataFile);
        
    }
    inline void setConstraints(const tFlag& C,const tReal data[3]) {
        mConstraintFaces=C;
        mConstraints->setSize(1);
        EMM_RealField &V=*mConstraints.get();
        V.setValue(0,data);
    }
    inline void setConstraints(const tFlag& C,
                               const tReal& C0,const tReal& C1,const tReal& C2) {
        mConstraintFaces=C;
        mConstraints->setSize(1);
        EMM_RealField &V=*mConstraints.get();
        V.initField(C0,C1,C2);
    }
    inline void setConstraints(const tFlag& C,const EMM_RealField& data) {
        mConstraintFaces=C;
        mConstraints->copy(data);
    }

    inline const tFlag& getConstraintFaces() const {
        return mConstraintFaces;
    }
    
    inline const EMM_RealField& getConstraints() const {
        return *mConstraints.get();
    }
    inline EMM_RealField& getConstraints() {
        return *mConstraints.get();
    }
   
public:
    /*  get the limit condition value for all points of the mesh.
     * @return the array at all points:
     * - NO_LIMIT_CONDITION for all interior points or not magnetized point
     * - DIRICHLET_LIMIT_CONDITION for all points on Dirichlet boundary
     * - NEUMANN_LIMIT_CONDITION for all points on Neumann boundary
     */
    inline const EMM_LimitConditionArray&  getLimitConditionOnPoints() const {
        return *mLimitConditionOnPoints.get();
    }
    /*  get the limit condition value for all points of the mesh.
     * @return the array at all points:
     * - NO_LIMIT_CONDITION for all interior points or not magnetized point
     * - DIRICHLET_LIMIT_CONDITION for all points on Dirichlet boundary
     * - NEUMANN_LIMIT_CONDITION for all points on Neumann boundary
     */
    inline SPC::EMM_LimitConditionArray  getLimitConditionOnPointsByReference() const {
        return mLimitConditionOnPoints;
    }


    virtual void buildDataOnBoundaryFaces(const EMM_Grid3D& mesh,
                                          const EMM_LimitConditionArray& limitConditionOnPoints,
                                          const EMM_RealField& U0,
                                          EMM_RealField& DnU0) = 0;
    
      
    void  nullProjectionOnDirichletBoundary(EMM_RealField& V) const;

    void  nullProjectionOnDirichletBoundary(const tUIndex& nPoints,const tDimension& dim,tReal* V) const;
    
    void  projectionOnDirichletBoundary(const EMM_RealField& V0, EMM_RealField& V) const;
  

    void  projectionOnDirichletBoundary(const tUIndex& nPoints,const tDimension& dim,const tBoolean& incV0,const tReal* V0, tReal* V) const;
    
    
    void periodicProjection(const tCellFlag& periodicity,const tUInteger nPoints[3],EMM_RealField& V) const;

    
    //discretization methods
    //======================
   
     
    virtual tULLInt getMemorySize() const;
     
    
    virtual tBoolean discretize(const EMM_LandauLifschitzSystem& system);

    virtual tBoolean resetToInitialState(const EMM_LandauLifschitzSystem& system) ;
    
    //backup & restore methods
    //========================
     
public:
    virtual tBoolean backup(const tString& prefix,const tString& suffix,const tString& ext) const;
    
    virtual tBoolean restore(const EMM_LandauLifschitzSystem& system,
                             const tString& prefix,const tString& suffix,const tString& ext);

    //output data
    //=============
    
    inline const EMM_2PackedSymmetricTensors& getElasticTensor() const {
        return mEpsilonUt;
    }
    //Data fields methods
    //===================
    
    virtual  tUSInt getDataFieldsNumber() const {
        return (isSteadyState())?1:3;
    }
   
   
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const float *& values) const {
        tBoolean succeeds=false;
        switch(index) {
        case 0:
            dataName="U";
            dim=mUn->getDimension();
            succeeds=mUn->getValues(n,values);
            n/=dim;
            break;
        case 1:
            dataName="dU_dt";
            dim=mVn->getDimension();
            succeeds=mVn->getValues(n,values);
            n/=dim;
            break;
            
        case 2:
            dataName="d2U_dt2";
            dim=mAccelerator->getDimension();
            succeeds=mAccelerator->getValues(n,values);
            n/=dim;
            break;
        }
        return succeeds;
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const double *& values) const { 
         tBoolean succeeds=false;
        switch(index) {
        case 0:
            dataName="U";
            dim=mUn->getDimension();
            succeeds=mUn->getValues(n,values);
            n/=dim;
            break;
        case 1:
            dataName="dU_dt";
            dim=mVn->getDimension();
            succeeds=mVn->getValues(n,values);
            n/=dim;
            break;
        case 2:
            dataName="d2U_dt2";
            dim=mAccelerator->getDimension();
            succeeds=mAccelerator->getValues(n,values);
            n/=dim;
            break;
       
       
        }
        return succeeds;
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tDimension& dim,const long double *& values) const {
        tBoolean succeeds=false;
        switch(index) {
        case 0:
            dataName="U";
            dim=mUn->getDimension();
            succeeds=mUn->getValues(n,values);
            n/=dim;
            break;
        case 1:
            dataName="dU_dt";
            dim=mVn->getDimension();
            succeeds=mVn->getValues(n,values);
            n/=dim;
            break;
      
        case 2:
            dataName="d2U_dt2";
            dim=mAccelerator->getDimension();
            succeeds=mAccelerator->getValues(n,values);
            n/=dim;
            break;
        
        }
        return succeeds;
       
        
    }


public:

    //operator attributes 
    //=================
    
    virtual tBoolean isAffine() const {
        return false;
    }
    virtual tBoolean isGradientComputationable() const {
        return false;
    }



    //Displacement fields Methods at 2 times 
    //======================================
public:
    inline void setDisplacement(const EMM_RealField& u) {
        mUn->copy(u);
    }
    inline void setDisplacement(const tReal& Ux,const tReal& Uy,const tReal& Uz) {
        mUn->initField(Ux,Uy,Uz);
    }
    inline EMM_RealField& getDisplacement() {
        return *mUn.get();
    }
    inline const EMM_RealField& getDisplacement() const {
        return *mUn.get();
    }
    inline const EMM_RealField& getDisplacement(const tReal& t) const {
        if ((t==0) || (isSteadyState())) return *mUn.get();
        else if (t<0) return *mUnm1.get();
        else  return *mUt.get();
    }


    
    void setVelocity(const EMM_RealField& v) {
        mVn->copy(v);
      
    }
    void setVelocity(const tReal& Vx,const tReal& Vy,const tReal& Vz) {
        mVn->initField(Vx,Vy,Vz);
    }
    inline EMM_RealField& getVelocity() {
        return *mVn.get();
    }
    inline const EMM_RealField& getVelocity(const tReal& t) const {
        if ((t==0)||(isSteadyState())) return *mVn.get();
        else return *mVt.get();
    }
    
    inline const EMM_RealField& getVelocity() const {
        return *mVn.get();
    }
public:
    inline EMM_RealField& getAccelerator() {
        return *mAccelerator.get();
    }
    inline const EMM_RealField& getAccelerator() const {
        return *mAccelerator.get();
    }


    //linear system solver
    //=====================

    virtual void setSolver(const tString& solverName);

    void setSolver(SP::MATH_Solver solver) {
        mSolver=solver;
    }
    
    inline MATH_Solver* getSolver() {
        return mSolver.get();
    }
    //Time integration methods
    //=========================
    
    inline void setElasticityState(const tFlag& v) {
        mElasticityState=v;
    }
    /* \brief @return true if the elastity is steady
     * 
     */
    inline tBoolean isSteadyState() const {
        return ((mElasticityState & 1)==1);
    }
    /* \brief @return true if the elastity is at equilibrium
     */
    inline tBoolean isEquilibriumState() const {
        return (mElasticityState==EQUILIBRIUM_STATE);
    }
    /* \brief @return true if the elastity is frozen
     */
    inline tBoolean isFrozenState() const {
        return (mElasticityState==FROZEN_STATE);
    }
   
   
    inline void setTimeIntegrationMethod(const tFlag& m) {
        mTimeIntegrationMethod=m;
    }
    inline const tFlag& getTimeIntegrationMethod() const {
        return mTimeIntegrationMethod;
    }
    inline void setTimeIntegrationOrder(const tInt& o) {
        mTimeIntegrationOrder=o;
    }
    inline const tUCInt& getTimeIntegrationOrder() const {
        return mTimeIntegrationOrder;
    }
   
    inline const tReal& getTimeStep() const {
        return mDt;
    }
 
    //time evolutions of fields for unsteady state
    //=============================================
public:
    inline void setCFL(const tReal& cfl)  {
        mCFL=cfl;
    }
    
    virtual tBoolean computeFieldsAtTime(const tReal& t,
                                         const tFlag& order,
                                         const EMM_RealArray& sigma,
                                         const EMM_RealField& dM_dt0,
                                         const EMM_RealField& M0);
    
   
    virtual tBoolean updateAtNextTimeStep(const tReal& dt,
                                          const EMM_RealArray& sigma,
                                          const EMM_RealField& Mt);
  
    
private:
    tBoolean computePastDisplacement(const tReal& dt,
                                     const EMM_RealField& accelerator,
                                     const EMM_RealField& U0,
                                     const EMM_RealField& V0,
                                     EMM_RealField& U) const;
    
                                    
    tBoolean computeFieldsAtTimeWithTE2(const tReal& dtau,
                                        const tReal& dt,
                                        const EMM_RealField& accelerator,
                                        const EMM_RealField& U0,
                                        const EMM_RealField& U1,
                                        EMM_RealField& U2,
                                        EMM_RealField& V2) const;


    tBoolean computeFieldsAtTimeWithTE1(const tReal& dt,
                                        const EMM_RealField& accelerator,
                                        const EMM_RealField& U0,
                                        const EMM_RealField& V0,
                                        EMM_RealField& U1,
                                        EMM_RealField& V1) const;

   
    
    tBoolean computeFieldsAtTimeWithGL1Interpolation(const tReal& dt,
                                                     const EMM_RealArray& sigma,
                                                     const EMM_RealField& dM_dt0,
                                                     const EMM_RealField& M0,
                                                     const EMM_RealField& U0,
                                                     const EMM_RealField& V0,
                                                     EMM_RealField& Ut,
                                                     EMM_RealField& Vt) const;
    
    tBoolean computeFieldsAtTimeWithGLnInterpolation(const tReal& dt,
                                                     const EMM_RealArray& sigma,
                                                     const EMM_RealField& dM_dt0,
                                                     const EMM_RealField& M0,
                                                     const EMM_RealField& U0,
                                                     const EMM_RealField& V0,
                                                     EMM_RealField& Ut,
                                                     EMM_RealField& Vt,
                                                     EMM_RealField& Us,
                                                     EMM_RealField& Ms);

private:

    tBoolean computeAccelerator(EMM_RealField& V);

    virtual tBoolean solveAcceleratorSystem(EMM_RealField& V)=0;

    virtual void spaceProjection(EMM_RealField& V) const=0;

    virtual void spaceProjection(const EMM_RealField& V0, EMM_RealField& V) const=0;
    
protected:
    virtual void spaceRelevant(EMM_RealField& V) const=0;

    //steady state methods
    //===================
  
public:
  
    virtual SP::EMM_BlockEquilibriumMatrix NewEquilibriumMatrix() const;
   
    
    inline void setIsEquilibriumMatrixReconditioned(const tBoolean& c) {
        mIsEquilibriumMatrixConditioned=c;
    }
    inline const tBoolean&  isEquilibriumMatrixReconditioned() const  {
        return mIsEquilibriumMatrixConditioned;
    }
    
    virtual  void computeEquilibriumMatrixDiagonalConditioner(MATH_Vector& D) const {
        D.setSize(0);
    }
protected:
    virtual void initializeEquilibriumSolver( const EMM_RealField& U0);
    
public:
    
    tBoolean computeEquilibriumState(const EMM_RealArray& sigma,
                                     const EMM_RealField& M,
                                     const EMM_RealField& U0,
                                     EMM_RealField& U);
    

public:
    virtual void computeElasticStressMatrixProduct(const tUIndex& nData,const tDimension& dim, const tReal* U,tReal* D) const {
        computeElasticStress(false,-1,nData,dim,U,D);
    }

    
    
  
    //elastic tensor methods
    //==========================
public:
    
    virtual void computeElasticTensor(const EMM_RealField& U, EMM_2PackedSymmetricTensors& eTensor);

   

protected:

  
    virtual void computeElasticTensor(const tUIndex& nData,
                                      const tDimension& dim,
                                      const tReal* U,
                                      EMM_2PackedSymmetricTensors& eTensor) const=0;

    
    //stress methods
    //==============
public:
    inline void  computeStress(const EMM_RealArray& sigma,const EMM_RealField&U,const EMM_RealField& M,EMM_RealField& stress) const {
        computeElasticStress(U,stress);
        computeMagneticStress(1,-1,sigma,M,stress);
    }
    
    
    //elastic stress
    //==============
    
    virtual void computeElasticStress(const EMM_RealField& U, EMM_RealField& S) const {
        tUIndex nU,nS;
        const tDimension &dim=U.getDimension();
        const tReal *Us;
        tReal *Ss;
        if (!U.getValues(nU,Us)) {
            throw EMM_Exception("emicrom/operators/magnetistriction",
                                "EMM_DisplacementOperator::computeElasticStress(U,S)",
                                "displacement field has incompatible real type");
        }
        if (!S.getValues(nS,Ss)) {
            throw EMM_Exception("emicrom/operators/magnetistriction",
                                "EMM_DisplacementOperator::computeElasticStress(U,S)",
                                "stress field has incompatible real type");
        }
        if (nU!=nS)  {
            throw EMM_Exception("emicrom/operators/magnetistriction",
                                "EMM_DisplacementOperator::computeElasticStress(U,S)",
                                "stress field & displacement field has incompatible size");
            
        }
        nU/=dim;
        
        computeElasticStress(nU,dim,Us,Ss);
    }
    
public:
   
    inline void computeElasticStress(const tUIndex& nData,const tDimension& dim, const tReal* U,tReal* D) const {
        computeElasticStress(true,1,nData,dim,U,D);
    }
    
protected:
    virtual void computeElasticStress(const tBoolean& withConstraints,
                                      const tReal& beta,
                                      const tUIndex& nData,const tDimension& dim,
                                      const tReal* U,
                                      tReal* D) const=0;
    
   

public:
    inline void computeMagneticStress(const EMM_RealArray& sigma,const EMM_RealField& M, EMM_RealField& S) const {
        //get the dimensipon of the discrete space
        tUIndex nData=mUn->getSize();
        const tDimension& dim=mUn->getDimension();
        //update the  size of the discrete magnetic stress field
        S.setDimension(dim);
        S.setSize(nData);
        //compute the magnetic stress field
        computeMagneticStress(0.,1.,sigma,M,S);
    }
    
    virtual void computeMagneticStress(const tReal& alpha,const tReal& beta,
                                       const EMM_RealArray& sigma,const EMM_RealField& M,
                                       EMM_RealField& S) const=0;

   
   
    
protected:
    
    virtual void computeMagneticStress(const tReal& alpha,const tReal& beta,
                                       const tUIndex& nCells,const tDimension& dim, const EMM_RealArray& sigma,
                                       const tReal* M,
                                       const tUIndex& nS,tReal* S) const=0;


public:
  
    
   



    //energy methods
    //===================
public: 
    tReal computeEnergy(const tReal& t,
                        const tUIndex& nCells,const tDimension& dim,
                        const EMM_RealArray& sigma,
                        const tReal* M) const;
   
    
    inline tReal computeCineticEnergyAtTime(const tReal& t) const {
        return computeCineticEnergy(getVelocity(t));
    }
    virtual tReal computeCineticEnergy(const EMM_RealField& V) const=0;
    
    
     
    inline tReal computePotentialEnergyAtTime(const tReal& t) const {
        return computePotentialEnergy(getDisplacement(t));
    }
    
    virtual tReal computePotentialEnergy(const EMM_RealField& U) const;
    
    inline tReal computeStressConstraintEnergy(const tReal& t) const {
        return computeStressConstraintEnergy(getDisplacement(t));
    }
 

     
  
    virtual tReal computeStressConstraintEnergy(const EMM_RealField& U) const=0;

    
                                 
                                      
public:
    virtual tString toString() const {
        return EMM_Operator::toString();
    }
    

   
};

#endif