interface for resiudal strain material laws

NonLinearSolver/internalPoints/CMakeLists.txt

@@ -60,6 +60,7 @@ set(SRC
   ipVoidState.cpp
   ipLinearElecMagInductor.cpp
   ipGenericTM.cpp
+  ipGenericRM.cpp
   ipElecMagGenericThermoMech.cpp
   ipElecMagInductor.cpp
   ipNonLinearTVM.cpp

NonLinearSolver/internalPoints/ipGenericRM.cpp

+//
+// Created by mohib on 14.08.24.
+//
+
+#include "ipGenericRM.h"
+#include "ipField.h"
+
+IPGenericRM::IPGenericRM(const STensor3 &_FRes) : IPVariableMechanics()
+{
+    _ipMeca=NULL;
+    FRes=_FRes;
+}
+
+IPGenericRM::IPGenericRM(const IPGenericRM &source) :
+IPVariableMechanics(source), _ipMeca(NULL)
+{
+    if(source._ipMeca!=NULL)
+    {
+        if(_ipMeca!=NULL)
+        {
+            delete _ipMeca;
+            _ipMeca=NULL;
+        }
+        _ipMeca = dynamic_cast<IPVariableMechanics *>(source.getConstRefToIpMeca().clone());
+    }
+    FRes=source.FRes;
+}
+
+IPGenericRM& IPGenericRM::operator=(const IPVariable &source)
+{
+    IPVariableMechanics::operator=(source);
+    const IPGenericRM* src = dynamic_cast<const IPGenericRM*>(&source);
+    if(src)
+    {
+        if(src->_ipMeca!=NULL)
+        {
+            if(_ipMeca!=NULL)
+            {
+                _ipMeca->operator=(dynamic_cast<const IPVariable &> (*(src->_ipMeca)));
+            }
+            else
+                _ipMeca = dynamic_cast<IPVariableMechanics *>((src->getConstRefToIpMeca()).clone());
+        }
+        FRes=src->FRes;
+    }
+    return *this;
+}
+
+void IPGenericRM::restart()
+{
+    _ipMeca->restart();
+    restartManager::restart(FRes);
+    IPVariableMechanics::restart();
+}
+
+double IPGenericRM::get(const int comp) const
+{
+   if(comp==IPField::FfAM_XX)
+     return FRes(0,0);
+   else    if(comp==IPField::FfAM_YY)
+     return FRes(1,1);
+   else    if(comp==IPField::FfAM_ZZ)
+     return FRes(2,2);
+   else    if(comp==IPField::FfAM_XY)
+     return FRes(0,1);
+   else    if(comp==IPField::FfAM_ZX)
+     return FRes(0,2);
+   else    if(comp==IPField::FfAM_YZ)
+     return FRes(1,2);
+   else 
+       return _ipMeca->get(comp);
+
+}
+
+double & IPGenericRM::getRef(const int comp)
+{
+  if(comp==IPField::FfAM_XX)
+     return FRes(0,0);
+   else    if(comp==IPField::FfAM_YY)
+     return FRes(1,1);
+   else    if(comp==IPField::FfAM_ZZ)
+     return FRes(2,2);
+   else    if(comp==IPField::FfAM_XY)
+     return FRes(0,1);
+   else    if(comp==IPField::FfAM_ZX)
+     return FRes(0,2);
+   else    if(comp==IPField::FfAM_YZ)
+     return FRes(1,2);
+   else 
+       return _ipMeca->getRef(comp);
+}

NonLinearSolver/internalPoints/ipGenericRM.h

+//
+// Created by mohib on 14.08.24.
+//
+
+#ifndef IPGENERICRM_H_
+#define IPGENERICRM_H_
+
+#include "ipvariable.h"
+#include "STensor3.h"
+#include "STensorOperations.h"
+
+class IPGenericRM : public IPVariableMechanics
+{
+protected:
+    IPVariableMechanics * _ipMeca;
+    STensor3 FRes;
+public:
+    IPGenericRM(const STensor3 &_FRes);
+
+public:
+    ~IPGenericRM()
+    {
+        if(_ipMeca!=NULL)
+        {
+            delete _ipMeca;
+            _ipMeca=NULL;
+        }
+    }
+
+    IPGenericRM(const IPGenericRM &source);
+    virtual IPGenericRM& operator=(const IPVariable &source);
+    virtual double defoEnergy() const{return _ipMeca->defoEnergy();};
+    virtual double plasticEnergy() const{return _ipMeca->plasticEnergy();}
+    virtual double damageEnergy() const{return  _ipMeca->damageEnergy();}
+    virtual double irreversibleEnergy() const{return  _ipMeca->irreversibleEnergy();}
+
+    virtual void restart();
+    virtual void setValueForBodyForce(const STensor43& K, const int ModuliType){ _ipMeca->setValueForBodyForce(K,ModuliType); }
+    virtual const STensor43 &getConstRefToTangentModuli() const{return _ipMeca->getConstRefToTangentModuli();};
+    virtual void computeBodyForce(const STensor33& G, SVector3& B) const { _ipMeca->computeBodyForce(G,B); }
+
+    virtual IPVariable* clone() const {return new IPGenericRM(*this);};
+
+    const IPVariableMechanics& getConstRefToIpMeca() const {return *_ipMeca;}
+    IPVariableMechanics& getRefToIpMeca() {return *_ipMeca;}
+    void setIpMeca(IPVariable& ipMeca)
+    {
+        if(_ipMeca!=NULL)
+        {
+            delete _ipMeca;
+            _ipMeca=NULL;
+        }
+        _ipMeca= (dynamic_cast<IPVariableMechanics *>(ipMeca.clone()));
+    }
+    const STensor3 & getConstRefToFRes() const { return FRes;}
+    STensor3 & getRefToFRes(){ return FRes;}
+
+    virtual double get(const int comp) const;
+    virtual double & getRef(const int comp);
+  private:
+      IPGenericRM(){};
+
+};
+
+#endif //IPGENERICTM_H_

NonLinearSolver/materialLaw/CMakeLists.txt

@@ -101,6 +101,7 @@ set(SRC
   mlawNonLocalPorousWithFailure.cpp
   mlawLinearElecMagInductor.cpp
   mlawGenericTM.cpp
+  mlawGenericRM.cpp
   mlawElecMagGenericThermoMech.cpp
   mlawElecMagInductor.cpp
   mlawNonLinearTVM.cpp

NonLinearSolver/materialLaw/mlaw.h

@@ -36,7 +36,7 @@ class materialLaw{
                  localDamageJ2SmallStrain,nonLocalDamageJ2SmallStrain,cluster,tfa,ANN, DMN, torchANN, NonlocalDamageTorchANN, LinearElecMagTherMech, LinearElecMagInductor, hyperviscoelastic,
                  GenericThermoMechanics, ElecMagGenericThermoMechanics, ElecMagInductor,
                  nonlineartvm,nonlinearTVE,nonlinearTVP,vevpmfh, VEVPUMAT, IMDEACPUMAT, Hill48,nonlinearTVEnonlinearTVP,nonlinearTVEnonlinearTVP2,
-                 MultipleLaws};
+                 MultipleLaws,GenericResidualStrain};
 
 
  protected :

NonLinearSolver/materialLaw/mlawGenericRM.cpp

+// C++ Interface: material law
+//              Generic Residual Strain law
+// Author:  <mohib>, (C) 2024
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+#include "mlawGenericRM.h"
+#include <math.h>
+#include "MInterfaceElement.h"
+
+mlawGenericTM::mlawGenericRM(const int num, const char* inputname, const bool init) :
+        materialLaw(num, init)
+{
+    _mecaLaw=NULL;
+    inputfilename = inputname;
+    _FRes = new constantScalarFunction(1.);
+
+}
+
+void mlawGenericTM::setLawForFRes(const scalarFunction& funcFRes)
+{
+    if (_FRes != NULL) delete _FRes;
+    _FRes = funcFRes.clone();
+}
+
+mlawGenericRM::mlawGenericRM(const mlawGenericRM& source) : materialLaw(source), _mecaLaw(NULL)
+{
+    inputfilename = source.inputfilename;
+    if(source._mecaLaw!=NULL)
+    {
+        if(_mecaLaw != NULL)
+        {
+            delete _mecaLaw;
+            _mecaLaw = NULL;
+        }
+        _mecaLaw=source._mecaLaw->clone();
+    }
+    _FRes = NULL;
+    if(source._FRes)
+        _FRes = source._FRes->clone();
+}
+
+mlawGenericRM& mlawGenericRM::operator=(const materialLaw& source)
+{
+    mlawCoupledThermoMechanics::operator=(source);
+    const mlawGenericRM* src =static_cast<const mlawGenericRM*>(&source);
+    if(src !=NULL)
+    {
+        if(src->_mecaLaw!=NULL)
+        {
+            if(_mecaLaw != NULL)
+            {
+                _mecaLaw->operator=(dynamic_cast<const materialLaw& >(*(src->_mecaLaw)));
+            }
+            else
+              _mecaLaw=src->_mecaLaw->clone();
+        }
+
+        if (_FRes!= NULL) delete _FRes; _FRes = NULL;
+        if (src->_Fres != NULL) _FRes = src->_FRes->clone();
+        inputfilename = src->inputname;
+
+    }
+    return *this;
+}
+
+//createIPVariable cf mlawTFA
+void mlawGenericRM::createIPState(IPStateBase* &ips,bool hasBodyForce, const bool* state_,const MElement *ele, const int nbFF_,
+                   const IntPt *GP, const int gpt) const
+{
+
+  bool inter=true;
+  const MInterfaceElement *iele = dynamic_cast<const MInterfaceElement*>(ele);
+  if(iele==NULL) inter=false;
+
+  static SPoint3 pt_Global;
+  ele->pnt(GP->pt[0],GP->pt[1],GP->pt[2],pt_Global);
+  static SVector3 GaussP;
+  GaussP[0] = pt_Global[0];
+  GaussP[1] = pt_Global[1];
+  GaussP[2] = pt_Global[2];
+  
+
+  // get the value? Reads the file     inputfilename and get the closest point @mohib do it in a function
+
+  
+  STensor3 FRes;
+
+  if(ips != NULL) delete ips;
+  IPGenericRM *ipvi=new IPGenericRM(FRes);
+  IPGenericRM *ipv1=new IPGenericRM(FRes);
+  IPGenericRM *ipv2=new IPGenericRM(FRes);
+
+  IPStateBase* ipsmeca=NULL;
+  getConstRefMechanicalMaterialLaw().createIPState(ipsmeca,hasBodyForce, state_,ele, nbFF_,GP, gpt);
+  std::vector<IPVariable*> allIP;
+  ipsmeca->getAllIPVariable(allIP);
+
+  ipvi->setIpMeca(*allIP[0]->clone());
+  ipv1->setIpMeca(*allIP[1]->clone());
+  ipv2->setIpMeca(*allIP[2]->clone());
+
+  ips = new IP3State(state_,ipvi,ipv1,ipv2);
+  delete ipsmeca;
+}
+
+void mlawGenericRM::createIPVariable(IPGenericRM* &ipv, bool hasBodyForce, const MElement *ele, const int nbFF,
+                                     const IntPt *GP, const int gpt) const
+{
+  bool inter=true;
+  const MInterfaceElement *iele = dynamic_cast<const MInterfaceElement*>(ele);
+  if(iele==NULL) inter=false;
+
+  static SPoint3 pt_Global;
+  ele->pnt(GP->pt[0],GP->pt[1],GP->pt[2],pt_Global);
+  static SVector3 GaussP;
+  GaussP[0] = pt_Global[0];
+  GaussP[1] = pt_Global[1];
+  GaussP[2] = pt_Global[2];
+  
+
+  // get the value? Reads the file     inputfilename and get the closest point @mohib do it in a function
+
+  
+  STensor3 FRes;
+
+    if(ipv != NULL)
+        delete ipv;
+    ipv = new IPGenericRM(FRes);
+
+    IPStateBase* ipsmeca=NULL;
+    const bool state_ = true;
+    getConstRefMechanicalMaterialLaw().createIPState(ipsmeca,hasBodyForce, &state_,ele, nbFF,GP, gpt);
+
+    std::vector<IPVariable*> allIP;
+    ipsmeca->getAllIPVariable(allIP);
+
+    ipv->setIpMeca(*allIP[0]->clone());
+    delete ipsmeca;
+}
+
+void mlawGenericRM::constitutive(            
+            const STensor3      &F0,                   // initial deformation gradient (input @ time n)
+            const STensor3      &Fn,                   // updated deformation gradient (input @ time n+1)
+            STensor3            &P,                    // updated 1st Piola-Kirchhoff stress tensor (output)
+            const IPVariable    *q0,                   // array of initial internal variable
+            IPVariable          *q1,                   // updated array of internal variable (in ipvcur on output),
+            STensor43           &Tangent,              // constitutive tangents (output)
+            const bool          stiff,
+            STensor43           *elasticTangent=NULL,
+            const bool dTangent =false,
+            STensor63* dCalgdeps = NULL
+
+                               ) const
+{
+    if(_mecaLaw == NULL)
+        Msg::Error("Mechanic law is null");
+
+    STensorOperation::zero(Tangent);
+
+    const double dh= getTimeStep();
+    const time=getTime();
+
+
+    const IPGenericRM &qRM0= dynamic_cast<const IPGenericRM &> (*q0);
+    IPGenericTM &qRM1= dynamic_cast<IPGenericRM &> (*q1);
+
+    static STensor3 FRes,FRes0,FResInv,FRes0Inv;
+    static STensor43 dFResdFn;
+    STensorOperation::zero(FRes);
+    STensorOperation::zero(FResInv);
+    STensorOperation::zero(dFResdFn);
+    STensorOperation::zero(FRes0);
+    STensorOperation::zero(FRes0Inv);
+
+    const STensor3 I2(1.0);
+    const STensor43 I4(2.0,0.0);
+
+    FRes = qRM1.getConstRefToFRes();
+    double scaleFactor=_FRes->get(time);
+    FRes-= I2;
+    FRes*=scaleFactor;
+    FRes+=I;
+    STensorOperation::inverseSTensor3(FRes, FResInv);
+
+    FRes0 = qRM0.getConstRefToFRes();
+    double time0=time;
+    if(getTimeStep()>0)
+     time0 -= getTimeStep():    
+    double scaleFactor0=_FRes->get(time0);
+    FRes0-= I2;
+    FRes0*=scaleFactor0;
+    FRes0+=I;
+    STensorOperation::inverseSTensor3(FRes0, FRes0Inv);
+
+
+    for (int i=0; i<3; i++){
+        for (int j=0; j<3; j++){
+            for (int k=0; k<3; k++){
+                for (int m=0; m<3; m++){
+                    for (int n=0; n<3; n++){
+                        dFResdFn(i,k,m,n) += FRes(i,j) * I2(j,m) * I2(k,n); /// to chnage to reflect order
+                    }
+                }
+            }
+        }
+    }
+    // need to updqte kt etc...
+    const double JacRes = FRes.determinant();
+
+
+    const IPVariableMechanics& qMeca0 = dynamic_cast<const IPGenericRM&>(*q0).getConstRefToIpMeca();
+    IPVariableMechanics& qMecan = dynamic_cast<IPGenericRM&>(*q1).getRefToIpMeca();
+
+
+    //Fmeca from F and Fthermal (possible using reference F?) for 0 and n
+    static STensor3 Fmeca, Fmeca0;
+ 
+    // Fmeca from F and FRes
+    STensorOperation::multSTensor3(Fn,FRes, Fmeca);
+    // Fmeca from F and FRes
+    STensorOperation::multSTensor3(F0,FRes0, Fmeca0);
+
+    static STensor43 dFmecadF;
+    STensorOperation::zero(dFmecadF);
+
+    for (int i=0; i<3; i++){
+        for (int j=0; j<3; j++){
+            for (int k=0; k<3; k++){
+                for(int l = 0; l < 3; ++l){
+                    dFmecadF(i,j,k,l)=I2(i,k)*FResinv(l,j);
+                }
+            }
+        }
+    }
+
+    static STensor3 Pmeca;
+    static STensor43 TangentMeca;
+    static STensor43 elasticTangentMeca;
+    static Stensor63 dTangentMecadF;
+
+    STensorOperation::zero(Pmeca);
+    STensorOperation::zero(TangentMeca);
+    STensorOperation::zero(elasticTangentMeca);
+    STensorOperation::zero(dTangentMecadF);
+
+    _mecaLaw->constitutive(Fmeca0, Fmeca, Pmeca,
+                           &qTM0.getConstRefToIpMeca(),
+                           &qTM1.getRefToIpMeca(),
+                           TangentMeca, stiff,
+                           &elasticTangentMeca, dTangent,  &dTangentMecadF);
+
+
+    // P, Tangent etc..; from Pmeca and Fth and Fref
+
+    // get P
+    STensorOperation::multSTensor3(Pmeca, FResinvT, P);
+
+    // get Tangent
+    if(stiff){
+        for(int i=0; i<3; i++)
+        {
+            for(int J=0; J<3; J++)
+            {
+                for(int k=0; k<3; k++)
+                {
+                    for(int L=0; L<3; L++)
+                    {
+                        Tangent(i,J,k,L)=0.0;
+                        if elasticTangent!=0
+                          *elasticTangent(i,J,k,L)=0.0;
+                          
+                        for(int M=0; M<3; M++)
+                        {
+                            for(int o=0; o<3; o++)
+                            {
+                                for(int P=0; P<3; P++)
+                                {
+                                    Tangent(i,J,k,L)+=TangentMeca(i,M,o,P)*dFmecadF(o,P,k,L)*FResinvT(M,J);
+                                    if elasticTangent!=0
+                                       *elasticTangent(i,J,k,L)=*elasticTangentMeca(i,M,o,P)*dFmecadF(o,P,k,L)*FResinvT(M,J);;
+
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if(dTangent)
+        {
+          for(int i=0; i<3; i++)
+          {
+            for(int J=0; J<3; J++)
+            {
+                for(int k=0; k<3; k++)
+                {
+                    for(int L=0; L<3; L++)
+                    {
+
+                      for(int r=0; r<3; r++)
+                      {
+                         for(int S=0; S<3; S++)
+                         {
+                            *dCalgdeps(i,J,k,L,r,S)=0.;
+
+                          
+                        for(int M=0; M<3; M++)
+                        {
+                            for(int o=0; o<3; o++)
+                            {
+                                for(int P=0; P<3; P++)
+                                {
+                                    *dCalgdeps(i,J,k,L,r,S)+=dTangentMecadF(i,M,k,L,o,P)*dFmecadF(o,P,r,S)*FResinvT(M,J); //to check
+ 
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+          }
+        }
+ 
+    }
+
+}
+
+void mlawGenericRM::ElasticStiffness(STensor43 *elasticStiffness) const {
+    getConstRefMechanicalMaterialLaw().ElasticStiffness(elasticStiffness);
+}

NonLinearSolver/materialLaw/mlawGenericRM.h

+// C++ Interface: material law
+//              Generic Residual Strain law
+// Author:  <mohib>, (C) 2024
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+
+#ifndef MLAWGENERICRM_H_
+#define MLAWGENERICRM_H_
+
+#include "mlaw.h"
+#include "STensor3.h"
+#include "STensor43.h"
+#include "STensor63.h"
+#include "scalarFunction.h"
+#include "ipGenericRM.h"
+#include "mlawCoupledThermoMechanics.h"
+
+
+class mlawGenericRM : public  materialLaw {
+protected:
+   //mechanical
+    materialLaw *_mecaLaw;
+    //
+    const char* inputfilename;
+    scalarFunction* _FRes;
+
+
+public:
+    mlawGenericRM(const int num, const char* inputfilename, const bool init = true);
+    const materialLaw &getConstRefMechanicalMaterialLaw() const
+    {
+        if(_mecaLaw == NULL)
+            Msg::Error("getConstRefMechanicalMaterialLaw: Mechanic law is null");
+        return *_mecaLaw;
+    }
+    materialLaw &getRefMechanicalMaterialLaw()
+    {
+        if(_mecaLaw == NULL)
+            Msg::Error("getRefMechanicalMaterialLaw: Mechanic law is null");
+        return *_mecaLaw;
+    }
+    virtual void setMechanicalMaterialLaw(const materialLaw *mlaw)
+    {
+        if(_mecaLaw != NULL)
+        {
+            delete _mecaLaw;
+            _mecaLaw = NULL;
+        }
+        _mecaLaw=mlaw->clone();
+
+    }
+    virtual void setTime(const double ctime,const double dtime){
+        mlawCoupledThermoMechanics::setTime(ctime,dtime);
+        if(_mecaLaw == NULL)
+            Msg::Error("setTime: Mechanic law is null");
+        _mecaLaw->setTime(ctime,dtime);
+    }
+    virtual void setMacroSolver(const nonLinearMechSolver* sv)
+    {
+        if(_mecaLaw == NULL)
+            Msg::Error("setMacroSolver: Mechanic law is null");
+        _mecaLaw->setMacroSolver( sv);
+    }
+#ifndef SWIG
+    virtual ~mlawGenericRM()
+    {
+        if(_mecaLaw != NULL)
+        {
+            delete _mecaLaw;
+            _mecaLaw = NULL;
+        }
+    }
+    mlawGenericRM(const mlawGenericRM& source);
+    virtual mlawGenericRM& operator=(const materialLaw& source);
+    virtual void initLaws(const std::map<int,materialLaw*> &maplaw){}; // this law is initialized so nothing to do
+    virtual double soundSpeed() const{
+        if(_mecaLaw == NULL)
+            Msg::Error("soundSpeed: Mechanic law is null");
+        return _mecaLaw->soundSpeed();
+    };
+    virtual double density() const{
+        if(_mecaLaw == NULL)
+            Msg::Error("density: Mechanic law is null");
+        return _mecaLaw->density();
+    };
+
+    virtual double ElasticShearModulus() const{
+        if(_mecaLaw == NULL)
+            Msg::Error("ElasticShearModulus: Mechanic law is null");
+        return _mecaLaw->getConstNonLinearSolverMaterialLaw()->ElasticShearModulus();
+    }
+    virtual void checkInternalState(IPVariable* ipv, const IPVariable* ipvprev) const{}; // do nothing
+    virtual materialLaw* clone() const {return new mlawGenericRM(*this);}
+    virtual bool withEnergyDissipation() const {
+            if(_mecaLaw == NULL)
+            Msg::Error("ElasticShearModulus: Mechanic law is null");
+        return _mecaLaw->withEnergyDissipation();
+
+    }
+    virtual matname getType() const{return materialLaw::GenericResidualStrain;}
+    virtual void createIPState(IPStateBase* &ips,bool hasBodyForce, const bool* state_=NULL,const MElement *ele=NULL, const int nbFF_=0,
+                               const IntPt *GP=NULL, const int gpt =0) const;
+    virtual void createIPVariable(IPGenericTM* &ipv, bool hasBodyForce, const MElement *ele, const int nbFF,
+                                  const IntPt *GP, const int gpt) const;
+
+    virtual void constitutive(
+            const STensor3      &F0,                   // initial deformation gradient (input @ time n)
+            const STensor3      &Fn,                   // updated deformation gradient (input @ time n+1)
+            STensor3            &P,                    // updated 1st Piola-Kirchhoff stress tensor (output)
+            const IPVariable    *q0,                   // array of initial internal variable
+            IPVariable          *q1,                   // updated array of internal variable (in ipvcur on output),
+            STensor43           &Tangent,              // constitutive tangents (output)
+            const bool          stiff,
+            STensor43           *elasticTangent=NULL,
+            const bool dTangent =false,
+            STensor63* dCalgdeps = NULL
+    ) const;
+
+    virtual void setLawForFRes(const scalarFunction& funcRes);
+    //const STensor43& getElasticityTensor() const { return _ElasticityTensor;};
+    virtual const STensor3&  getConductivityTensor() const { return _k;};
+    virtual const STensor3& getAlphaDilatation() const { return _alphaDilatation;};
+    //virtual void getStiff_alphaDilatation(STensor3 &stiff_alphaDilatation) const;
+    virtual void ElasticStiffness(STensor43 *elasticStiffness) const;
+
+#endif //SWIG
+};
+
+#endif //MLAWGENERICRM_H_

dG3D/src/dG3DIPVariable.h

@@ -66,6 +66,8 @@
 #include "mlawLocalDamageIsotropicElasticity.h"
 #include "ipGenericTM.h"
 #include "mlawGenericTM.h"
+#include "ipGenericRM.h"
+#include "mlawGenericRM.h"
 #include "ipElecMagGenericThermoMech.h"
 #include "mlawElecMagGenericThermoMech.h"
 #include "ipElecMagInductor.h"
@@ -5508,6 +5510,9 @@ public:
     STensor3 & getRefToReferenceF();
 };
 
+//copy class GenericResidualMechanicsDG3DIPVariable : public dG3DIPVariableBase idem in Material
+
+
 class ElecMagGenericThermoMechanicsDG3DIPVariable : public ElecMagTherMechDG3DIPVariableBase
 {
 protected: