J:/Tecgraf/prj/femoop/trunk/shp/shape.h

// -------------------------------------------------------------------------
// shape.h - Definition of the base shape class.
// -------------------------------------------------------------------------
// Description:
//
// There are many operations in a FE program which are common to different
// types of elements, such as the computation of shape functions, of shape
// derivatives, and of the Jacobian matrix. In FEMOOP, these tasks are
// performed by the cShape class.
//
// Note that this class is only for procedures which vary between different
// shapes of elements. Specifically, material models ([C] matrices) may be
// common among a number of different elements and have their own methods.
//
// cShape is an abstract class (has pure virtual methods) defining the
// generic behavior (interface) of the different FE shapes. The shapes
// supported by the current implementation is indicated in the definition
// of eShapeType. A simplified scheme of the class hierarchy is:
//
// cShape
// |
// |-- cLine2D => LINE2, LINE3, LINE4
// |   |
// |   |-- cLine3D => LINE2_3D, LINE3_3D, LINE4_3D
// |   |
// |   |-- cLine2DDeg => LINE2_DEG, LINE3_DEG, LINE4_DEG
// |
// |-- cPlaneShape => TRIA3, TRIA6, TRIA10, QUAD4, QUAD8, QUAD9, ...
// |   |
// |   |-- cCurveShape => TRIA3_CRV, TRIA6_CRV, QUAD4_CRV, QUAD8_CRV
// |       |
// |       |-- cCurveShapeDeg => QUAD4_DEG, QUAD8_DEG, QUAD9_DEG, ...
// |
// |-- cSolidShape => BRICK8, BRICK20, TETR4, TETR10, WEDGE6, WEDGE15
//
// The lower classes of this hierarchy implements the specific methods of
// each shape, such as the computation of the shape/map functions (and
// derivatives), while the upper classes implements the methods which are
// independent from the shape connectivity/interpolation, such as the
// computation of the Jacobian matrix and of the shape/map derivatives
// w.r.t. the cartesian coordinates.
//
// The classes cPlaneShape and cSolidShape were designed for use in the
// computation of the stiffness matrix of (iso/sub)parametric elements.
// The class cLine2DDeg was designed to deal with axisymmetric shell
// elements and the class cCurveShapeDeg to deal with free-form shells.
//
// On the other hand, the classes cLine2D/cLine3D were designed for use in
// computation of equivalent loads applied on the edges of plane/solid
// elements, while the class cCurveShape was designed for use in the case
// of loads applied on the faces solid elements.
//
// Both cCurveShape and cCurveShapeDeg represents two-dimensional shapes
// located in the three-dimensional space.
//
// It should be noticed that the multiple inheritance is used to allow the
// curves and degenerated shapes inherit the connectivity related methods
// from the basic shapes (TRIA3, TRIA6, QUAD4, ...) and the other methods
// (Jacobian, DerivXYZ, ...) from cCurveShape/cCurveShapeDeg.
//
// -------------------------------------------------------------------------
// Public methods:
// -------------------------------------------------------------------------
//
// cShape *ShpNew( eShapeType type )
//
//     type  - shape type                                        (  in )
//
// Create a shape object of the given type.
//
// -------------------------------------------------------------------------
//
// int NumMapNodes( void )
//
// Returns the number of nodes in element shape used to interpolate (map)
// its geometry.
//
// -------------------------------------------------------------------------
//
// int NumShpNodes( void )
//
// Returns the number of nodes used  by shape interpolation functions.
//
// -------------------------------------------------------------------------
//
// int NumPolTerms( void )
//
// Returns the number of polynomial terms used in SPR method.
//
// -------------------------------------------------------------------------
//
// void GetShapeType( ShapeType *s_type )
//
//      s_type     -  type of given element shape                ( out )
//
// This routine  attempts  to  determine  the type of the given
// element shape.
//
// -------------------------------------------------------------------------
//
// void GetDomain( eShapeType *type, int *num_nodes, int *connect )
//
//      type       -  returned domain shape type                 ( out )
//      num_nodes  -  number domain nodes                        ( out )
//      connect    -  domain connectivity                        ( out )
//
// Gets shape type, no. of nodes, and connectivity of given shape.
//
// -------------------------------------------------------------------------
//
// void IntDomainType( eDomainType *domain )
//
//      domain     -  returned integration domain type           ( out )
//
// Returns the integration domain type which is consistent with
// this element shape.
//
// -------------------------------------------------------------------------
//
// void NodalCoord( NodeCoord *coord )
//
//      coords      -   Cartesian coordinates of its nodes       ( out )
//
// Returns shape nodal coordinates.
//
// -------------------------------------------------------------------------
//
// void MaxSizes( double *dx, double *dy, double *dz )
//
//      dx         -   length in x axis                          ( out )
//      dy         -   length in y axis                          ( out )
//      dz         -   length in z axis                          ( out )
//
// Returns the bounding box of the element.
//
// -------------------------------------------------------------------------
//
// int GetShpNodeIdx( int id )
//
//      id        -    node identifier                           (  in )
//
// Returns the local index of a given node. If the node doesn't belongs to
// element then it returns (-1).
//
// -------------------------------------------------------------------------
//
// int VerShpNode( int id )
//
//      id        -    node identifier                           (  in )
//
// Returns (1) if the node belongs to the element and (0) otherwise.
//
// -------------------------------------------------------------------------
//
// void Make( int *connect )
//
//      connect  -  connectivity of the given element            (  in )
//
// Makes an element shape of given connectivity.
//
// -------------------------------------------------------------------------
//
// void RecoverPatchNodes( cNode *PatchNode,
//                         int   *iNumRecNodes,
//                         int   *vRecNodes )
//
//      PacthNode    - given patch node                           (  in )
//      iNumRecNodes - number of recovery nodes                ( in/out )
//      vRecNodes    - vector of recovery nodes                ( in/out )
//
// Adds the nodes of this shape that belongs to the patch of the given
// PatchNode to the vector of recovery nodes.
//
// -------------------------------------------------------------------------
//
//  Here follows a generic description of the virtual methods:
//
// ------------------------------ methods ----------------------------------
//
//  Read          - read the shape connectivity
//  Connectivity  - returns the shape connectivity
//  GetDimShape   - returns the shape dimension (1 = line,2 = plane/surface
//                  or 3 = solid).
//  GetMapOrder   - returns the order (1,2 or 3) of the geometry
//                  interpolation.
//  ShapeFunc     - returns the shape interpolation functions
//                  evaluated at a given point in local coordinates.
//  MapFunc       - returns the geometric interpolation functions
//                  evaluated at a given point in local coordinates.
//  NMatrix       - mounts the shape function matrix, given (from outside)
//                  the number of dof's per node.
//  DerivMapRST   - returns the derivatives of interpolation functions
//                  at geometric nodes in local coordinate system.
//  DerivShpRST   - returns the derivatives of interpolation functions
//                  at shape nodes in local coordinate system.
//  GetEdge       - get shape type, no. of nodes, and connectivity of an
//                  edge of given shape for a given pair of corner nodes.
//  GetFace       - get shape type, no. of nodes, and connectivity of a
//                  face of given shape for a given pair of corner nodes and
//                  a third node defining the face normal direction.
//  PolFunc       - returns the polynomial functions (used in SPR method)
//                  evaluated at a given point in cartesian coordinates.
//  VerCorNode    - returns (TRUE) if the given node is a corner node of
//                  this shape and (FALSE) otherwise.
//  VerEdgeNode   - returns (TRUE) if the given node is an edge node of
//                  the given corner node and (FALSE) otherwise.
//  Jacobian      - returns the Jacobian matrix, its inverse  and  its
//                  determinant.
//  DerivXYZ      - returns the derivatives of interpolation functions
//                  at shape nodes in global coordinate system.
//  LocalSys      - get rotation matrix of local system w.r.t. global axes
//                  at a given point given by its parametric coordinates.
//  GetTangent    - evaluates the tangent vector(s) in a given point.
//                  Returns tangent vector(s) and their moduli.
//  DsaDerivXYZ   - returns the sensitivities of the derivatives of
//                  interpolation functions at shape nodes in global
//                  coordinate system (dNi,x; dNi,y; dNi,z)
//  VerifyQtP     - returns 1 if the element is a Quarter-Point element
//                  (fracture mechanics), zero otherwise.
//
// -------------------------------------------------------------------------
//
// $Author: evandro $
// $Revision: 1.3 $
// $Date: 1999/04/12 14:58:25 $
// $State: Exp $
//
// -------------------------------------------------------------------------

