Skip to content
Snippets Groups Projects
Select Git revision
  • 49041a7f5059255b87ecc09d49873bd034e3c32a
  • master default protected
  • cyrielle
  • dev_mm_pf
  • ujwal_05_08_2025
  • complexpetsc
  • ujwal_21_08_2024
  • vinayak
  • dev_mm_torchSCRU
  • debug_mm_pf
  • newStructureNonLocal
  • Mohamed_stochasticDMN
  • dev_mm_bench
  • stochdmn
  • revert-351ff7aa
  • ujwal_29April2024
  • dev_mm_ann
  • mohamed_vevp
  • ujwal_debug
  • ujwal_2ndApril2024
  • ujwal_October_2023
  • v4.0
  • v3.2.3_multiplePhase
  • v3.5
  • v3.3.2
  • v3.4
  • v3.3
  • ver3.2
  • verJulienWork
  • ver3.1
  • ver2
  • ver1.1.2
  • ver1.1.1
  • ver1.1
34 results

nonLocalDamageDG3DIPVariable.cpp

Blame
    • nonLocalDamageDG3DIPVariable.cpp 22.90 KiB 
    //
// C++ Interface: ipvariable
//
// Description: Class with definition of ipvarible for dG3D
//
//
// Author:  <L. Noels>, (C) 2011
//
// Copyright: See COPYING file that comes with this distribution
//
//

#include "nonLocalDamageDG3DIPVariable.h"
#include "ipstate.h"
#include "ipField.h"
#include <iostream>
#include <fstream>
#include <iomanip>
#include <string.h>
#include "restartManager.h"
#include "highOrderTensor.h"


virtualNonLocalDamageDG3DIPVariable::virtualNonLocalDamageDG3DIPVariable(const int num, const dG3DIPVariableBase* base, const std::vector<STensor3>& length, int numExtra):
      _nonlocalData(num,numExtra), _constitutiveExtraDofDiffusionData(NULL), dG3DIPVariableBase(),characteristicLength(length){
  _ipvBase = dynamic_cast<dG3DIPVariableBase*>(base->clone());
  if (_ipvBase == NULL){
    Msg::Fatal("dG3DIPVariableBase must be used");
  }
  if (num > 0){
    localVar.resize(num,0.);
    nonLocalVar.resize(num,0.);
    DirrEnergDNonlocalVar.resize(num,0.);
  }
  if(numExtra>0.)
  {
    _constitutiveExtraDofDiffusionData = new constitutiveExtraDofDiffusionData(numExtra,num);
    constitutiveExtraDofVar.resize(numExtra,0);
    DirrEnergDConstitutiveExtraDofDiffusion.resize(numExtra,0.);
  }
};

virtualNonLocalDamageDG3DIPVariable::virtualNonLocalDamageDG3DIPVariable(const virtualNonLocalDamageDG3DIPVariable& src):
  dG3DIPVariableBase(src), _nonlocalData(src._nonlocalData), localVar(src.localVar),nonLocalVar(src.nonLocalVar),
  characteristicLength(src.characteristicLength),DirrEnergDNonlocalVar(src.DirrEnergDNonlocalVar), 
  constitutiveExtraDofVar(src.constitutiveExtraDofVar), 
  DirrEnergDConstitutiveExtraDofDiffusion(src.DirrEnergDConstitutiveExtraDofDiffusion) 
{
  _ipvBase = NULL;
  if (src._ipvBase != NULL){
    _ipvBase = dynamic_cast<dG3DIPVariableBase*>(src._ipvBase->clone());
  }
  if(src._constitutiveExtraDofDiffusionData!=NULL)
  {
    _constitutiveExtraDofDiffusionData = new constitutiveExtraDofDiffusionData(*(src._constitutiveExtraDofDiffusionData));
  }
};
virtualNonLocalDamageDG3DIPVariable& virtualNonLocalDamageDG3DIPVariable::operator =(const IPVariable& src){
  dG3DIPVariableBase::operator =(src);
  const virtualNonLocalDamageDG3DIPVariable* psrc = dynamic_cast<const virtualNonLocalDamageDG3DIPVariable*>(&src);
  if (psrc != NULL){
    _nonlocalData = psrc->_nonlocalData;
    localVar = psrc->localVar;
    nonLocalVar = psrc->nonLocalVar;
    DirrEnergDNonlocalVar = psrc->DirrEnergDNonlocalVar;
    if(psrc->_constitutiveExtraDofDiffusionData!=NULL)
    {
      if(_constitutiveExtraDofDiffusionData==NULL)
        _constitutiveExtraDofDiffusionData = new constitutiveExtraDofDiffusionData(*(psrc->_constitutiveExtraDofDiffusionData));
      else
            _constitutiveExtraDofDiffusionData->operator=(*(psrc->_constitutiveExtraDofDiffusionData)); 
    }
    constitutiveExtraDofVar = psrc->constitutiveExtraDofVar;
    DirrEnergDConstitutiveExtraDofDiffusion = psrc->DirrEnergDConstitutiveExtraDofDiffusion;
    if (psrc->_ipvBase != NULL){
      if (_ipvBase != NULL){
        _ipvBase->operator=(*dynamic_cast<const IPVariable*>(psrc->_ipvBase));
      }
      else{
        _ipvBase = dynamic_cast<dG3DIPVariableBase*>(psrc->_ipvBase->clone());
      }
    }
  }
  return *this;
};

