isofail.c

Go to the documentation of this file.

/*
%M This modules contains the ISOTROPIC material sub-class methods and 
   definitions. This material contains the failure capability.
%a Joao Luiz Elias Campos.
%d January 11st, 1999.
%r $Id: isofail.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 methods
 */
void MaterialTimeStep( sMaterial *, double * );
void MaterialDensity ( sMaterial *, double * );


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

/*
%T ISOTROPIC_FAIL material data definition
*/
typedef struct _isofdata
{
 double E0;            /* Initial young modulos     */
 double E;             /* Young modulos             */
 double Nu;            /* Poisson coefficient       */
 double Ft;            /* Traction straight         */
 double et;            /* Strain value on traction  */
 double e0;            /* Strain value to softening */
} sIsoFData;


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


/*
** ------------------------------------------------------------------------
** Subclass methods:
*/
static void IsotropicFailNew            ( int, sMaterial ** );
static void IsotropicFailFree           ( sMaterial * );
static void IsotropicFailRead           ( sMaterial * );
static void IsotropicFailEParameter     ( sMaterial *, double * );
static void IsotropicFailNuParameter    ( sMaterial *, double * );
static void IsotropicFailCMatrix        ( sMaterial *, double [6][6] );
static void IsotropicFailUpdateParameter( sMaterial *, double );
static void IsotropicFailUpdateStress   ( sMaterial *, double, double *,
                                                       double *, double *,
                                                       double * );


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

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

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

/* Fill ISOTROPIC_FAIL material data
 */
 data->E0  = 0.0;
 data->E   = 0.0;
 data->Nu  = 0.0;
 data->Ft  = 0.0;
 data->e0  = 0.0;
 data->et  = 0.0;

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

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

} /* End of IsotropicFailNew */


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

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

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

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

} /* End of IsotropicFailFree */


/*
%F This method reads the ISOTROPIC_FAIL material information.
%i Material descriptor.
*/
static void IsotropicFailRead( sMaterial *mat )
{
 sIsoFData *data = 0L;
 double     e, nu, ft, et, e0;

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

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

/* Fill material information
 */
 data->E0 = e;
 data->E  = e;
 data->Nu = nu;
 data->Ft = ft;
 data->et = et;
 data->e0 = e0;

} /* End of IsotropicFailRead */


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

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

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

} /* End of IsotropicFailEParameter */


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

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

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

} /* End of IsotropicFailNuParameter */


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


/*
%F This function updates the Young modules for the current strain filed.
*/
static void IsotropicFailUpdateParameter( sMaterial *mat, double str )
{
 sIsoFData *data = 0L;
 double     phi, E0, Ft, e0, et, e;

/* Get material data
 */
 data = (sIsoFData *)mat->data;
 
/* Get material parameters
 */
 E0 = data->E0;
 Ft = data->Ft;
 e0 = data->e0;
 et = data->et;
 e  = str;

/* Check to see if the deformation value is diferent than zero
 */
 if( e == 0.0 )
  return;

/* Compute fail function
 */
 phi = (Ft / (E0 * (e0 - et))) * ((e0 - e) / e);

/* Check to see if the current strain is traction
 */
 if( e <= et )
  data->E = data->E0;
 else if( (e > et) && (e < e0) )
  data->E = phi * data->E0;
 else
  data->E = 0.0;

} /* End of IsotropicFailUpdateParameter */


/*
%F This function updates the effective strain that be used to compute the 
   fail parameter.
*/
static void IsotropicFailUpdateStress( sMaterial *mat, double dtime,
                                                       double *yield,
                                                       double *effdef,
                                                       double *str,
                                                       double *def )
{
 double maxdef = 0.0;

/* Get the maximum traction deformation
 */
      if( def[0] > maxdef ) maxdef = def[0];
 else if( def[1] > maxdef ) maxdef = def[1];

/* Set effective strain
 */
 (*effdef) = maxdef;

} /* End of IsotropicFailUpdateStress */


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

/*
%F This function initializes the sub-class "ISOTROPIC_FAIL .
*/
void IsotropicFailInit( void );
void IsotropicFailInit( void )
{
/* Initialize ISOTROPIC_FAIL material sub-class
 */
 MatClass[ISOTROPIC_FAIL].new       = IsotropicFailNew;
 MatClass[ISOTROPIC_FAIL].free      = IsotropicFailFree;
 MatClass[ISOTROPIC_FAIL].read      = IsotropicFailRead;
 MatClass[ISOTROPIC_FAIL].epar      = IsotropicFailEParameter;
 MatClass[ISOTROPIC_FAIL].nupar     = IsotropicFailNuParameter;
 MatClass[ISOTROPIC_FAIL].cmatrix   = IsotropicFailCMatrix;
 MatClass[ISOTROPIC_FAIL].updatepar = IsotropicFailUpdateParameter;
 MatClass[ISOTROPIC_FAIL].updatestr = IsotropicFailUpdateStress;
 MatClass[ISOTROPIC_FAIL].timestep  = MaterialTimeStep;
 MatClass[ISOTROPIC_FAIL].density   = MaterialDensity;
 MatClass[ISOTROPIC_FAIL].vstrain   = 0L;

} /* End of IsotropicFailInit */


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

---