mohrnav.c

Go to the documentation of this file.

/*
%M This modules contains the MOHR COULOMB NONASSOCIATE VARIABLE material 
   sub-class methods and definitions
%a Joao Luiz Elias Campos.
%d September 2nd, 1998.
%r $Id: mohrnav.c,v 1.1 2004/06/22 05:29:59 joaoluiz Exp $
%w (C) COPYRIGHT 1995-1996, Eduardo Nobre Lages.
   (C) COPYRIGHT 1997-1999, Joao Luiz Elias Campos.
   All Rights Reserved
   Duplication of this program or any part thereof without the express
   written consent of the author is prohibited.

   Modificacao: 28/04/2005    Alexandre A. Del Savio
     Foram substituídas todas as alocações dinâmicas feitas com malloc 
     por calloc.

*/

/*
** ------------------------------------------------------------------------
** Global variables and symbols:
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "load.h"
#include "elm.h"
#include "material.h"
#include "node.h"
#include "rio.h"


/* Parent methods
 */
void MaterialTimeStep( sMaterial *, double * );
void MaterialDensity ( sMaterial *, double * );


/*
** ------------------------------------------------------------------------
** Local variables and symbols:
*/

/*
%T MOHR COULOMB NONASSOCIATE VARIABLE material data definition
*/
typedef struct _mohrnacdata
{
 double E;             /* Young modulos                    */
 double Nu;            /* Poisson coefficient              */
 double sC;            /* Start point for coesion          */
 double iC;            /* Initial coesion value            */
 double fC;            /* Final coesion value              */
 double sPhi;          /* Start point for friction angle   */
 double iPhi;          /* Initial friction angle           */
 double fPhi;          /* Final friction angle             */
 double sPsi;          /* Start point for dilatation angle */
 double iPsi;          /* Initial dilatation angle         */
 double fPsi;          /* Final dilatation angle           */
} sMohrNAVData;

#ifndef PI
#define PI 3.141592654
#endif

/*
** ------------------------------------------------------------------------
** Local functions:
*/
static double _UpdateParameter( double, double, double, double );

/*
%F
*/
static double _UpdateParameter( double effdef, double spar, double ipar, 
                                                            double fpar )
{
 double aux, npar;

/* especial case
 */
 if( effdef == 0.0 )
  return fpar;

/* Compute effective deformation ratio
 */
 aux = effdef / spar;
 if( aux <= 1.0 )
  npar = (fpar * aux) + (ipar * (1.0 - aux));
 else
  npar = fpar;

 return npar;
 
} /* End of _UpdateParameter */


/*
** ------------------------------------------------------------------------
** Subclass methods:
*/
static void MohrCoulombNAVNew         ( int, sMaterial ** );
static void MohrCoulombNAVFree        ( sMaterial * );
static void MohrCoulombNAVRead        ( sMaterial * );
static void MohrCoulombNAVEParameter  ( sMaterial *, double * );
static void MohrCoulombNAVNuParameter ( sMaterial *, double * );
static void MohrCoulombNAVCMatrix     ( sMaterial *, double [6][6] );
static void MohrCoulombNAVUpdateStress( sMaterial *, double, double *,
                                                     double *, double *,
                                                     double * );


/*
%F This method allocates memory for a MOHR COULOMB NONASSOCIATE VARIABLE 
   material and fills its data with the specific values.
%i Material label (number)
%o Material descriptor.
*/
static void MohrCoulombNAVNew( int label, sMaterial **mat )
{
 sMohrNAVData *data = 0L;

/* Get memory for the material descriptor
 */
 (*mat) = (sMaterial *)calloc(1, sizeof(sMaterial));

/* Get memory for the MOHR COULOMB NONASSOCIATE VARIABLE material data
 */
 data = (sMohrNAVData *)calloc(1, sizeof(sMohrNAVData));

/* Fill MOHR COULOMB NONASSOCIATE VARIABLE material data
 */
 data->E    = data->Nu   = 0.0;
 data->sC   = data->iC   = data->fC   = 0.0;
 data->sPhi = data->iPhi = data->fPhi = 0.0;
 data->sPsi = data->iPsi = data->fPsi = 0.0;

/* Fill material descriptor
 */
 (*mat)->type  = MOHR_COULOMB_NAV;
 (*mat)->label = label;
 (*mat)->Gamma = 0.0;
 (*mat)->data  = (void *)data;

/* Add to the material list
 */
 MatList[label-1] = (*mat);

} /* End of MohrCoulombNAVNew */


