itfmohr.c

Go to the documentation of this file.

/*
%M This modules contains the INTERFACE MOHR COULOMB material sub-class 
   methods and definitions
%a Joao Luiz Elias Campos.
%d September 9th, 1998.
%r $Id: itfmohr.c,v 1.1 2004/06/22 05:29:58 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 method
 */
void MaterialDensity( sMaterial *, double * );


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

/*
%T INTERFACE MOHR COULOMB material data definition
*/
typedef struct _isodata
{
 double Ks;            /* Shear rigidity moduless */
 double Kn;            /* Normal rigidity modules */
 double C;             /* Coesion value           */
 double Phi;           /* Friction angle          */
} sItfMohrData;


#ifndef PI
#define PI 3.141592654
#endif


/*
** ------------------------------------------------------------------------
** Local functions:
*/


/*
** ------------------------------------------------------------------------
** Subclass methods:
*/
static void ItfMohrCoulombNew         ( int, sMaterial ** );
static void ItfMohrCoulombFree        ( sMaterial * );
static void ItfMohrCoulombRead        ( sMaterial * );
static void ItfMohrCoulombEParameter  ( sMaterial *, double * );
static void ItfMohrCoulombNuParameter ( sMaterial *, double * );
static void ItfMohrCoulombCMatrix     ( sMaterial *, double [6][6] );
static void ItfMohrCoulombUpdateStress( sMaterial *, double, double *, double *,
                                                     double *, double * );


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

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

/* Get memory for the INTERFACE MOHR COULOMB material data
 */
 data = (sItfMohrData *)calloc(1, sizeof(sItfMohrData));

/* Fill INTERFACE MOHR COULOMB material data
 */
 data->Ks  = 0.0;
 data->Kn  = 0.0;
 data->C   = 0.0;
 data->Phi = 0.0;

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

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

} /* End of ItfMohrCoulombNew */


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

/* Get INTERFACE MOHR COULOMB material data
 */
 data = (sItfMohrData *)mat->data;

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

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

} /* End of ItfMohrCoulombFree */


/*
%F This method reads the INTERFACE MOHR COULOMB material information.
%i Material descriptor.
*/
static void ItfMohrCoulombRead( sMaterial *mat )
{
 sItfMohrData *data = 0L;
 double        ks, kn, c, phi;

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

/* Read the material parameters
 */
 fscanf( nf, "%lf %lf %lf %lf", &kn, &ks, &c, &phi );

/* Fill material information
 */
 data->Ks  = ks;
 data->Kn  = kn;
 data->C   = c;
 data->Phi = phi;

} /* End of ItfMohrCoulombRead */


/*
%F
*/
static void ItfMohrCoulombEParameter( sMaterial *mat, double *ks )
{
 sItfMohrData *data = 0L;

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

/* Get Young modules parameters
 */
 (*ks) = data->Ks;

} /* End of ItfMohrCoulombEParameter */


/*
%F
*/
static void ItfMohrCoulombNuParameter( sMaterial *mat, double *kn )
{
 sItfMohrData *data = 0L;

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

/* Get Poisson coefficient parameters
 */
 (*kn) = data->Kn;

} /* End of ItfMohrCoulombNuParameter */


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

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

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

/* Get element parameters
 */
 ks = data->Ks;
 kn = data->Kn;

/* Compute matrix elements
 */
 if( NDof == 3 )
 {
  cm[0][0] = ks;
  cm[1][1] = kn;
  cm[2][2] = kn;
 }
 else
 {
  cm[0][0] = ks;
  cm[1][1] = kn;
 }
 
} /* End of ItfMohrCoulombCMatrix */


/*
%F
*/
static void ItfMohrCoulombUpdateStress( sMaterial *mat, double dtime, 
                                                        double *yield,
                                                        double *effdef, 
                                                        double *str,
                                                        double *def )
{
 sItfMohrData *data = 0L;
 double        sig1, sig3;
 double        c, phi, pf;
 double        cm[6][6];

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

/* Get material contitutive matrix
 */
 ItfMohrCoulombCMatrix( mat, cm );

/* Get material plastic properties
 */
 c   = data->C;
 phi = data->Phi;

/* 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] );

/* Computes the angle
 */
 phi *= PI / 180.0;

/* Compute plastic function (maximum shear stress)
 */
 (*yield) = pf = c - (str[1] * tan(phi));

/* Correct the stress if necessery
 */
 if( pf < 0.0 )
 {
  str[0] = str[1] = 0.0;
 }
 else
 {
  if( pf < fabs(str[0]) ) 
  {
   if( str[0] > 0.0 ) str[0] =  pf;
   else               str[0] = -pf;
  }
 }

} /* End of ItfMohrCoulombUpdateStress */


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

/*
%F This function initializes the sub-class "INTERFACE MOHR COULOMB".
*/
void ItfMohrCoulombMatInit( void );
void ItfMohrCoulombMatInit( void )
{
/* Initialize INTERFACE MOHR COULOMB material sub-class
 */
 MatClass[ITF_MOHR_COULOMB].new       = ItfMohrCoulombNew;
 MatClass[ITF_MOHR_COULOMB].free      = ItfMohrCoulombFree;
 MatClass[ITF_MOHR_COULOMB].read      = ItfMohrCoulombRead;
 MatClass[ITF_MOHR_COULOMB].epar      = ItfMohrCoulombEParameter;
 MatClass[ITF_MOHR_COULOMB].nupar     = ItfMohrCoulombNuParameter;
 MatClass[ITF_MOHR_COULOMB].cmatrix   = ItfMohrCoulombCMatrix;
 MatClass[ITF_MOHR_COULOMB].updatestr = ItfMohrCoulombUpdateStress;
 MatClass[ITF_MOHR_COULOMB].updatepar = 0L;
 MatClass[ITF_MOHR_COULOMB].timestep  = 0L;
 MatClass[ITF_MOHR_COULOMB].density   = MaterialDensity;
 MatClass[ITF_MOHR_COULOMB].vstrain   = 0L;

} /* End of ItfMohrCoulombMatInit */


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

---