#ifndef _SHAPE_H
#define _SHAPE_H

#include "gbldefs.h"
#include "intpt.h"

// ------------------------------------------------------------------------
// Forward declarations:
//
class cNode;

// ------------------------------------------------------------------------
// (Finite) Element Shape types:
//
typedef enum _shapetype
{
  UNDEFINED = -1,
  LINE2,          // 2-noded line (XY plane)
  LINE3,          // 3-noded line (XY plane)
  LINE4,          // 4-noded line (XY plane)
  HERMITE,        // 2-noded hermitian beam
  HERMITE_PLANE,  // 2-noded in-plane hermitian interpolation
  TRIA3,          // 3-noded triangle
  TRIA6,          // 6-noded triangle
  TRIA10,         // 10-noded triangle
  QUAD4,          // 4-noded quadrilateral
  QUAD5,          // 5-noded quadrilateral
  QUAD6,          // 6-noded quadrilateral subparametric
  QUAD6B,         // 6-noded quadrilateral isoparametric
  QUAD8,          // 8-noded quadrilateral
  QUAD9,          // 9-noded Lagrangean quadrilateral
  QUAD9H,         // 9-noded hierarchical serendipity quadrilateral
  QUADS,          // Gerenal Serendipity quadratic quadrilateral
  QUAD12,         // 12-noded Serendipity cubic quadrilateral
  QUAD13,         // 13-noded Serendipity cubic quadrilateral
  QUAD16,         // 16-noded Lagrangean cubic quadrilateral
  INFINITE,       // 4-noded Lagrangean infinite
  INFL4,          // 4-noded Lagrangean infinite
  INFS3,          // 3-noded Serendipity infinite
  INFS5,          // 5-noded Serendipity infinite
  BRICK8,         // 8-noded brick
  BRICK20,        // 20-noded brick
  TETR4,          // 4-noded tetrahedron
  TETR10,         // 10-noded tetrahedron
  WEDGE6,         // 6-noded wedge
  WEDGE15,        // 15-noded Serendipity wedge
  BAR,            // 2-node line shape for beam and truss
  LINE2_3D,       // 2-noded line (solid edge used by Lec)
  LINE3_3D,       // 3-noded line (solid edge used by Lec)
  LINE4_3D,       // 4-noded line (solid edge used by Lec)
  TRIA3_CRV,      // 3-noded triangle (solid face used by Lec)
  TRIA6_CRV,      // 6-noded triangle (solid face used by Lec)
  QUAD4_CRV,      // 4-noded quadrilateral (solid face used by Lec)
  QUAD8_CRV,      // 8-noded quadrilateral (solid face used by Lec)
  LINE2_DEG,      // degenerated 2-node line shape ( shells )
  LINE3_DEG,      // degenerated 3-node line shape
  LINE4_DEG,      // degenerated 4-node line shape
  QUAD4_DEG,      // degenerated 4-node curved area shape
  QUAD8_DEG,      // degenerated 8-node curved area shape
  QUAD9_DEG,      // degenerated 9-node curved area shape
  QUAD9H_DEG,     // degenerated 9-node hierarchical curved area shape
  QUAD12_DEG,     // degenerated 12-node curved area shape
  QUAD16_DEG      // degenerated 16-node curved area shape

} eShapeType;

