diff --git a/NonLinearSolver/internalPoints/CMakeLists.txt b/NonLinearSolver/internalPoints/CMakeLists.txt index a399f88b53a6b1e332014d4002b1a591ca76dfc1..446b7faa7b792a87ef3ad770e3a5757c53a9fce6 100644 --- a/NonLinearSolver/internalPoints/CMakeLists.txt +++ b/NonLinearSolver/internalPoints/CMakeLists.txt @@ -60,6 +60,7 @@ set(SRC ipVoidState.cpp ipLinearElecMagInductor.cpp ipGenericTM.cpp + ipGenericRM.cpp ipElecMagGenericThermoMech.cpp ipElecMagInductor.cpp ipNonLinearTVM.cpp diff --git a/NonLinearSolver/internalPoints/ipGenericRM.cpp b/NonLinearSolver/internalPoints/ipGenericRM.cpp new file mode 100644 index 0000000000000000000000000000000000000000..947d7d47477f1dd32824e5fcb794e3b1d3ff2158 --- /dev/null +++ b/NonLinearSolver/internalPoints/ipGenericRM.cpp @@ -0,0 +1,91 @@ +// +// 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); +} diff --git a/NonLinearSolver/internalPoints/ipGenericRM.h b/NonLinearSolver/internalPoints/ipGenericRM.h new file mode 100644 index 0000000000000000000000000000000000000000..69411a4290358816f4c10ed0b76e24108153ceba --- /dev/null +++ b/NonLinearSolver/internalPoints/ipGenericRM.h @@ -0,0 +1,65 @@ +// +// 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_ diff --git a/NonLinearSolver/materialLaw/CMakeLists.txt b/NonLinearSolver/materialLaw/CMakeLists.txt index bed4818d58f43a62c966e84079fdc99d77bc8d92..77dac38ffd8a018d8ebca0c5abc27afff6325ec3 100644 --- a/NonLinearSolver/materialLaw/CMakeLists.txt +++ b/NonLinearSolver/materialLaw/CMakeLists.txt @@ -101,6 +101,7 @@ set(SRC mlawNonLocalPorousWithFailure.cpp mlawLinearElecMagInductor.cpp mlawGenericTM.cpp + mlawGenericRM.cpp mlawElecMagGenericThermoMech.cpp mlawElecMagInductor.cpp mlawNonLinearTVM.cpp diff --git a/NonLinearSolver/materialLaw/mlaw.h b/NonLinearSolver/materialLaw/mlaw.h index 4f2ed086c46255a0c2e818fbdd6f2e7383561547..218d8146015db8556ff42162a89a4e3d230dc177 100644 --- a/NonLinearSolver/materialLaw/mlaw.h +++ b/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 : diff --git a/NonLinearSolver/materialLaw/mlawGenericRM.cpp b/NonLinearSolver/materialLaw/mlawGenericRM.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4a29b7ada504166bfc56443581d84bba8d9e761d --- /dev/null +++ b/NonLinearSolver/materialLaw/mlawGenericRM.cpp @@ -0,0 +1,331 @@ +// 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); +} diff --git a/NonLinearSolver/materialLaw/mlawGenericRM.h b/NonLinearSolver/materialLaw/mlawGenericRM.h new file mode 100644 index 0000000000000000000000000000000000000000..ee2d62453e9ebb36c197d075a72cbea29c954076 --- /dev/null +++ b/NonLinearSolver/materialLaw/mlawGenericRM.h @@ -0,0 +1,131 @@ +// 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_ diff --git a/dG3D/src/dG3DIPVariable.h b/dG3D/src/dG3DIPVariable.h index 684b5cdb5304fb9b4f62c8c27455da3bb36db130..30fb66223ba9390ad3a790026096109785b6e801 100644 --- a/dG3D/src/dG3DIPVariable.h +++ b/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: diff --git a/dG3D/src/dG3DMaterialLaw.cpp b/dG3D/src/dG3DMaterialLaw.cpp index 81dc1be39b05d4f9c47d3de0ecd43f86889b304f..6d68bf4b232a6556262971662396ed96dc4bc1a7 100644 --- a/dG3D/src/dG3DMaterialLaw.cpp +++ b/dG3D/src/dG3DMaterialLaw.cpp @@ -252,7 +252,7 @@ void dG3DMaterialLawWithTangentByPerturbation::stress(IPVariable* ipv, const IPV ipvcur->getConstRefToDeformationGradient().print("F Analytique"); // FLE ipvcur->getConstRefToFirstPiolaKirchhoffStress().print("P Analytique"); // FLE ipvcur->getConstRefToTangentModuli().print("dPdE Analytique"); - /* for (int k=0; k< numNonLocalVars; k++) + for (int k=0; k< numNonLocalVars; k++) { ipvcur->getConstRefToDLocalVariableDStrain()[k].print("dpdE Analyique"); } @@ -336,7 +336,7 @@ void dG3DMaterialLawWithTangentByPerturbation::stress(IPVariable* ipv, const IPV { Msg::Info("dp dExtraDofDiffusionField Analytique: %e",ipvcur->getRefTodLocalVariableDExtraDofDiffusionField()(k,i)); } - }*/ + } for (unsigned int i = 0; i < numCurlDof; ++i) { ipvcur->getConstRefTodPdVectorPotential()[i].print("dPdMagneticVectorPotential Analytique"); @@ -636,7 +636,7 @@ void dG3DMaterialLawWithTangentByPerturbation::stress(IPVariable* ipv, const IPV ipvcur->getConstRefToDIrreversibleEnergyDDeformationGradient().print("dEnedE Numerique"); } } - /*for (int i=0; i< numNonLocalVars; i++) + for (int i=0; i< numNonLocalVars; i++) { for (int j=0; j< numNonLocalVars; j++) { @@ -707,7 +707,7 @@ void dG3DMaterialLawWithTangentByPerturbation::stress(IPVariable* ipv, const IPV { Msg::Info("dp dExtraDofDiffusionField Numerique: %e",ipvcur->getRefTodLocalVariableDExtraDofDiffusionField()(k,i)); } - }*/ + } for (unsigned int i = 0; i < numCurlDof; ++i) { const unsigned int extradof_T = 0; // Thermal field EM source