J:/Tecgraf/prj/femoop/trunk/fem/fem.h

// -------------------------------------------------------------------------
// Fem.h - This header file contains the public data structure definitions
//         for the Finite Element Method class mechanism within FEMOOP.
// -------------------------------------------------------------------------
//
// Description:  This class manages the global operations of the Finite
//               Element Method, like the computation of the profile of 
//               the stiffnes matrix and the computation of the internal
//               force vector.
//
//               Currently are implemented the subclasses:
//               FemMech       - Fem for structural mechanics
//
// -------------------------------------------------------------------------
// Main public methods:
// -------------------------------------------------------------------------
//
// eFemType GetType( void )
//
// Returns the Finite Element Model type.
// -------------------------------------------------------------------------
//
// cSmooth *GetSmooth( void )
//
// Returns the pointer to smoothing class.
// -------------------------------------------------------------------------
//
// cDSA *GetDSA( void )
//
// Returns the pointer to design sensitivity analysis class.
// -------------------------------------------------------------------------
//
// int GetNumEq( void )
//
// Returns the total number of equations.
// -------------------------------------------------------------------------
//
// int *GetProfile( void )
//
// Returns the profile of the stiffness matrix.
// -------------------------------------------------------------------------
//
// virtual void UpdateState( void )
//
// Updates the system variables. For mechanical problems exemples are the
// internal variables of constitutive models or the rigid rotations of
// co-rotational elements.
// -------------------------------------------------------------------------
//
// virtual void AssignState( double *s )
//
//   s - vector of state variables                               ( out )
//
// Stores the final values of the state variables (eg. nodal displacements),
// this method should be called after the convergence of the global 
// numerical algorithm.
// -------------------------------------------------------------------------
//
// virtual void GetDValues( double *u )
//
//   u - vector of nodal displacements                           ( out )
//
// Returns the current values of nodal displacements.
// -------------------------------------------------------------------------
//
// virtual void InitValues( void )
//
// Initializes the system variables. For mechanical problems are the nodal
// forces and constitutive models.
// -------------------------------------------------------------------------
//
// virtual double CalcVol( void )
//
// Evaluates and returns the volume of the finite element mesh.
// -------------------------------------------------------------------------
//
// virtual int ExistStrainLoads( void )
//
// Returns 1 if there are strain loads (e.g. thermal loads) in the FE model
// and 0 otherwise.
// -------------------------------------------------------------------------
//
//  virtual int StrainLoadVector( cVector &g, cVector &dg );
//
//   g     - current internal force vector                       ( out )
//   dg    - strain load vector                                  ( out )
//
// Computes the strain load vector (e.g. due to thermal effects) by finite
// difference: {dg} = {g(u, lf + dlf)} - {g(u, lf)})/dlf
// -------------------------------------------------------------------------
// virtual void CompEqs( void )
//
// Evaluates the total number of equations and generate the number of
// each degree of freedom.
// -------------------------------------------------------------------------
//
// virtual void Profile( void )
//
// Computes the profile of the global stiffness matrix.
// -------------------------------------------------------------------------
//
// virtual void PrscDispVector( int *prdof, double *prdsp )
//
//   prdof - array of prescribed dofs                            ( out )
//   prdsp - array of prescribed displacements                   ( out )
//
// Computes the vector of prescribed dofs and the associated prescribed 
// displacements. The dimension of the given vectors is the number of
// prescribed displacements (obtained from cNode class).
// It should be noted that the same dof may be prescribed more than one 
// time. In this case the resulting prescribed displacement should be the 
// summation of the prescribed values.
// -------------------------------------------------------------------------
//
// virtual void ExtLoadVector( cVector &f )
//
//   f - external load vector                                    ( out )
//
// Evaluates the external load vector corresponding to the total loads,
// e.g. gravity + thermal loads, for small displacement analysis.
// -------------------------------------------------------------------------
//
// virtual void RefLoadVector( cVector &q )
//
//   q - reference load vector                                   ( out )
//
// Evaluates the reference load vector for proportional external loading,
// e.g. gravity loads, for large displacement (geometrically nonlinear)
// analysis.
// -------------------------------------------------------------------------
//
// virtual int IntForceVector( cVector &g )
//
//   g - internal load vector                                    ( out )
//
// Evaluates the internal force vector. Returns (1) for sucess and (0) for
// error.
// -------------------------------------------------------------------------
//
// virtual void StiffnessMatrix( cSysMatrix *K )
//
//   K - global stiffness matrix                                 ( out )
//
// Evaluates the global stiffness matrix of the finite element model.
// -------------------------------------------------------------------------
//
// virtual void GeoStiffnessMatrix( cSysMatrix *Kg )
//
//   Kg - global geometric stiffness matrix                      ( out )
//
// Evaluates the global geometric (initial stress) stiffness matrix of the 
// finite element model.
// -------------------------------------------------------------------------
//
// virtual void PrintResult( double lbd )
//
//   lbd - load factor                                           ( in  )
//
// Prints the results on the output file.
// -------------------------------------------------------------------------
//
// virtual void CalcDSA( double lbd, double **K )
//
//   lbd - load factor                                           ( in  )
//   K   - global stiffness matrix                               ( in  )
//
// Evaluates the design sensitivities of displacements and stresses.
// -------------------------------------------------------------------------
//
// virtual void CalcDSA( double lbd, double **K, double *v )
//
//   lbd - load factor                                           ( in  )
//   K   - global stiffness matrix                               ( in  )
//   v   - buckling mode (eigenvector)                           ( in  )
//
// Evaluates the design sensitivities of the displacements, stresses and
// linear bucking load.
// -------------------------------------------------------------------------
//
// virtual void CalcDSA( double lbd, double **K, double *v, double *p )
//
//   lbd - load factor                                           ( in  )
//   K   - global stiffness matrix                               ( in  )
//   v   - stiffness matrix zero eigenvector                     ( in  )
//   p   - global load vector                                    ( in  )
//
// Evaluates the design sensitivities of the nonlinear critical load.
// -------------------------------------------------------------------------
//
// $Author: evandro $
// $Revision: 1.5 $
// $Date: 2000/04/04 23:21:02 $
// $State: Exp $
//
// -------------------------------------------------------------------------