virtualNonLocalDamageDG3DIPVariable::~virtualNonLocalDamageDG3DIPVariable(){
  if(_constitutiveExtraDofDiffusionData!=NULL) delete _constitutiveExtraDofDiffusionData;
  if (_ipvBase != NULL) delete _ipvBase; _ipvBase = NULL;
};

double virtualNonLocalDamageDG3DIPVariable::get(const int comp) const{
  if (comp == IPField::LOCAL_0){
    if (getNumberNonLocalVariable()>0){
      return getConstRefToLocalVariable(0);
    }
    else return 0.;
  }
  else if (comp == IPField::LOCAL_1){
    if (getNumberNonLocalVariable()>1){
      return getConstRefToLocalVariable(1);
    }
    else return 0.;
  }
  else if (comp == IPField::LOCAL_2){
    if (getNumberNonLocalVariable() > 2){
      return getConstRefToLocalVariable(2);
    }
    else return 0.;
  }
  else if (comp == IPField::NONLOCAL_0){
    if (getNumberNonLocalVariable() > 0){
      return getConstRefToNonLocalVariable(0);
    }
    else return 0.;
  }
  else if (comp == IPField::NONLOCAL_1){
    if (getNumberNonLocalVariable()> 1){
      return getConstRefToNonLocalVariable(1);
    }
    else return 0.;
  }
  else if (comp == IPField::NONLOCAL_2){
    if (getNumberNonLocalVariable() > 2)
      return getConstRefToNonLocalVariable(2);
    else return 0.;
  }
  else if (comp == IPField::CONSTITUTIVEEXTRADOFDIFFUSION_0){
    if (getNumConstitutiveExtraDofDiffusionVariable() > 0)
      return getConstRefToField(0);
  }
  else if (comp == IPField::CONSTITUTIVEEXTRADOFDIFFUSION_1){
    if (getNumConstitutiveExtraDofDiffusionVariable() > 1)
      return getConstRefToField(1);
  }
  else if (comp == IPField::CONSTITUTIVEEXTRADOFDIFFUSION_2){
    if (getNumConstitutiveExtraDofDiffusionVariable() > 2)
      return getConstRefToField(2);
  }
  else{
        return _ipvBase->get(comp);
  }
}

void virtualNonLocalDamageDG3DIPVariable::restart(){
  _ipvBase->restart();
  _nonlocalData.restart();
  if(_constitutiveExtraDofDiffusionData!=NULL)
    _constitutiveExtraDofDiffusionData->restart();
};

//
nonLocalDamageDG3DIPVariable::nonLocalDamageDG3DIPVariable(int _nsdv, const bool oninter) : dG3DIPVariable(oninter,1)
{
  _nldipv = new IPNonLocalDamage(_nsdv);
}