// -------------------------------------------------------------------------
// Base (Finite) Element Shape class:
//
class cShape
{
 protected:
  static double  _J[3][3];           // Jacobian matrix
  static double  _iJ[3][3];          // Inverse of Jacobian matrix
  static double  _dJ[3][3];          // Sensitivity of Jacobian matrix
  static double  _L[3][3];           // [L] = [iJ]*[dJ]

 protected:
  eShapeType    _eType;              // Shape type
  eDomainType   _eDomainType;        // Integration domain type
  int           _iNumShpNodes;       // Number of Shape Nodes
  int           _iNumMapNodes;       // Number of Map Nodes
  int           _iNumPolTerms;       // Number of Complete Polynomial Terms
  int           _iNumSupPolTerms;    // N. of Superior Polynomial Terms
  int          *_aiNode;             // Element node indices
  cNode       **_apcNode;            // Element node pointers
 public:
  static cShape *ShpNew            ( eShapeType );
                cShape             ( void );
  virtual      ~cShape             ( void );
          int   NumMapNodes        ( void ) { return _iNumMapNodes; }
          int   NumShpNodes        ( void ) { return _iNumShpNodes; }
          int   NumPolTerms        ( void ) { return _iNumPolTerms; }
          int   NumSupPolTerms     ( void ) { return _iNumSupPolTerms; }
          int   GetConnId          ( int k ){ return _aiNode[k]; }
          cNode *GetConnNode       ( int k ){ return _apcNode[k]; }
          void  GetShapeType       ( eShapeType * );
          void  GetDomain          ( eShapeType *, int *, int * );
          void  IntDomainType      ( eDomainType * );
          void  NodalCoord         ( sNodeCoord * );
          void  MaxSizes           ( double *, double *, double * );
          int   GetShpNodeIdx      ( int );
          int   VerShpNode         ( int );
          void  Make               ( int * );
          void  RecoverPatchNodes  ( cNode *, int *, int * );
  virtual int   Read               ( void );
  virtual void  Connectivity       ( int * );
  virtual void  Connectivity       ( cNode ** );
  virtual void  NMatrix            ( int, sNatCoord *, double *, double *,
                                     sDerivNat *, double, double **);
  virtual int   GetDimShape        ( void )=0;
  virtual int   GetMapOrder        ( void )=0;
  virtual void  Jacobian           ( sNatCoord *, sNodeCoord *, double *,
                                     sDerivNat *, double *, double *,
                                     double **, double ** ){ }
  virtual void  Jacobian           ( sDerivNat *, double *, sNodeCoord *,
                                     double *, double **, double ** ) = 0;
  virtual void  DerivXYZ           ( double **,sDerivNat *,sDerivCart * )=0;
  virtual void  LocalSys           ( sDerivNat *, sNodeCoord *, double**)=0;
  virtual void  MapFunc            ( sNatCoord *, double * )=0;
  virtual void  ShapeFunc          ( sNatCoord *, double * )=0;
  virtual void  DerivMapRST        ( sNatCoord *, sDerivNat * )=0;
  virtual void  DerivShpRST        ( sNatCoord *, sDerivNat * )=0;
  virtual int   GetEdge            ( int *, eShapeType *, int *, int * )=0;
  virtual int   GetFace            ( int *, eShapeType *, int *, int * )=0;
  virtual void  GetNatCoordMapNode ( sNatCoord * )=0;
  virtual void  PolFunc            ( sNodeCoord *, double * ) { }
  virtual void  DerivPolFunc       ( sNodeCoord *, sDerivCart * ) { }
  virtual void  SupPolFunc         ( sNodeCoord *, double * ) { }
  virtual void  DerivSupPolFunc    ( sNodeCoord *, sDerivCart * ) { }
  virtual int   VerCorNode         ( int ) { return 0; }
  virtual int   VerEdgeNode        ( int, int ) { return 0; }
  virtual int   VerifyQtP          ( void ) { return 0; }
  virtual void  GetTangent         ( sNodeCoord *, sDerivNat *, sVector *,
                                     double *) { }

  virtual void  DsaDerivXYZ        ( sNodeCoord *, sDerivNat *, sDerivNat *,
                                     double *, sDerivCart *, sNodeCoord *,
                                     double *, sDerivCart *) { }
};

// -------------------------------------------------------------------------
// Mathematical functions:
//
void ShpMatZero(int n, double A[3][3]);
int  ShpMatInv (int n, double A[3][3], double B[3][3], double *det);
void ShpMatMult(int n, double A[3][3], double B[3][3], double C[3][3]);

#endif

---