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

// -------------------------------------------------------------------------
// CModel.h - This header file contains the public data structure
//            definitions for the Constitutive Model class within FEMOOP.
// -------------------------------------------------------------------------
//
// Description:  There are several conceptual operations which are common
//               to all constitutive models (e.g. the  stress evaluation
//               for a given state of strain), these operations are defined
//               below.
//
//               Currently are implemented the models:
//               Elastic Linear
//               Elastic-Plastic
//                  von Mises
//                  Tresca
//                  Drucker-Prager
//                  Mohr-Coulomb
//                Polar von Mises
//                Damage
//                  Bilinear
//                  Nonlinear
//                
//   It's important to note that each integration (Gauss) point  of the 
//   Finite Element mesh must have its constitutive model. This is necessary
//   because in nonlinear analysis the stress is a function not only  of
//   the current strain but of the whole strain history.
//   Each constitutive model object has a pointer to its integr. point and
//   a pointer to its material. The object material knows only the data 
//   read in the neutral file.  
// -------------------------------------------------------------------------
//  References:
//
//  [1] "Plasticity: Computational Aspects", J. C. Simo & T. J. R. Hughes,
//       1988.
//  [2] "The Finite Element Method", O. C. Zienkiewicz & R. L. Taylor, 
//       Vol. 2, Fourth Edition, McGraw-Hill, 1991.
//  [3] "Plasticity in Reinforced Concrete", W. F. Chen, McGraw-Hill, New
//       York, 1984.
//   
// -------------------------------------------------------------------------
// Main public methods:
// -------------------------------------------------------------------------
//
// static cConstModel *CreateModel( cIntPt *ipt )
//  
//      ipt        -  integration point                              (  in )
//
// Creates a new constitutive model for a given integr. point and returns
// a pointer to this model.
//
// -------------------------------------------------------------------------
//
// static cConstModel GetTotNumPrintScls( void )
//  
// Returns the number of different constitutive model labels. 
//
// -------------------------------------------------------------------------
//
// static cConstModel GetTotPrintSclLabs( char **label )
//  
// Returns the constitutive model labels.
//
// -------------------------------------------------------------------------
//
// virtual void  Init( void )
//
// Initializes the constitutive model.
//
// -------------------------------------------------------------------------
//
// virtual void  Update( void )
//
// Updates the history of the constitutive model. The iterative variables 
// are assigned to the incremental variables. This operation must be done
// only after the structure had been reached a equilibrium state. If the
// history isn't important to the model, then this method does nothing.
//
// -------------------------------------------------------------------------
//
// 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.
//
// -------------------------------------------------------------------------
//
// virtual void  ModifyCMatrix( double **c_matrix )
//
//      c_matrix    -  constitutive matrix                        ( in/out )
//
// Modifies the elastic constitutive matrix according to the current
// state of stress and strain and its respectives histories.
//
// -------------------------------------------------------------------------
//
// virtual int   GetNumPrintScls( void )
//
// Returns the number of scalar values of the constitutive model that
// should be printed in the output file.
//
// -------------------------------------------------------------------------
//
// virtual void  GetPrintSclLabs( char **label )
//
//      label       -  array with print labels                       ( out )
//
// Returns the labels of scalar values of the constitutive model that
// should be printed in the output file.
//
// -------------------------------------------------------------------------
//
// virtual void  GetPrintSclVals( double *stress, double *val )
//
//      stress      -  current stress vector                         (  in )
//      val         -  vector with print values                      ( out )
//
// Returns the scalar values of the constitutive model that
// should be printed in the output file.
//
// -------------------------------------------------------------------------
//
// $Author: evandro $
// $Revision: 1.3 $
// $Date: 2000/04/04 22:30:08 $
// $State: Exp $
//
// -------------------------------------------------------------------------

#ifndef _CMODEL_H
#define _CMODEL_H

#include "gbldefs.h"

// -------------------------------------------------------------------------
// Forward declarations:
//
class cMaterial;
class cIntPt;

// -------------------------------------------------------------------------
// Constituive models types:
//
typedef enum _constmodeltype
{
 ELASTICLIN,              // Elastic Linear Model
 VONMISES,                // Elastic-Plastic von Mises Model
 PVONMISES,               // Elastic-Plastic Polar von Mises Model
 DRUCKERPRAGER,           // Elastic-Plastic Drucker-Prager Model 
 TRESCA,                  // Elastic-Plastic Tresca Model 
 MOHRCOULOMB,             // Elastic-Plastic Mohr-Coulomb Model 
 DAMAGEBL,                // Bilinear Damage Model
 DAMAGENL,                // Nonlinear Damage Model
 WINKLERPT,               // Nonlinear Winkler Model
 WINKLER2DPT              // Nonlinear Winkler Model for 2D problems
} eConstModelType;

// -------------------------------------------------------------------------
// Max sizes:
//
#define NUM_MAX_LABELS   100

// -------------------------------------------------------------------------
// Base Constitutive Model class:
//
class cConstModel
{
 private:
  static int  _iNumScalarLabels;
  static char *_chScalarLabels[NUM_MAX_LABELS];

 protected:
  eConstModelType  _eType;               // Constitutive model type
  cMaterial       *_pcMat;               // Global material
  cIntPt          *_pcIpt;               // Integration point
      
 public:
                            cConstModel        ( cIntPt *, cMaterial * );
  virtual                  ~cConstModel        ( void ) { }
  static  cConstModel      *CreateModel        ( cIntPt * );
  static  int               GetTotNumPrintScls ( void );
  static  void              GetTotPrintSclLabs ( char ** );
          cMaterial        *GetMaterialAddr    ( void ) { return _pcMat; }
          eConstModelType   GetType            ( void ) { return _eType; }
  virtual void              Init               ( void ) { }
  virtual void              Update             ( void ) { }
  virtual int               Stress             ( double *, double * ) = 0;
  virtual void              ModifyCMatrix      ( double ** ) = 0;
  virtual int               GetNumPrintScls    ( void ) { return 0; }
  virtual void              GetPrintSclLabs    ( char ** )  { }
  virtual void              GetPrintSclVals    ( double *, double * ) { }

 private:
  static  void              AddLabelList       ( cConstModel * );
};

#endif

---