nonLocalDamageDG3DIPVariable::nonLocalDamageDG3DIPVariable(const nonLocalDamageDG3DIPVariable &source) :
                                                                   dG3DIPVariable(source)
{
  _nldipv = NULL;
  if (source.getIPNonLocalDamage() != NULL){
    _nldipv = new IPNonLocalDamage((int)source.getIPNonLocalDamage()->getNsdv());
    _nldipv->operator= (*dynamic_cast<const IPVariable*>(source.getIPNonLocalDamage()));
  }

}

nonLocalDamageDG3DIPVariable& nonLocalDamageDG3DIPVariable::operator=(const IPVariable &source)
{
  dG3DIPVariable::operator=(source);
  const nonLocalDamageDG3DIPVariable* src = dynamic_cast<const nonLocalDamageDG3DIPVariable*>(&source);
  if(src != NULL)
  {
    if (src->getIPNonLocalDamage() != NULL){
      if (_nldipv != NULL){
        _nldipv->operator=(*dynamic_cast<const IPVariable*>(src->getIPNonLocalDamage()));
      }
      else{
        _nldipv = dynamic_cast<IPNonLocalDamage*>(src->getIPNonLocalDamage()->clone());
      }
    }
    else{
      if (_nldipv != NULL){
        delete _nldipv;
        _nldipv = NULL;
      }
    }
  }
  return *this;
}
double nonLocalDamageDG3DIPVariable::get(const int i) const
{
  return getIPNonLocalDamage()->get(i);
}
double nonLocalDamageDG3DIPVariable::defoEnergy() const
{
  return getIPNonLocalDamage()->defoEnergy();
}
double nonLocalDamageDG3DIPVariable::plasticEnergy() const
{
  return getIPNonLocalDamage()->plasticEnergy();
}

double nonLocalDamageDG3DIPVariable::getConstRefToLocalVariable(const int idex) const {
  if (idex == 0)
    return getIPNonLocalDamage()->_nldCurrentPlasticStrain;
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
    };
