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

// -------------------------------------------------------------------------
// Lec.h - This header file contains the public data structure definitions
//         for the Load Element Class mechanism within FEMOOP.
// -------------------------------------------------------------------------
//
// Description:  There are many conceptual operations which are common
//               to all types of loads.  In  FEMOOP, these  types   of 
//               routines are stored in a data structure called a load
//               element "class".   General procedures can  be written 
//               which  will  operate  properly  for all load  element
//               classes currently in the system.
//
// -------------------------------------------------------------------------
//
// $Author: evandro $
// $Revision: 1.4 $
// $Date: 1999/04/12 14:55:42 $
// $State: Exp $
//
// -------------------------------------------------------------------------

#ifndef  _LEC_H
#define  _LEC_H

#include "gbldefs.h"

// -------------------------------------------------------------------------
// Forward declarations:
//
class cNode;
class cElement;
class cShape;
class cIntPt;
class cVector;

//#include "node.h"
//#include "shape.h"
//#include "element.h"

// -------------------------------------------------------------------------
// Load Element types:
//
typedef enum _loadelmtype
{
 FORCE_UNIFORM,                // Uniformely distributed force
 FORCE_LINEAR,                 // Linear distributed force
 FORCE_VARIABLE,               // Variably distributed force
 MOMENT_UNIFORM,               // Uniformely distributed moment
 BEAM_FORCE,                   // Concetrated beam load
 BEAM_UNIFORM,                 // Uniformely distributed load on a beam
 BEAM_LINEAR,                  // Linearly distributed load on a beam
 PLATE_UNIFORM,                // Uniformely distributed load on a plate
 SHELL_UNIFORM,                // Uniformely distributed load on f.f.shell
 SHELL_DOMAIN,                 // Uniform body load on f.f.shell
 DOMAIN_UNIFORM                // Uniformely distributed domain load 
} eLoadElmType;

typedef enum _loaddir
{
 GLOBAL_LOAD,
 LOCAL_LOAD
} eLoadDir;

typedef enum _loadshp
{
 ELEM_LOAD,
 POINT_LOAD,
 LINE_LOAD,
 AREA_LOAD,
 VOLUME_LOAD,
 DOMAIN_LOAD,
 BAR_LOAD,
 PLATE_LOAD,
 SHELL_LOAD,
 SHELL_DOMAIN_LOAD
} eLoadShp;

// -------------------------------------------------------------------------
// Definition of a Load Element Class:
//
class cLoadElement
{
 private:
  static cLoadElement   *LecHead;
         cLoadElement   *next;
         cLoadElement   *prev;

 protected:
  static int             _iNumLoadElem;     // Number of Load Elements
         eLoadElmType    _eType;            // the load element type
         cShape         *_pcShp;            // element shape data
         cIntPt         *_pcIpt;            // numerical integration
         cElement       *_pcElm;            // reference element

 public:
  static  cLoadElement *ReadAll          ( void );
  static  cLoadElement *GetLecHead       ( void ) { return LecHead; }
  static  void          FreeAll          ( void );
  static  int           GetNumLoadElem   ( void ) { return _iNumLoadElem; }
                        cLoadElement     ( void );
  virtual              ~cLoadElement     ( void );
          cLoadElement *GetNext          ( void ) { return next; }
          cElement     *GetElm           ( void ) { return _pcElm; }
          cShape       *GetShp           ( void ) { return _pcShp; }
          void          LocalSys         ( sNatCoord *, double ** );
          void          Assembly         ( double *, double * );
          void          Assembly         ( double *, cVector & );
          void          AddSuppReact     ( double );
          int           ReadElement      ( eLoadShp );
          int           ReadLineShape    ( void );
          int           ReadAreaShape    ( void );
          int           ReadDomainShape  ( void );
          int           ReadElemShape    ( void );
          int           ReadBarShape     ( void );
          int           ReadPlateShape   ( void );
          int           ReadShellShape   ( void );
          int           ReadShellDomain  ( void );
          int           MakeDomainShape  ( int );
  virtual void          EquivForce       ( double, double * );
  virtual void          Free             ( void ) { };
  virtual void          Evaluate         ( sNatCoord *, double * ) { };
  virtual void          LoadVal          ( double[], eLoadDir ) { };
  virtual void          Read             ( void ) = 0;

  virtual void          DsaDerEqForceAm  ( sNodeCoord *, double, double * );

 private:
  static  void ProcessLineForceUniform ( void );
  static  void ProcessLineForceLinear  ( void );
  static  void ProcessLineForceVariable( void );
  static  void ProcessLineMomentUniform( void );
  static  void ProcessBeamForce        ( void );
  static  void ProcessBeamUniform      ( void );
  static  void ProcessBeamLinear       ( void );
  static  void ProcessPlFrameUnif      ( void );
  static  void ProcessPlateUniform     ( void );
  static  void ProcessShellUniform     ( void );
  static  void ProcessShellDomain      ( void );
  static  void ProcessDomainUniform    ( void );
  static  void ProcessAreaUniform      ( void );
};

#endif

---