/*
%F This method frees the MOHR COULOMB NONASSOCIATE VARIABLE material 
   data for a given material.
%i Material descriptor.
*/
static void MohrCoulombNAVFree( sMaterial *mat )
{
 sMohrNAVData *data = 0L;

/* Get MOHR COULOMB NONASSOCIATE VARIABLE material data
 */
 data = (sMohrNAVData *)mat->data;

/* Release allocated memory
 */
 free( data );

/* Reset material data
 */
 mat->data = 0L;

} /* End of MohrCoulombNAVFree */


/*
%F This method reads the MOHR COULOMB NONASSOCIATE VARIABLE material 
   information.
%i Material descriptor.
*/
static void MohrCoulombNAVRead( sMaterial *mat )
{
 sMohrNAVData *data = 0L;
 double        nu, e;
 double        sc, ic, fc;
 double        sphi, iphi, fphi;
 double        spsi, ipsi, fpsi;

/* Get the material data
 */
 data = (sMohrNAVData *)mat->data;

/* Read the material parameters
 */
 fscanf( nf, "%lf %lf", &e, &nu );
 fscanf( nf, "%lf %lf %lf", &ic, &fc, &sc );
 fscanf( nf, "%lf %lf %lf", &iphi, &fphi, &sphi );
 fscanf( nf, "%lf %lf %lf", &ipsi, &fpsi, &spsi );

/* Fill material information
 */
 data->E    = e;
 data->Nu   = nu;
 data->sC   = sc;
 data->iC   = ic;
 data->fC   = fc;
 data->sPhi = sphi;
 data->iPhi = iphi;
 data->fPhi = fphi;
 data->sPsi = spsi;
 data->iPsi = ipsi;
 data->fPsi = fpsi;

} /* End of MohrCoulombNAVRead */

/*
%F
*/
static void MohrCoulombNAVEParameter( sMaterial *mat, double *e )
{
 sMohrNAVData *data = 0L;

/* Get material descriptor
 */
 data = (sMohrNAVData *)mat->data;

/* Get Young modules parameters
 */
 (*e) = data->E;

} /* End of MohrCoulombNAVEParameter */


/*
%F 
*/ 
static void MohrCoulombNAVNuParameter( sMaterial *mat, double *nu )
{
 sMohrNAVData *data = 0L;

/* Get material descriptor
 */
 data = (sMohrNAVData *)mat->data;

/* Get Poisson coefficient parameters
 */
 (*nu) = data->Nu;

} /* End of MohrCoulombNAVNuParameter */


/*
%F This function computes the material constitutive matrix
*/
static void MohrCoulombNAVCMatrix( sMaterial *mat, double cm[6][6] )
{
 int           i, j;
 sMohrNAVData *data = 0L;
 double        e, nu;

/* Intialize matrix
 */
 for( i = 0; i < 6; i++ )
  for( j = 0; j < 6; j++ )
   cm[i][j] = 0.0;

/* Get material descriptor
 */ 
 data = (sMohrNAVData *)mat->data;

/* Get element parameters
 */
 e  = data->E;
 nu = data->Nu;

/* Compute matrix elements
 */
 if( NDof == 3 )
 {
  cm[0][0] =
  cm[1][1] =
  cm[2][2] =  e*(nu*nu-1.0) / (nu*(nu+nu*nu)+nu*(nu*nu+nu)+nu*nu-1.0);
  cm[1][0] =
  cm[2][0] =
  cm[0][1] =
  cm[2][1] =
  cm[0][2] =
  cm[1][2] = -e*(nu*nu+nu) / (nu*(nu+nu*nu)+nu*(nu*nu+nu)+nu*nu-1.0);
  cm[3][3] =
  cm[4][4] =
  cm[5][5] = (e * e) / (e + e * (1.0 + 2.0 * nu));
 }
 else
 {
  cm[0][0] = cm[1][1] = (e * (1.0 - nu)) / ((1.0 + nu) * (1.0 - (2.0 * nu)));
  cm[0][1] = cm[1][0] = (e * nu) / ((1.0 + nu) * (1.0 - (2.0 * nu)));
  cm[2][2] = e / (2.0 * (1.0 + nu));
 }

} /* End of MohrCoulombNAVCMatrix */


