J:/Tecgraf/prj/femoop/trunk/cmod/elasplas.h

// -------------------------------------------------------------------------
// ElasPlas.h - This header file contains the  public  data  structure
//              definitions for the Associative Elasto-plastic constitutive
//              model class within FEMOOP.
// -------------------------------------------------------------------------
//
// Description:  In this base case are implemented the general methods of
//               the elasto-plastic constitutive models (e.g. the  return
//               of a trial state of stress to  the yield surface).  Each
//               particular model has only to  implement  simple  methods  
//               (e.g.  a  method to  evaluate the  yield function).  All 
//               these methods are defined below.
//
//               Currently are implemented the models:
//               von Mises
//               Tresca
//               Drucker-Prager
//               Mohr-Coulomb
//
//               Important: The elasto-plastic  constitutive models must
//                          have only one surface.
//
// -------------------------------------------------------------------------
// Main reference:
//
// "Plasticity: Computational Aspects", J. C. Simo & T. J. R. Hughes, 1988.
//
// -------------------------------------------------------------------------
// Main public methods:
// -------------------------------------------------------------------------
//
// virtual void  Init( void )
//
// Initializes the elasto-plastic model.
//
// -------------------------------------------------------------------------
//
// virtual void  Update( void )
//
// Updates the history of the elasto-plastic model. The iterative plastic 
// strains and internal (hardening) variables are assigned to the
// incremental variables. This operation must be done only after the
// structure has reached an equilibrium state. 
//
// -------------------------------------------------------------------------
//
// virtual int Stress( double *strain_vec, double *stress_vec )
//
//      strain_vec -  integration point strain vector           (  in )
//      stress_vec -  integration point stress vector           ( out )
//
// Evaluates the state of stress in a integration point for a given state of
// strain. It returns (1) if the operation had success an (0) otherwise.
// First this methods tries to use the Closest-Point Projection Algorithm,
// if this method fails then it tries the Cutting Plane Algorithm.
//
// -------------------------------------------------------------------------
//
// virtual void  ModifyCMatrix( double **c_matrix )
//
//      c_matrix    -  constitutive matrix                      ( in/out )
//
// Evaluates the elasto-plastic constitutive matrix. If the step is 
// elastic (_dGamma == 0) does nothing. If the return to yield surface
// was performed by the Closest-Point Projection Algorithm then this
// method evaluates the consistent constitutive matrix, but when used 
// the Cutting Plane Algorithm it evaluates the classical one. 
//
// -------------------------------------------------------------------------
//
// virtual void GetPlasticVar( double *Ep, double *alpha )
//
//      Ep         -  plastic strains                           ( out )
//      alpha      -  internal variable in strain space         ( out )
//      
// Returns the current iterative plastic strains and the internal in 
// variables strain space.
//
// -------------------------------------------------------------------------
//
// virtual void SetPlasticVar( double *Ep, double *alpha )
//
//      Ep         -  plastic strains                           ( out )
//      alpha      -  internal variables in strain space        ( out )
//      
// Stores the plastic strains and the internal variables in the iterative
// variables.
//
// -------------------------------------------------------------------------
//
// virtual void InternalVar( double *alpha, double *q )
//
//      alpha      -  internal variables in strain space        (  in )
//      q          -  internal variables in stress space        ( out )
//      
// Evaluates the internal variables in stress space from a givem set of
// variables in strain space.
//
// -------------------------------------------------------------------------
//
// virtual void PlasticModuli( double *alpha, double *D )
//
//      alpha      -  internal variables in strain space        (  in )
//      D          -  generalized plastic moduli                ( out )
//      
// Returns the matrix of generalized plastic moduli.
//
// -------------------------------------------------------------------------
//
// virtual double YieldFunction( double *stress, double *q )
//
//      stress     -  stress vector                             (  in )
//      q          -  internal variables in stress space        (  in )
//      
// Returns the yield function value from a given state of stress and
// internal variables.
//
// -------------------------------------------------------------------------
//
// virtual void YieldGrad( double *stress, double *q, 
//                         double *dfs,    double *dfq )
//
//      stress     -  stress vector                             (  in )
//      q          -  internal variables in stress space        (  in )
//      dfs        -  derivative of yield surf. w.r.t. stress   ( out )
//      dfq        -  derivative of yield surf. w.r.t. int. var.( out )
//      
// Evaluates the gradient of yield surface w.r.t. the stress components
// and internal variables in stress space.
//
// -------------------------------------------------------------------------
//
// virtual void YieldHessian( double *stress, double *q, double **H )
//
//      stress     -  stress vector                             (  in )
//      q          -  internal variables in stress space        (  in )
//      H          -  hessian of yield surface                  ( out )
//      
// Evaluates the hessian of yield surface w.r.t. the stress components
// and internal variables in stress space.
//
// -------------------------------------------------------------------------
// Private methods:
// -------------------------------------------------------------------------
//
// int  ClosestPoint( double *Et, double **C, double **C1,
//                    double *Sig )
//
//      Et         -  total strain                              (  in )
//      C          -  elastic constitutive matrix               (  in )
//      C1         -  inverse of elastic constitutive matrix    (  in )
//      Sig        -  stress vector                             ( out )
//
// Evaluates the state of stress from a given state of strain using the
// Closest-Point Projection Algorithm. Evaluates the plastic strains and
// the internal variables. 
// -------------------------------------------------------------------------
//
// int  CuttingPlane( double *Et, double **C, double *Sig )
//
//      Et         -  total strain                              (  in )
//      C          -  elastic constitutive matrix               (  in )
//      Sig        -  stress vector                             ( out )
//
// Evaluates the state of stress from a given state of strain using the
// Cutting Plane Algorithm. Evalautes the plastic strains and the internal 
// variables. 
// 
// -------------------------------------------------------------------------
//
// $Author: joaquim $
// $Revision: 1.2 $
// $Date: 1998/02/16 20:21:11 $
// $State: Exp $
//
// -------------------------------------------------------------------------