double& nonLocalDamageDG3DIPVariable::getRefToLocalVariable(const int idex) {
  if (idex == 0)
    return getIPNonLocalDamage()->_nldCurrentPlasticStrain;
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

double nonLocalDamageDG3DIPVariable::getConstRefToNonLocalVariable(const int idex) const{
  if (idex == 0)
    return getIPNonLocalDamage()->_nldEffectivePlasticStrain;
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalDamageDG3DIPVariable::getRefToNonLocalVariable(const int idex) {
  if (idex == 0)
    return getIPNonLocalDamage()->_nldEffectivePlasticStrain;
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

void nonLocalDamageDG3DIPVariable::restart()
{
  dG3DIPVariable::restart();
  if (_nldipv != NULL)
    restartManager::restart(_nldipv);
  return;
}



nonLocalDamageIsotropicElasticityDG3DIPVariable::nonLocalDamageIsotropicElasticityDG3DIPVariable(const mlawNonlocalDamageHyperelastic &isoElastLaw,
    const bool oninter) : dG3DIPVariable(oninter,1)
{
    _nldIsotropicElasticityipv = new IPNonLocalDamageIsotropicElasticity(isoElastLaw.getCLengthLaw(),isoElastLaw.getDamageLaw());
}

nonLocalDamageIsotropicElasticityDG3DIPVariable::nonLocalDamageIsotropicElasticityDG3DIPVariable(const mlawNonLocalDamageIsotropicElasticity &isoElastLaw,
    const bool oninter) : dG3DIPVariable(oninter,1)
{
    _nldIsotropicElasticityipv = new IPNonLocalDamageIsotropicElasticity(isoElastLaw.getCLengthLaw(),isoElastLaw.getDamageLaw());
}

nonLocalDamageIsotropicElasticityDG3DIPVariable::nonLocalDamageIsotropicElasticityDG3DIPVariable(const nonLocalDamageIsotropicElasticityDG3DIPVariable &source)
    : dG3DIPVariable(source)
{
  _nldIsotropicElasticityipv = NULL;
  if (source.getIPNonLocalDamageIsotropicElasticity() != NULL){
     _nldIsotropicElasticityipv = dynamic_cast<IPNonLocalDamageIsotropicElasticity*>(source.getIPNonLocalDamageIsotropicElasticity()->clone());
  }

}

nonLocalDamageIsotropicElasticityDG3DIPVariable& nonLocalDamageIsotropicElasticityDG3DIPVariable::operator=(const IPVariable &source)
{
  dG3DIPVariable::operator=(source);
  const nonLocalDamageIsotropicElasticityDG3DIPVariable* src = dynamic_cast<const nonLocalDamageIsotropicElasticityDG3DIPVariable*>(&source);
  if(src != NULL)
  {
    if (src->getIPNonLocalDamageIsotropicElasticity() != NULL){
      if (_nldIsotropicElasticityipv!=NULL){
        _nldIsotropicElasticityipv->operator=(*dynamic_cast<const IPVariable*>(src->getIPNonLocalDamageIsotropicElasticity()));
      }
      else
        _nldIsotropicElasticityipv = dynamic_cast<IPNonLocalDamageIsotropicElasticity*>(src->getIPNonLocalDamageIsotropicElasticity()->clone());
    }
    else{
          if (_nldIsotropicElasticityipv!=NULL){
        delete _nldIsotropicElasticityipv;
        _nldIsotropicElasticityipv=NULL;
      }
    }
  }
  return *this;
}

double nonLocalDamageIsotropicElasticityDG3DIPVariable::get(const int i) const
{
    if(i == IPField::DAMAGE)
    {
        return getIPNonLocalDamageIsotropicElasticity()->getDamage();
    }
    else if(i == IPField::LOCAL_EQUIVALENT_STRAINS)
    {
        return getIPNonLocalDamageIsotropicElasticity()->getLocalEffectiveStrains();
    }
    else if(i == IPField::NONLOCAL_EQUIVALENT_STRAINS)
    {
        return getIPNonLocalDamageIsotropicElasticity()->getNonLocalEffectiveStrains();
    }
		else if (i == IPField::ACTIVE_DAMAGING_ZONE){
			if (getIPNonLocalDamageIsotropicElasticity()->dissipationIsActive()) return 1.;
			else return 0.;
		}
    else
    {
        return dG3DIPVariable::get(i);
    }
}

double nonLocalDamageIsotropicElasticityDG3DIPVariable::defoEnergy() const
{
    return getIPNonLocalDamageIsotropicElasticity()->defoEnergy();
}
double nonLocalDamageIsotropicElasticityDG3DIPVariable::plasticEnergy() const
{
    return getIPNonLocalDamageIsotropicElasticity()->plasticEnergy();
}


double nonLocalDamageIsotropicElasticityDG3DIPVariable::getConstRefToLocalVariable(const int idex) const
{
    if (idex == 0)
        return getIPNonLocalDamageIsotropicElasticity()->getLocalEffectiveStrains();
    else
        {
            Msg::Fatal("the non-local variable %d is not defined",idex);
        }
};
double& nonLocalDamageIsotropicElasticityDG3DIPVariable::getRefToLocalVariable(const int idex)
{
    if (idex == 0)
        return getIPNonLocalDamageIsotropicElasticity()->getRefToLocalEffectiveStrains();
    else
        {
            Msg::Fatal("the non-local variable %d is not defined",idex);
        }
};

double nonLocalDamageIsotropicElasticityDG3DIPVariable::getConstRefToNonLocalVariable(const int idex) const
{
    if (idex == 0)
        return getIPNonLocalDamageIsotropicElasticity()->getNonLocalEffectiveStrains();
    else
        {
            Msg::Fatal("the non-local variable %d is not defined",idex);
        }
    };

double& nonLocalDamageIsotropicElasticityDG3DIPVariable::getRefToNonLocalVariable(const int idex)
{
    if (idex == 0)
        return getIPNonLocalDamageIsotropicElasticity()->getRefToNonLocalEffectiveStrains();
    else
        {
            Msg::Fatal("the non-local variable %d is not defined",idex);
        }
};

void nonLocalDamageIsotropicElasticityDG3DIPVariable::restart()
{
    dG3DIPVariable::restart();
    if (_nldIsotropicElasticityipv != NULL)
      restartManager::restart(_nldIsotropicElasticityipv);
    return;
}






nonLocalDamageJ2HyperDG3DIPVariable::nonLocalDamageJ2HyperDG3DIPVariable(const mlawNonLocalDamageJ2Hyper &_j2law, const bool oninter) :
                                   dG3DIPVariable(oninter,1)
{
  _nldJ2Hyperipv = new IPNonLocalDamageJ2Hyper(_j2law.getJ2IsotropicHardening(),_j2law.getCLengthLaw(),_j2law.getDamageLaw());
}

nonLocalDamageJ2HyperDG3DIPVariable::nonLocalDamageJ2HyperDG3DIPVariable(const nonLocalDamageJ2HyperDG3DIPVariable &source) : dG3DIPVariable(source)
{
  _nldJ2Hyperipv = NULL;
  if (source.getIPNonLocalDamageJ2Hyper() != NULL){
    _nldJ2Hyperipv = dynamic_cast<IPNonLocalDamageJ2Hyper*>(source.getIPNonLocalDamageJ2Hyper()->clone());
  }
}

nonLocalDamageJ2HyperDG3DIPVariable& nonLocalDamageJ2HyperDG3DIPVariable::operator=(const IPVariable &source)
{
  dG3DIPVariable::operator=(source);
  const nonLocalDamageJ2HyperDG3DIPVariable* src = dynamic_cast<const nonLocalDamageJ2HyperDG3DIPVariable*>(&source);
  if(src != NULL)
  {
    if (src->getIPNonLocalDamageJ2Hyper() != NULL){
      if (_nldJ2Hyperipv != NULL)
        _nldJ2Hyperipv->operator=(*dynamic_cast<const IPVariable*>(src->getIPNonLocalDamageJ2Hyper()));
      else
        _nldJ2Hyperipv = dynamic_cast<IPNonLocalDamageJ2Hyper*>(src->getIPNonLocalDamageJ2Hyper()->clone());
    }
    else{
      if (_nldJ2Hyperipv != NULL) {
        delete _nldJ2Hyperipv;
        _nldJ2Hyperipv= NULL;
      }
    }

  }
  return *this;
}
double nonLocalDamageJ2HyperDG3DIPVariable::get(const int i) const
{
  if(i == IPField::PLASTICSTRAIN)
  {
    return getIPNonLocalDamageJ2Hyper()->getConstRefToEquivalentPlasticStrain();
  }
  else if(i == IPField::DAMAGE)
  {
    return getIPNonLocalDamageJ2Hyper()->getDamage();
      }
	else if (i == IPField::ACTIVE_DAMAGING_ZONE){
		if (getIPNonLocalDamageJ2Hyper()->dissipationIsActive()) return 1.;
		else return 0.;
	}
  else
  {
    return dG3DIPVariable::get(i);
  }
}
double nonLocalDamageJ2HyperDG3DIPVariable::defoEnergy() const
{
  return getIPNonLocalDamageJ2Hyper()->defoEnergy();
}
double nonLocalDamageJ2HyperDG3DIPVariable::plasticEnergy() const
{
  return getIPNonLocalDamageJ2Hyper()->plasticEnergy();
}


double nonLocalDamageJ2HyperDG3DIPVariable::getConstRefToLocalVariable(const int idex) const {
  if (idex == 0)
    return getIPNonLocalDamageJ2Hyper()->getConstRefToEquivalentPlasticStrain();
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalDamageJ2HyperDG3DIPVariable::getRefToLocalVariable(const int idex){
  if (idex == 0)
    return getIPNonLocalDamageJ2Hyper()->getRefToEquivalentPlasticStrain();
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

double nonLocalDamageJ2HyperDG3DIPVariable::getConstRefToNonLocalVariable(const int idex) const{
  if (idex == 0)
    return getIPNonLocalDamageJ2Hyper()->getEffectivePlasticStrain();
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalDamageJ2HyperDG3DIPVariable::getRefToNonLocalVariable(const int idex){
  if (idex == 0)
    return getIPNonLocalDamageJ2Hyper()->getRefToEffectivePlasticStrain();
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

void nonLocalDamageJ2HyperDG3DIPVariable::restart()
{
  dG3DIPVariable::restart();
  if (_nldJ2Hyperipv != NULL)
    restartManager::restart(_nldJ2Hyperipv);
  return;
}
//

nonLocalPorosityDG3DIPVariable::nonLocalPorosityDG3DIPVariable(const mlawNonLocalPorosity &law,const double fvInitial, const bool oninter, const int numLocalVar):
  dG3DIPVariable(oninter,numLocalVar)
{
  _nldPorousipv = new IPNonLocalPorosity(fvInitial, law.getJ2IsotropicHardening(), law.getCLengthLaw(),
                                             law.getGursonDamageNucleationContainer(), law.getCoalescenceLaw());
}

nonLocalPorosityDG3DIPVariable::nonLocalPorosityDG3DIPVariable(const mlawNonLocalPorosity &_law, const bool oninter, const int numLocalVar) :
                                   dG3DIPVariable(oninter,numLocalVar)
{
  _nldPorousipv = new IPNonLocalPorosity(_law.getInitialPorosity(), _law.getJ2IsotropicHardening(), _law.getCLengthLaw(),
                                                 _law.getGursonDamageNucleationContainer(), _law.getCoalescenceLaw());
}

nonLocalPorosityDG3DIPVariable::nonLocalPorosityDG3DIPVariable(const nonLocalPorosityDG3DIPVariable &source) : dG3DIPVariable(source)
{
  _nldPorousipv  = NULL;
  if (source.getIPNonLocalPorosity() != NULL){
    _nldPorousipv = dynamic_cast<IPNonLocalPorosity*>(source.getIPNonLocalPorosity()->clone());
  }

}

nonLocalPorosityDG3DIPVariable& nonLocalPorosityDG3DIPVariable::operator=(const IPVariable &source)
{
  dG3DIPVariable::operator=(source);
  const nonLocalPorosityDG3DIPVariable* src = dynamic_cast<const nonLocalPorosityDG3DIPVariable*>(&source);
  if(src != NULL)
  {
    if (src->getIPNonLocalPorosity() != NULL){
      if (_nldPorousipv != NULL)
        _nldPorousipv->operator=(*dynamic_cast<const IPVariable*>(src->getIPNonLocalPorosity()));
      else
        _nldPorousipv = dynamic_cast<IPNonLocalPorosity*>(src->getIPNonLocalPorosity()->clone());
    }
    else{
      if (_nldPorousipv!=NULL){
        delete _nldPorousipv;
        _nldPorousipv = NULL;
      }
    }
  }
  return *this;
}
double nonLocalPorosityDG3DIPVariable::get(const int i) const
{
  if(i == IPField::PLASTICSTRAIN)
  {
    return getIPNonLocalPorosity()->getMatrixPlasticStrain();
  }
  else if (i == IPField::VOLUMETRIC_PLASTIC_STRAIN){
    return getIPNonLocalPorosity()->getMatrixVolumetricPlasticStrain();
  }
  else if (i == IPField::NONLOCAL_POROSITY){
    return getIPNonLocalPorosity()->getNonLocalPorosity();
  }
  else if(i == IPField::DAMAGE)
  {
    return getIPNonLocalPorosity()->getNonLocalPorosity();
  }
  else if(i == IPField::LOCAL_POROSITY)
  {
    return getIPNonLocalPorosity()->getLocalPorosity();
  }
  else if (i == IPField::CORRECTED_POROSITY)
  {
    return getIPNonLocalPorosity()->getCorrectedPorosity();
  }
  else if (i == IPField::YIELD_POROSITY){
    return getIPNonLocalPorosity()->getYieldPorosity();
  }
  else if (i == IPField::LIGAMENT_RATIO)
  {
    return getIPNonLocalPorosity()->getLigamentRatio();
  }
  else if ( i == IPField::COALESCENCE){
    if (getIPNonLocalPorosity()->getConstRefToIPCoalescence().getCoalescenceActiveFlag()){
      return 1.;
    }
    else return 0.;
  }
      else if (i == IPField::POROSITY_AT_COALESCENCE){
    return getIPNonLocalPorosity()->getConstRefToIPCoalescence().getCoalescenceOnset();
  }
	else if (i == IPField::FAILED){
		if (getIPNonLocalPorosity()->isFailed()) return 1.;
		else return 0.;
	}
  else if (i == IPField::K_XX){
    return getIPNonLocalPorosity()->getConstRefToCorotationalKirchhoffStress()(0,0);
  }
  else if (i == IPField::K_YY){
    return getIPNonLocalPorosity()->getConstRefToCorotationalKirchhoffStress()(1,1);
  }
  else if (i == IPField::K_ZZ){
    return getIPNonLocalPorosity()->getConstRefToCorotationalKirchhoffStress()(2,2);
  }
  else if (i == IPField::K_XY){
    return getIPNonLocalPorosity()->getConstRefToCorotationalKirchhoffStress()(0,1);
  }
  else if (i == IPField::K_YZ){
    return getIPNonLocalPorosity()->getConstRefToCorotationalKirchhoffStress()(1,2);
  }
  else if (i == IPField::K_XZ){
    return getIPNonLocalPorosity()->getConstRefToCorotationalKirchhoffStress()(0,2);
  }
  else
  {
    return dG3DIPVariable::get(i);
  }
}
double nonLocalPorosityDG3DIPVariable::defoEnergy() const
{
  return getIPNonLocalPorosity()->defoEnergy();
}
double nonLocalPorosityDG3DIPVariable::plasticEnergy() const
{
  return getIPNonLocalPorosity()->plasticEnergy();
}

double nonLocalPorosityDG3DIPVariable::getConstRefToLocalVariable(const int idex) const{
  if (idex == 0){
    return getIPNonLocalPorosity()->getLocalPorosity();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalPorosityDG3DIPVariable::getRefToLocalVariable(const int idex){
  if (idex == 0){
    return getIPNonLocalPorosity()->getRefToLocalPorosity();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

double nonLocalPorosityDG3DIPVariable::getConstRefToNonLocalVariable(const int idex) const{
  if (idex == 0){
    return getIPNonLocalPorosity()->getNonLocalPorosity();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalPorosityDG3DIPVariable::getRefToNonLocalVariable(const int idex){
  if (idex == 0){
    return getIPNonLocalPorosity()->getRefToNonLocalPorosity();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
      }
};


void nonLocalPorosityDG3DIPVariable::restart()
{
  dG3DIPVariable::restart();
  if (_nldPorousipv != NULL)
    restartManager::restart(_nldPorousipv);
  return;
};

double nonLocalPorousEqPlasticDG3DIPVariable::getConstRefToLocalVariable(const int idex) const{
  if (idex == 0){
    return getIPNonLocalPorosity()->getMatrixPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalPorousEqPlasticDG3DIPVariable::getRefToLocalVariable(const int idex){
  if (idex == 0){
    return getIPNonLocalPorosity()->getRefToMatrixPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

double nonLocalPorousEqPlasticDG3DIPVariable::getConstRefToNonLocalVariable(const int idex) const{
  if (idex == 0){
    return getIPNonLocalPorosity()->getNonLocalMatrixPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalPorousEqPlasticDG3DIPVariable::getRefToNonLocalVariable(const int idex){
  if (idex == 0){
    return getIPNonLocalPorosity()->getRefToNonLocaMatrixPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

double nonLocalPorousVolumetricPlasticDG3DIPVariable::getConstRefToLocalVariable(const int idex) const{
  if (idex == 0){
    return getIPNonLocalPorosity()->getMatrixVolumetricPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};
double& nonLocalPorousVolumetricPlasticDG3DIPVariable::getRefToLocalVariable(const int idex){
  if (idex == 0){
    return getIPNonLocalPorosity()->getRefToMatrixVolumetricPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};

double nonLocalPorousVolumetricPlasticDG3DIPVariable::getConstRefToNonLocalVariable(const int idex) const{
  if (idex == 0){
    return getIPNonLocalPorosity()->getNonlocalMatrixVolumetricPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
    };
double& nonLocalPorousVolumetricPlasticDG3DIPVariable::getRefToNonLocalVariable(const int idex){
  if (idex == 0){
    return getIPNonLocalPorosity()->getRefToNonLocalMatrixVolumetricPlasticStrain();
  }
  else{
    Msg::Fatal("the non-local variable %d is not defined",idex);
  }
};