/*
%F
*/
static void MohrCoulombNAVUpdateStress( sMaterial *mat, double dtime,
                                                        double *yield,
                                                        double *effdef, 
                                                        double *str,
                                                        double *def )
{
 sMohrNAVData *data = 0L;
 double        sig1, sig3, sig2;
 double        c, sc, ic, fc;
 double        phi, sphi, iphi, fphi;
 double        psi, spsi, ipsi, fpsi;
 double        pf, mult, aldp, ni;
 double        cm[6][6];

/* Get material data
 */
 data = (sMohrNAVData *)mat->data;

/* Get material contitutive matrix
 */
 MohrCoulombNAVCMatrix( mat, cm );
 
/* Get material poisson coef.
 */
 MohrCoulombNAVNuParameter( mat, &ni );

/* Get material plastic properties
 */ 
 sc   = data->sC;
 ic   = data->iC;
 fc   = data->fC;
 sphi = data->sPhi;
 iphi = data->iPhi;
 fphi = data->fPhi;
 spsi = data->sPsi;
 ipsi = data->iPsi;
 fpsi = data->fPsi;

/* Computes the principal stresses (Sigma 1 and Sigma 3)
 */
 sig1 = ((str[0] + str[1]) / 2.0) -
        sqrt( (str[0] - str[1])*(str[0] - str[1])/4.0 + str[2] * str[2] );
 sig3 = ((str[0] + str[1]) / 2.0) +
        sqrt( (str[0] - str[1])*(str[0] - str[1])/4.0 + str[2] * str[2] );
 sig2 = ni * (sig1 + sig3);

/* Computes the angle
 */
 phi  = _UpdateParameter( (*effdef), sphi, iphi, fphi );
 phi *= PI / 180.0;
 phi  = (1.0 + sin(phi)) / (1.0 - sin(phi));

/* Update coesion
 */
 c = _UpdateParameter( (*effdef), sc, ic, fc );

/* Compute plastic function
 */
 (*yield) = pf = sig1 - (sig3 * phi) + (2.0 * c * sqrt(phi));

/* Correct the stress if necessery
 */
 if( pf <= 0.0 )
 {
  if( sig1 == str[0]) aldp = 0.0;
  else                aldp = atan2( (sig1 - str[0]), str[2] );

  psi  = _UpdateParameter( (*effdef), spsi, ipsi, fpsi );
  psi *= PI / 180.0;
  psi  = (1.0 + sin(psi)) / (1.0 - sin(psi));

  mult = pf / (-cm[0][0] * (1.0 + (phi*psi)) + (2.0 * psi * cm[0][1]));

  sig1 += mult * (cm[0][0] - (cm[0][1] * psi));
  sig3 += mult * (cm[0][1] - (cm[0][0] * psi));
  sig2 += mult * cm[0][0] * (1.0 - psi);

  str[0] = ((sig1 + sig3) / 2.0) + ((sig1-sig3) * cos(2.0 * aldp) / 2.0);
  str[1] = ((sig1 + sig3) / 2.0) - ((sig1-sig3) * cos(2.0 * aldp) / 2.0);
  str[2] = ((sig1 - sig3) * (sin(2.0 * aldp))) / 2.0;
  str[3] = sig2;

 /* Update effective deformatrion
  */
  (*effdef) += mult * sqrt((2.0/3.0)*(1.0+(psi*psi)));
 }

} /* End of MohrCoulombNAVUpdateStress */


/*
** ------------------------------------------------------------------------
** Public functions:
*/

/*
%F This function initializes the sub-class "MOHR COULOMB NONASSOCIATE VARIABLE".
*/
void MohrCoulombNAVInit( void );
void MohrCoulombNAVInit( void )
{
/* Initialize MOHR COULOMB NONASSOCIATE VARIABLE material sub-class
 */
 MatClass[MOHR_COULOMB_NAV].new       = MohrCoulombNAVNew;
 MatClass[MOHR_COULOMB_NAV].free      = MohrCoulombNAVFree;
 MatClass[MOHR_COULOMB_NAV].read      = MohrCoulombNAVRead;
 MatClass[MOHR_COULOMB_NAV].epar      = MohrCoulombNAVEParameter;
 MatClass[MOHR_COULOMB_NAV].nupar     = MohrCoulombNAVNuParameter;
 MatClass[MOHR_COULOMB_NAV].cmatrix   = MohrCoulombNAVCMatrix;
 MatClass[MOHR_COULOMB_NAV].updatestr = MohrCoulombNAVUpdateStress;
 MatClass[MOHR_COULOMB_NAV].updatepar = 0L;
 MatClass[MOHR_COULOMB_NAV].timestep  = MaterialTimeStep;
 MatClass[MOHR_COULOMB_NAV].density   = MaterialDensity;
 MatClass[MOHR_COULOMB_NAV].vstrain   = 0L;

} /* End of MohrCoulombNAVInit */


/* =======================================================  End of File  */

---