#ifndef _ELASTOPLASTIC_H
#define _ELASTOPLASTIC_H

#include "cmodel.h"

// -------------------------------------------------------------------------
// Elasto-plastic constitutive model class:

class cElastoPlastic : public cConstModel
{
 protected:
  int      _iNumStrCmp;    // Num. of stress components
  int      _iNumIntVar;    // Number of internal variables
  double   _dGamma;        // Plastic Multiplier   
  double   _dDenom;        // {dF/dSig  dF/dq} [A] {df/dSig  df/dq}  
  double   *_dFdSig;       // Deriv. of Yield Func. w.r.t stress
  double   *_dFdq;         // Deriv. of Yield Func. w.r.t internal var. 
  double   **_H;           // Algorithmic moduli (consistent)

 public:
                 cElastoPlastic ( cIntPt *, cMaterial * );
                ~cElastoPlastic ( void );
  virtual void   Init           ( void ) = 0;
  virtual void   Update         ( void ) = 0;
  virtual int    Stress         ( double *, double * );
  virtual void   ModifyCMatrix  ( double ** );
  virtual void   GetPlasticVar  ( double *, double *  ) = 0;
  virtual void   SetPlasticVar  ( double *, double *  ) = 0;
  virtual void   InternalVar    ( double *, double *  ) = 0;
  virtual void   PlasticModuli  ( double *, double ** ) = 0;
  virtual double YieldFunction  ( double *, double *  ) = 0;
  virtual void   YieldGrad      ( double *, double *, double *, double * ) = 0;
  virtual void   YieldHessian   ( double *, double *, double ** );
  virtual int    GetNumPrintScls( void ) { return 0; }
  virtual void   GetPrintSclLabs( char ** ) { }
  virtual void   GetPrintSclVals( double *, double * ) { }

 private:
  int ClosestPoint ( double *, double **, double **, double * );
  int CuttingPlane ( double *, double **, double * );
};

#endif

---