maxwell.c

Go to the documentation of this file.

/*
%M This modules contains the MAXWELL material sub-class methods and 
   definitions
%a Joao Luiz Elias Campos.
%d September 2nd, 1998.
%r $Id: maxwell.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 "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 MAXWELL material data definition
*/
typedef struct _isodata
{
 double E;             /* Young modulos       */
 double Nu;            /* Poisson coefficient */
 double N;             /* Viscosity parameter */
} sMaxwellData;


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


/*
** ------------------------------------------------------------------------
** Subclass methods:
*/
static void MaxwellNew         ( int, sMaterial ** );
static void MaxwellFree        ( sMaterial * );
static void MaxwellRead        ( sMaterial * );
static void MaxwellEParameter  ( sMaterial *, double * );
static void MaxwellNuParameter ( sMaterial *, double * );
static void MaxwellCMatrix     ( sMaterial *, double [6][6] );
static void MaxwellViscoStrain ( sMaterial *, double, sTensor *, sTensor * );
static void MaxwellUpdateStress( sMaterial *, double, double *, double *,
                                              double *, double * );


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

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

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

/* Fill MAXWELL material data
 */
 data->E  = 0.0;
 data->Nu = 0.0;
 data->N  = 0.0;

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

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

} /* End of MaxwellNew */


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

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

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

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

} /* End of MaxwellFree */


/*
%F This method reads the MAXWELL material information.
%i Material descriptor.
*/
static void MaxwellRead( sMaterial *mat )
{
 sMaxwellData *data = 0L;
 double        e, nu, n;

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

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

/* Fill material information
 */
 data->E  = e;
 data->Nu = nu;
 data->N  = n;

} /* End of MaxwellRead */


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

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

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

} /* End of MaxwellEParameter */


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

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

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

} /* End of MaxwellNuParameter */


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

/*
%F
*/
static void MaxwellViscoStrain( sMaterial *mat, double timeStep, sTensor *str,
                                sTensor *stav )
{
 double        sm, n;
 sMaxwellData *data = 0L;

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

/* Get material viscos parameter
 */
 n = data->N;
 
/* Compute mean stress
 */ 
 sm = (str->xx + str->yy + str->zz) / 3.0;
 
/* Compute visco strain
 */
 stav->xx = 0.5 * n * (str->xx - sm) / timeStep;
 stav->yy = 0.5 * n * (str->yy - sm) / timeStep;
 stav->zz = 0.5 * n * (str->zz - sm) / timeStep;
 stav->xy = 0.5 * n * str->xy / timeStep;
 stav->xz = 0.5 * n * str->xz / timeStep;
 stav->yz = 0.5 * n * str->yz / timeStep;
 
} /* End of MaxwellViscoStrain */

static void MaxwellUpdateStress( sMaterial *mat, double dtime,
                                                 double *yield,
                                                 double *effdef,
                                                 double *str,
                                                 double *def )
{
 sMaxwellData *data = 0L;
 double        n, ni;
 double        cm[6][6];
 double        C1, C2;
 sTensor       stre, stra, stred, strad, upstrd;
 sPTensor      pstr;

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

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

/* Get material viscous property and elasticity property
 */ 
 n = data->N;

/* Compute constants
 */
 C1 = 1.0 - ((cm[2][2] * dtime)/(2.0 * n));
 C2 = 1.0 / (1.0 + ((cm[2][2] * dtime)/(2.0 * n)));

/* Compute the desviatory stress and strain
 */
 stre.xx = str[0];
 stre.yy = str[1];
 stre.xy = str[2];
 PrincipalTensor( &stre, &pstr );

 stred.xx = stre.xx - ((pstr.dir1 + pstr.dir3 + pstr.dir2)/3.0);
 stred.yy = stre.yy - ((pstr.dir1 + pstr.dir3 + pstr.dir2)/3.0);

 stra.xx = def[0];
 stra.yy = def[1];
 stra.xy = def[2];
 PrincipalTensor( &stra, &pstr );

 strad.xx = stra.xx - ((pstr.dir1 + pstr.dir3 + pstr.dir2)/3.0);
 strad.yy = stra.yy - ((pstr.dir1 + pstr.dir3 + pstr.dir2)/3.0);

/* Compute updated desviatory stress
 */
 upstrd.xx = C2 * ((C1 * stred.xx) + (2.0 * cm[2][2] * strad.xx));
 upstrd.yy = C2 * ((C1 * stred.yy) + (2.0 * cm[2][2] * strad.yy));

} /* End of MaxwellUpdateStress */


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

/*
%F This function initializes the sub-class "MAXWELL".
*/
void MaxwellInit( void );
void MaxwellInit( void )
{
/* Initialize MAXWELL material sub-class
 */
 MatClass[MAXWELL].new       = MaxwellNew;
 MatClass[MAXWELL].free      = MaxwellFree;
 MatClass[MAXWELL].read      = MaxwellRead;
 MatClass[MAXWELL].epar      = MaxwellEParameter;
 MatClass[MAXWELL].nupar     = MaxwellNuParameter;
 MatClass[MAXWELL].cmatrix   = MaxwellCMatrix;
 MatClass[MAXWELL].updatestr = 0L;
 MatClass[MAXWELL].updatepar = 0L;
 MatClass[MAXWELL].timestep  = MaterialTimeStep;
 MatClass[MAXWELL].density   = MaterialDensity;
 MatClass[MAXWELL].vstrain   = MaxwellViscoStrain;

} /* End of MaxwellInit */


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

---