J:/Tecgraf/prj/femoop/trunk/ipt/intpt.h

// -------------------------------------------------------------------------
// IntPt.h - This header file contains the definition of the Integration
//           Point class.
// -------------------------------------------------------------------------
// Remarks:
// -------------------------------------------------------------------------
//
// In femoop, the integration procedure is performed using this general
// class "intpt" (from INTegration PoinT). The general purpose of the class
// class is to provide the natural coordinates and integration weights of
// the integration points for numerical integration of element vectors and
// matrices.
//
// The following numerical integration techniques have been implemented:
//
// Gauss
//    Gauss over a unidimensional domain
//    Gauss over a triangular domain
//    Gauss over a quadrilateral domain
//    Gauss over a wedge-type domain
//    Gauss over a tetrahedral domain
//    Gauss over a three-dimensional domain
//
// Lobatto
//    Gauss-Lobatto over a unidimensional domain
//    Gauss-Lobatto over a quadrilateral domain
//    Gauss-Lobatto over a three-dimensional domain
//
// Newton-Cotes
//    Newton-Cotes over a unidimensional domain
//    Newton-Cotes over a quadrilateral domain
//    Newton-Cotes over a three-dimensional domain
//
// Mixed (for beams, plates and shells)
//    Gauss in unidimensional and Lobatto through-thickness
//    Gauss in triangle and Lobatto through-thickness
//    Gauss in quadrilateral and Lobatto through-thickness
//
// In Gauss quadrature, "order" means the number of integration points
// on each direction. In Newton-Cotes and Lobatto rules, the number of
// points is the order number plus one; e.g., the 1x1 integration using
// Newton-Cotes and Gauss-Lobatto schemes uses a total number of 4 points.
//
// -------------------------------------------------------------------------
// Main public methods:
// -------------------------------------------------------------------------
//
// void SetNatCoord ( void )
//
// This method evaluates for each integration point its natural coordinates 
// and its integration weight.
//
// -------------------------------------------------------------------------
//
// cIntPt *MakeLst ( eIntType int_type, eDomainType dom_type, sOrder *order,
//                   cElement *pcElm, int iMatLabel )
//
// This static method builds a doubly-linked list of integration points.
// It returns the head of the list.
//
// -------------------------------------------------------------------------
//
// void DestroyLst ( cIntPt* &Head )
//
// This static method kills the doubly-linked list of integration points 
// given its Head.
//
// -------------------------------------------------------------------------
// Methods associated with Material/Constitutive Model:
// -------------------------------------------------------------------------
// 
// There are several methods of this class whose function is only to call
// the associated method of the Material class or of the Constitutive Model
// class. These methods are listed below:
//
// int   NumMatElastParam( void )
// void  MatElastParam   ( double *parameters )
//
// void  InitConstModel  ( void )
// void  UpdateConstModel( void )
// void  ModifyCMatrix   ( double **c_matrix )
// int   GetNumPrintScls ( void )
// void  GetPrintSclLabs ( char **labels )
// void  GetPrintSclVals ( double *str, double *prnval )
//
// For details see the files: "material.h" and "cmodel.h".
// -------------------------------------------------------------------------
//
// $Author: evandro $
// $Revision: 1.2 $
// $Date: 1999/04/12 14:53:48 $
// $State: Exp $
//
// -------------------------------------------------------------------------

#ifndef _INTPT_H
#define _INTPT_H

#include "gbldefs.h"
#include "quadrat.h"

// -------------------------------------------------------------------------
// Forward declarations:
//
class cElement;
class cConstModel;

// -------------------------------------------------------------------------
// Domain types:
//
typedef enum _eDomainType 
{
 LINE_QUADRATURE,            // quadrature over a line domain
 TRIA_QUADRATURE,            // quadrature over a triangular domain
 QUAD_QUADRATURE,            // quadrature over a quadrilateral domain
 QUADS_QUADRATURE,           // idem, for QuadS elements (Petrobras order)
 TETR_QUADRATURE,            // quadrature over a tetrahedral domain
 CUBE_QUADRATURE,            // quadrature over a hexahedral domain
 WEDGE_QUADRATURE,           // quadrature over a wedge domain
 SHELL_QUADRATURE,           // quadrature over a degenerated shell domain
} eDomainType;

// -------------------------------------------------------------------------
// Integration point class:
//
class cIntPt
{
 private:
  static int     _iNumIntPts;   // Mesh number of integration points
         cIntPt *_pcHead;       // Head of this point's intgpnt list
         cIntPt *next;          // Next point
         cIntPt *prev;          // Previous point

 protected:
         eIntType     _eiType;      // Type of quadrature
         eDomainType  _edType;      // Type of domain
         sOrder       _sOrder;      // Integration order
         int          _iNumPts;     // Number of integration points.
         int          _iLabel;      // Integration point label
         sNatCoord    _sCoord;      // Integration point natural coordinates
         double       _dWeight;     // Integration weight
         cConstModel *_pcMod;       // Integration point constitutive model
         cElement    *_pcElm;       // Integration point element

 public:
  static  cIntPt    *MakeLst         ( eIntType, eDomainType, sOrder *, 
                                       cElement * );
  static  cIntPt    *MakeLst         ( int, eDomainType, cElement * );
  static  void       DestroyLst      ( cIntPt *& );
  static  int        GetNumMeshIntPt ( void ) { return _iNumIntPts; }
                     cIntPt          ( cIntPt *&, cElement *, int );
  virtual           ~cIntPt          ( void );
  virtual void       SetNatCoord     ( void ) = 0;
          cIntPt    *GetNext         ( void ) { return next; }
          int        GetNumPts       ( void ) { return _iNumPts; }
          int        GetLabel        ( void ) { return _iLabel; }
          cElement  *GetElementAddr  ( void ) { return _pcElm; }
          sNatCoord  GetCoord        ( void ) { return _sCoord;}
          double     GetWeight       ( void ) { return _dWeight; }
          sOrder     GetOrder        ( void ) { return _sOrder; }

          void       InitConstModel  ( void );
          void       UpdateConstModel( void );
          int        NumMatElastParam( void );
          void       MatElastParam   ( double *  );
          void       ModifyCMatrix   ( double ** );
          int        GetNumPrintScls ( void );
          void       GetPrintSclLabs ( char ** );
          void       GetPrintSclVals ( double *, double * );
          int        Stress          ( double *, double * );
          int        Stress          ( double *, sTensor * );
  virtual int        CheckTRMatrix   ( int, double ** )=0;
};

#endif

---