mechmat.cpp

Finite element program for mechanical problem. It can solve various problem in solid problem

    break;
  }
  case chenplast:{
    chplast[ip[ipp].idm[idpm]].deryieldfdsigmadq (sig,q,dfdsdqt);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dfdsigmadq (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
  
  //  conversion from tensorial notation to matrix notation
  gentensor_matrix (dfdsdq,dfdsdqt,ip[ipp].ssst);

}

/**
   function evaluates derivates of plastic potential with respect to stresses and
   internal variables (hardening parameters)

   stresses must be assembled in tensor notation and stored in 3x3 %matrix
   function stores derivatives in %matrix dgdsdq
   
   @param ipp - integration point pointer
   @param idpm - id of plasticity model
   @param sig - stress components
   @param q - internal variables (hardening parameters)
   @param dgdsdq - derivatives of plastic potential with respect to stresses and internal variables
   
   28.10.2001
*/
void mechmat::dgdsigmadq (long ipp, long idpm,matrix &sig,vector &q,matrix &dgdsdq)
{
  //  number of hardening parameters
  long nh=dgdsdq.n;
  
  matrix dgdsdqt(6,nh);

  switch (ip[ipp].tm[idpm]){
  case simplas1d:{
    spl1d[ip[ipp].idm[idpm]].dfdsigmadq (dgdsdqt);
    break;
  }
  case jflow2:{
    j2f2[ip[ipp].idm[idpm]].deryieldfdsigmadq (dgdsdqt);
    break;
  }
  case modcamclaymat:{
    cclay[ip[ipp].idm[idpm]].deryieldfdsdq (dgdsdqt);
    break;
  }
  case chenplast:{
    chplast[ip[ipp].idm[idpm]].deryieldfdsigmadq (sig,q,dgdsdqt);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dgdsigmadq (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
  
  //  conversion from tensorial notation to matrix notation
  gentensor_matrix (dgdsdq,dgdsdqt,ip[ipp].ssst);

}





/**
   function computes derivatives of hardening function with respect to stresses
   
   @param ipp - id of integration point
   @param idpm - id of plasticity model
   @param sigt - stress components stored in 3x3 %matrix
   @param q - internal variables stored in %vector
   @param dhds - derivatives of hardening function with respect to stresses stored in 6 x ncomphard %matrix
   
   JK, 7.8.2005
*/
void mechmat::dhdsigma (long ipp,long idpm,matrix &sigt,vector &q,matrix &dhds)
{
  //  number of hardening parameters
  long nh=dhds.m;
  
  matrix dhdst(6,nh);

  switch (ip[ipp].tm[idpm]){
  case simplas1d:{
    //spl1d[ip[ipp].idm[idpm]].dfdsigmadq (dgdsdqt);
    break;
  }
  case chenplast:{
    chplast[ip[ipp].idm[idpm]].dhdsigma (sigt,q,dhdst);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dhdsigma (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }

  //  conversion from tensorial notation to matrix notation
  gentensor_matrix (dhds,dhdst,ip[ipp].ssst);
}

/**
   function computes derivatives of hardening function with respect to consistency parameter
   
   @param ipp - id of integration point
   @param idpm - id of plasticity model
   @param dhdc - derivatives of hardening function with respect to consistency parameter stored in ncomphard x 1 %vector
   
   JK, 7.8.2005
*/
void mechmat::dhdgamma (long ipp,long idpm,vector &epsp,matrix &sig,vector &q,vector &dhdc)
{
  switch (ip[ipp].tm[idpm]){
  case simplas1d:{
    spl1d[ip[ipp].idm[idpm]].dhdgamma (ipp,epsp,sig,dhdc);
    break;
  }
  case chenplast:{
    chplast[ip[ipp].idm[idpm]].dhdgamma (dhdc);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dhdgamma (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

/**
   function computes derivatives of hardening function with respect to hardening parameters
   
   @param ipp - id of integration point
   @param idpm - id of plasticity model
   @param sigt - stress components stored in 3x3 %matrix
   @param q - internal variables stored in %vector
   @param dhdq - derivatives of hardening function with respect to hardening parameters stored in ncomphard x ncomphard %matrix
   
   JK, 7.8.2005
*/
void mechmat::dhdqpar (long ipp,long idpm,matrix &sigt,vector &q,matrix &dhdq)
{
  switch (ip[ipp].tm[idpm]){
  case simplas1d:{
    //spl1d[ip[ipp].idm[idpm]].dfdsigmadq (dgdsdqt);
    break;
  }
  case chenplast:{
    chplast[ip[ipp].idm[idpm]].dhdqpar (sigt,q,dhdq);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dhdqpar (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}











/*
void mechmat::plasticmoduli (long ipp,long idpm,vector &epsp,matrix &sig,matrix &h)
{
  switch (ip[ipp].tm[idpm]){
  case jflow2:{
    j2f2[ip[ipp].idm[idpm]].plasmod (h);
    break;
  }
  case chenplast:{
    //chplast[ip[ipp].idm[idpm]].plasmod (h);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function");
    fprintf (stderr,"\n plasticmoduli (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }

}
*/

//  konec nedelnich uprav





/*
void mechmat::dfunctdqdq (long ipp, long idpm,matrix &sig,vector &q,matrix &dfdqdq)
{
  switch (ip[ipp].tm[idpm]){
  case jflow2:{
    j2f2[ip[ipp].idm[idpm]].deryieldfdqdq (dfdqdq);
    break;
  }
  case modcamclaymat:{
    cclay[ip[ipp].idm[idpm]].deryieldfdqdq (dfdqdq);
    break;
  }
  case chenplast:{
    //chplast[ip[ipp].idm[idpm]].deryieldfdqdq (dfdqdq);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dfdqdq (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}
*/

void mechmat::dhardfdq (long ipp, long idpm,long ido, double dgamma, vector &q,matrix &dqdq)
{
  switch (ip[ipp].tm[idpm]){
  case modcamclaymat:{
    cclay[ip[ipp].idm[idpm]].dhardfdq (ipp, ido, dgamma, q, dqdq);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dhardfdq (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

void mechmat::dqdsigma (long ipp, long idpm,matrix &sig,vector &q,matrix &dqds)
{
  switch (ip[ipp].tm[idpm]){
  case modcamclaymat:{
    cclay[ip[ipp].idm[idpm]].dqdsigma (sig, q, dqds);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function dqdsigma (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

/**

*/
/*
double mechmat::plasmodscalar(long ipp, long idpm, long ido, matrix &sig, vector &eps, vector &epsp, vector &qtr,double gamma)
{
  double ret = 0.0;
  switch (ip[ipp].tm[idpm]){
  case simplas1d:{
    //ret = spl1d[ip[ipp].idm[idpm]].plasmodscalar (qtr);
    ret = spl1d[ip[ipp].idm[idpm]].plasmodscalar (sig,epsp,qtr,gamma);
    break;
  }
  case jflow:{
    ret = j2f[ip[ipp].idm[idpm]].plasmodscalar (qtr);
    break;
  }
  case jflow2:{
    ret = j2f2[ip[ipp].idm[idpm]].plasmodscalar (qtr);
    break;
  }
  case mohrcoulparab:{
    break;
  }
  case boermaterial:{
    break;
  }
  case druckerprager:{
    ret = drprm[ip[ipp].idm[idpm]].plasmodscalar(qtr);
    break;
  }
  case chenplast:{
    ret = chplast[ip[ipp].idm[idpm]].plasmodscalar (ipp,sig,epsp,qtr);
    //ret = 0.0;
    break;
  }
  case modcamclaymat:{
    ret = cclay[ip[ipp].idm[idpm]].plasmodscalar(ipp, ido, sig, qtr);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function");
    fprintf (stderr,"\n plasmodscalar (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
  return ret;
}
*/

void mechmat::plasmodscalar(double &denom,long ipp, long idpm, long ido, matrix &sig, vector &eps, vector &epsp, vector &qtr,double gamma)
{
  double ret = 0.0;
  switch (ip[ipp].tm[idpm]){
  case simplas1d:{
    //ret = spl1d[ip[ipp].idm[idpm]].plasmodscalar (qtr);
    ret = spl1d[ip[ipp].idm[idpm]].plasmodscalar (sig,epsp,qtr,gamma);
    break;
  }
  case jflow:{
    ret = j2f[ip[ipp].idm[idpm]].plasmodscalar (qtr);
    break;
  }
  case jflow2:{
    ret = j2f2[ip[ipp].idm[idpm]].plasmodscalar (qtr);
    break;
  }
  case mohrcoulparab:{
    break;
  }
  case boermaterial:{
    break;
  }
  case druckerprager:{
    ret = drprm[ip[ipp].idm[idpm]].plasmodscalar(qtr);
    break;
  }
  case chenplast:{
    //ret = chplast[ip[ipp].idm[idpm]].plasmodscalar (ipp,sig,epsp,qtr);
    if (ret<1.0e-6)
      denom*=2.0;
    //else
    //if (epsp[0]<1.0e-6)
    //denom*=2.0;
    //else
    //denom+=ret;
    break;
  }
  case modcamclaymat:{
    ret = cclay[ip[ipp].idm[idpm]].plasmodscalar(ipp, ido, sig, qtr);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function");
    fprintf (stderr,"\n plasmodscalar (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
  //return ret;
}


void mechmat::updateq (long ipp, long idpm, long ido,double dgamma, vector &eps, vector &epsp, matrix &sig, vector &q)
{
  switch (ip[ipp].tm[idpm]){
  case simplas1d:{
    //spl1d[ip[ipp].idm[idpm]].updateq(dgamma, q);
    spl1d[ip[ipp].idm[idpm]].updateq (ipp,dgamma, epsp,q);
    break;
  }
  case jflow:{
    j2f[ip[ipp].idm[idpm]].updateq (dgamma, q);
    break;
  }
  case jflow2:{
    j2f2[ip[ipp].idm[idpm]].updateq (dgamma, q);
    break;
  }
  case mohrcoul:{
    break;
  }
  case mohrcoulparab:{
    break;
  }
  case boermaterial:{
    break;
  }
  case druckerprager:{
    drprm[ip[ipp].idm[idpm]].updateq(ipp, epsp, q);
    break;
  }
  case chenplast:{
    //chplast[ip[ipp].idm[idpm]].updateq (ipp,dgamma,epsp,sig,q);
    break;
  }
  case modcamclaymat:{
    cclay[ip[ipp].idm[idpm]].updateq(ipp, ido, eps, epsp, sig, q);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function");
    fprintf (stderr,"\n updateq (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

/**
   function computes hardening/softening function for required parameters
   
   @param ipp - integration point id
   @param idpm - id of plastic material
   @param sigt - stress components stored in 3x3 %matrix
   @param q - internal parameters
   @param h - values of hardening function stored in %vector
   
   JK, 3.2.2007
*/
void mechmat::hardsoftfunction (long ipp,long idpm,matrix &sigt,vector &q,vector &h)
{
  switch (ip[ipp].tm[idpm]){
  case chenplast:{
    chplast[ip[ipp].idm[idpm]].hvalues (sigt,q,h);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown plasticity model is required in function");
    fprintf (stderr,"\n hardsoftfunction (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }  
}

/**
  Function returns irreversible strains for given material im.
  
  @param ipp    - integration point number
  @param im     - index of given material
  @param ido    - index of the first internal variable for given material in the ipp eqother array
  @param epsirr - %vector of irreversible strains

  Returns :
   Function returns vector of irreversible strains via parameter epsirr.
*/
void mechmat::giveirrstrains(long ipp, long im, long ido, vector &epsirr)
{
  fillv(0.0, epsirr);
  switch (ip[ipp].tm[im])
  {
    case simplas1d:{
      spl1d[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case jflow:{
      j2f[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case jflow2:{
      j2f2[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case mohrcoul:{
      mcoul[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case mohrcoulparab:{
      mcpar[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case boermaterial:{
      boerm[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case druckerprager:{
      drprm[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case chenplast:{
      //chplast[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case modcamclaymat:{
      cclay[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case creepbaz:{
      crbaz[ip[ipp].idm[im]].giveirrstrains(ipp, ido, epsirr);
      break;
    }
    case creepb3:{
      crb3[ip[ipp].idm[im]].g