mises.c

Go to the documentation of this file.

/*
%M This modules contains the MISES material sub-class methods and 
   definitions
%a Joao Luiz Elias Campos.
%d September 8th, 1998.
%r $Id: mises.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 MISES material data definition
*/
typedef struct _misesdata
{
 double E;             /* Young modulos       */
 double Nu;            /* Poisson coefficient */
 double Smax;          /* Maximum stress      */
} sMisesData;


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


/*
** ------------------------------------------------------------------------
** Subclass methods:
*/
static void MisesNew         ( int, sMaterial ** );
static void MisesFree        ( sMaterial * );
static void MisesRead        ( sMaterial * );
static void MisesEParameter  ( sMaterial *, double * );
static void MisesNuParameter ( sMaterial *, double * );
static void MisesCMatrix     ( sMaterial *, double [6][6] );
static void MisesUpdateStress( sMaterial *, double, double *, double *,
                                            double *, double * );


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

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

/* Get memory for the MISES material data
 */
 data = (sMisesData *)calloc(1, sizeof(sMisesData));

/* Fill MISES material data
 */
 data->E    = 0.0;
 data->Nu   = 0.0;
 data->Smax = 0.0;

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

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

} /* End of MisesNew */


/*
%F This method frees the MISES material data for a given material.
%i Material descriptor.
*/
static void MisesFree( sMaterial *mat )
{
 sMisesData *data = 0L;

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

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

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

} /* End of MisesFree */


/*
%F This method reads the MISES material information.
%i Material descriptor.
*/
static void MisesRead( sMaterial *mat )
{
 sMisesData *data = 0L;
 double      e, nu, smax;

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

/* Read the material parameters
 */
 fscanf( nf, "%lf %lf %lf", &e, &nu, &smax );

/* Fill material information
 */
 data->E    = e;
 data->Nu   = nu;
 data->Smax = smax;

} /* End of MisesRead */


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

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

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

} /* End of MisesEParameter */


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

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

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

} /* End of MisesNuParameter */


/*
%F This function computes the material constitutive matrix
*/
static void MisesCMatrix( sMaterial *mat, double cm[6][6] )
{
 int         i, j;
 sMisesData *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 = (sMisesData *)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 MisesCMatrix */


/*
%F
*/
static void MisesUpdateStress( sMaterial *mat, double dtime, double *yield,
                                               double *effdef, double *str,
                                               double *def )
{
 sMisesData *data = 0L;
 double      sig1, sig2, sig3;
 double      nu, smax, pf;
 double      smed, sdev[3], scl, trans, r, aux;

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

/* Get material plastic properties
 */
 nu   = data->Nu;
 smax = data->Smax;

/* 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] );
 sig2 = nu * (str[0] + str[1]);
 sig3 = ((str[0] + str[1]) / 2.0) +
        sqrt( (str[0] - str[1])*(str[0] - str[1])/4.0 + str[2] * str[2] );

/* Compute plastic function
 */
 pf = smax - sqrt( 0.5 *((sig1 - sig2) * (sig1 - sig2) + (sig1 - sig2) * (sig1 - sig2) + 
                         (sig2 - sig3) * (sig2 - sig3)) );
 (*yield) = pf;

/* Correct the stress if necessery
 */
 if( pf <= 0.0 )
 {
  smed = (sig1 + sig2 + sig3) / 3.0;

  sdev[0] = sig1 - smed;
  sdev[1] = sig2 - smed;
  sdev[2] = sig3 - smed;

  aux = sqrt((sdev[0] * sdev[0]) + (sdev[1] * sdev[1]) + (sdev[2] * sdev[2]));

  sdev[0] /= aux;
  sdev[1] /= aux;
  sdev[2] /= aux;

  r     = sqrt( 2.0 / 3.0 ) * smax;
  scl   = r * ((sdev[2] - sdev[0]) / (sig3 - sig1));
  trans = smed + (0.5 * r * (sdev[0] + sdev[2]));
  aux   = (str[0] - str[1]) / 2.0;

 /* Update stress
  */
  str[0]  = ( scl * aux) + trans;
  str[1]  = (-scl * aux) + trans;
  str[2] *=   scl;
 }

} /* End of MisesUpdateStress */


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

/*
%F This function initializes the sub-class "MISES".
*/
void MisesInit( void );
void MisesInit( void )
{
/* Initialize MISES material sub-class
 */
 MatClass[MISES].new       = MisesNew;
 MatClass[MISES].free      = MisesFree;
 MatClass[MISES].read      = MisesRead;
 MatClass[MISES].epar      = MisesEParameter;
 MatClass[MISES].nupar     = MisesNuParameter;
 MatClass[MISES].cmatrix   = MisesCMatrix;
 MatClass[MISES].updatestr = MisesUpdateStress;
 MatClass[MISES].updatepar = 0L;
 MatClass[MISES].timestep  = MaterialTimeStep;
 MatClass[MISES].density   = MaterialDensity;
 MatClass[MISES].vstrain   = 0L;

} /* End of MisesInit */


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

---