#ifndef _FEM_H
#define _FEM_H

// -------------------------------------------------------------------------
// Forward declarations:
//
class cNode;
class cMaterial;
class cAnModel;
class cElement;
class cLoadElement;
class cDSA;
class cError;
class cSmooth;
class cVector;
class cSysMatrix;

// -------------------------------------------------------------------------
// Fem types:
//
typedef enum _femtype
{
 MECHANIC
} eFemType;

// -------------------------------------------------------------------------
// Definition an Finite Element Method class:
//
class cFem
{
 protected:
  eFemType       _eType;            // Fem type
  int            _PrintVolume;      // Print mesh volume
  int            _PrintNodDsp;      // Print nodal displacement
  int            _PrintSupRct;      // Print support reactions
  int            _PrintNodScl;      // Print nodal results
  int            _PrintElmScl;      // Print element results
  int            _PrintElmNodScl;   // Print elm.nodal results
  int            _PrintElmGauScl;   // Print elm.gauss results
  int            _iNumEq;           // Total number of equations
  int           *_piProfile;        // Profile vector
  cNode         *_pcNode;           // Node class
  cMaterial     *_pcMat;            // All material data
  cAnModel      *_pcAnM;            // Analysis model
  cElement      *_pcElm;            // Element class
  cLoadElement  *_pcLec;            // Load element class
  cDSA          *_pcDSA;            // Design sensitivity analysis class
  cError        *_pcErr;            // Error estimator class
  cSmooth       *_pcSmooth;         // Smooth procedure Class

 public:
                    cFem                ( void );
  virtual          ~cFem                ( void );
          eFemType  GetType             ( void ) { return _eType;     }
          int      *GetProfile          ( void ) { return _piProfile; }
          int       GetNumEq            ( void ) { return _iNumEq;    }
          cSmooth  *GetSmooth           ( void ) { return _pcSmooth;  }
          cDSA     *GetDSA              ( void ) { return _pcDSA;     }
  virtual void      UpdateState         ( void );
  virtual void      AssignState         ( double * );
  virtual void      AssignState         ( cVector & );
  virtual void      GetDValues          ( double * );
  virtual int       ExistStrainLoads    ( void );
  virtual int       StrainLoadVector    ( cVector &, cVector & );
  virtual double    CalcVol             ( void );
  virtual void      InitValues          ( void ) = 0;
  virtual void      CompEqs             ( void ) = 0;
  virtual void      Profile             ( void ) = 0;
  virtual void      PrscDispVector      ( int *, double  * ) { }
  virtual void      ExtLoadVector       ( cVector & ) { }
  virtual void      RefLoadVector       ( cVector & ) { }
  virtual int       IntForceVector      ( cVector & ) { return 0; }
  virtual void      StiffnessMatrix     ( cSysMatrix * ) { }
  virtual void      GeoStiffnessMatrix  ( cSysMatrix * ) { }
  virtual void      PrintResult         ( double ) { }
  virtual void      CalcDSA             ( double, cSysMatrix * ) { }
  virtual void      CalcDSA             ( double, cSysMatrix *, cVector &){}
  virtual void      CalcDSA             ( double, cSysMatrix *, cVector &, 
                                          cVector & ) { }
  virtual int       GetNumStrainEq      ( void ) { return 0; }
  virtual void      AssemblyStrainVector( double *, double *, double * ) { }

  protected:
  virtual void      ReduceVector        ( double *, double * );
          void      ProcessPrintOptions ( void );
};

#endif

---