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

// -------------------------------------------------------------------------
// dsa.h - This header file contains the public data structure definitions
//         for the Design Sensitivity Analysis class within FEMOOP.
// -------------------------------------------------------------------------
// Public methods:
// -------------------------------------------------------------------------
//
// static cDSA *Read(cFem *pcFem)
//
//     pcFem  -  pointer to parent Fem object                       ( in)
//
// This method reads the DSA data from the input file and returns a pointer
// to the created DSA object.
// -------------------------------------------------------------------------
//
// void Evaluate(double lbd, cSysMatrix *K)
//
//     lbd    -  current load factor                                ( in)
//     K      -  current stiffnes matrix                            ( in)
//
// This method evaluates the derivatives of mesh vol., nodal displacements
// and element stresses w.r.t. the nodal coordinates and prints these
// values in the "pos" file.
// -------------------------------------------------------------------------
//
// void Evaluate(double lbd, cSysMatrix *K, cVector &v)
//
//     lbd    -  buckling load factor                               ( in)
//     K      -  global stiffnes matrix                             ( in)
//     v      -  buckling mode                                      ( in)
//
// This method evaluates the derivatives of mesh vol., nodal displacements,
// element stresses and linear bukling load factor w.r.t. the nodal
// coordinates and prints these values in the "pos" file.
// -------------------------------------------------------------------------
//
// void Evaluate(double lbd, cSysMatrix *K, cVector &v, cVector &f)
//
//     lbd    -  critical load factor                               ( in)
//     K      -  current stiffnes matrix                            ( in)
//     v      -  buckling mode (zero eigenvector)                   ( in)
//     f      -  reference load vector                              ( in)
//
// This method evaluates the derivatives of nonlinear critical load factor
// and prints these values in the "pos" file.
// -------------------------------------------------------------------------
// Pure virtual methods:
// -------------------------------------------------------------------------
//
// double DsaVolume(cElement *Elm, int nnode, cNode **node,
//                  sNodeCoord *dcoord)
//
//     elm    -  given element                                      ( in)
//     nnode  -  number of element nodes                            ( in)
//     node   -  element nodes                                      ( in)
//     dcoord -  design velocities (dcoord/dx)                      ( in)
//
// Returns the shape sensitivity of the element volume.
// -------------------------------------------------------------------------
//
// void DsaEqvForce(cLoadElement *lec, int nnode, cNode **node,
//                  sNodeCoord *dcoord, double lf, double *p)
//
//     lec    -  given load element                                 ( in)
//     nnode  -  number of element nodes                            ( in)
//     node   -  element nodes                                      ( in)
//     dcoord -  design velocities (dcoord/dx)                      ( in)
//     lbd    -  load factor                                        ( in)
//     p      -  d{f}/dx                                            (out)
//
// Evaluates the shape sensitivity of the equivalent load vector.
// -------------------------------------------------------------------------
//
//  void DsaIntForce(cElement *elm, int nnode, cNode **node,
//                   sNodeCoord *dcoord, double *p)
//
//     elm    -  given element                                      ( in)
//     nnode  -  number of element nodes                            ( in)
//     node   -  element nodes                                      ( in)
//     dcoord -  design velocities (dcoord/dx)                      ( in)
//     p      -  d{g}/dx                                            (out)
//
// Evaluates the shape sensitivity of the internal force vector.
// -------------------------------------------------------------------------
//
// void DsaStiffMat(cElement *elm, int nnode, cNode **node,
//                  sNodeCoord *dcoord, double *v, double *w)
//
//     elm    -  given element                                      ( in)
//     nnode  -  number of element nodes                            ( in)
//     node   -  element nodes                                      ( in)
//     dcoord -  design velocities (dcoord/dx)                      ( in)
//     v      -  buckling mode                                      ( in)
//     w      -  (d[K]/dx)*{v}                                      (out)
//
// Evaluates the shape sensitivity of the stiffness matrix (d[K]/dx) and
// returns (d[K]/dx)*{v}. Used for critical load sensitivity.
// -------------------------------------------------------------------------
//
// void DsaGeoStiff(cElement *elm, int active, int nnode, cNode **node,
//                  sNodeCoord *dcoord, double *du, double *v, double *w)
//
//     elm    -  given element                                      ( in)
//     active -  flag indicating if dcoord != {0}                   ( in)
//     nnode  -  number of element nodes                            ( in)
//     node   -  element nodes                                      ( in)
//     dcoord -  design velocities (dcoord/dx)                      ( in)
//     du     -  nodal displacements                                ( in)
//     v      -  buckling mode                                      ( in)
//     w      -  (d[K]/dx)*{v}                                      (out)
//
// Evaluates the shape sensitivity of the element geometric stiffness
// matrix (d[K]/dx) and returns (d[K]/dx)*{v}. Used for critical load
// sensitivity.
// -------------------------------------------------------------------------
//
// void DsaStress(cElement *elm, int active, int nnode, cNode **node,
//                sNodeCoord *dcoord, double *du, double **ds)
//
//     elm    -  given element                                      ( in)
//     active -  flag indicating if dcoord != {0}                   ( in)
//     nnode  -  number of element nodes                            ( in)
//     node   -  element nodes                                      ( in)
//     dcoord -  design velocities (dcoord/dx)                      ( in)
//     du     -  nodal displacements                                ( in)
//     ds     -  sensitivity of element stresses                    (out)
//
// Evaluates the shape sensitivity of the element stresses.
// -------------------------------------------------------------------------
//
// $Author: evandro $
// $Revision: 1.7 $
// $Date: 2000/08/21 19:20:55 $
// $State: Exp $
//
// -------------------------------------------------------------------------

#ifndef _DSA_H
#define _DSA_H

#include "gbldefs.h"

// -------------------------------------------------------------------------
// Forward declarations:
//
class cFem;
class cNode;
class cElement;
class cLoadElement;
class cVector;
class cSysMatrix;

// -------------------------------------------------------------------------
// Sensitivity types:
//
typedef enum _dsatype
{
 AM,    // Analytical method
 SAM,   // Semi-Analytical method
 RSAM   // Refined Semi-Analytical method
} eDSAType;

typedef struct _dsanodedir
{
  cNode *node;
  int    dirx;
  int    diry;
  int    dirz;
  int    theta;
  int    phi;
} DSANodeDir;

typedef struct _dsanodedrv
{
  double dx;       // coord x derivative w.r.t. design var
  double dy;       // coord y derivative w.r.t. design var
  double dz;       // coord z derivative w.r.t. design var
  double dtheta;   // vector theta angle derivative w.r.t. design var
  double dphi;     // vector phi angle derivative w.r.t. design var
} DSANodeDrv;

typedef struct _dsatempdrv
{
  double tinf;     // sensitivity of inferior face temperature
  double tsup;     // sensitivity of superior face temperature
} DSATempDrv;

// -------------------------------------------------------------------------
// DSA class:
//
class cDSA
{
 protected:
  static  eDSAType     _eType;        // Method of DSA
  static  int          _iNumVar;      // Number of design variables
  static  int          _iNumKeyNode;  // Number of FE mesh 'key' nodes
  static  int          _iNumSnsNode;  // Number of nodes for stress sensit.
  static  int          _iNumSnsElem;  // Number of elems (stress sensit.)
  static  int          _iNumTempNode; // Number of nodes with temp. derivs.
  static  int          _iDirDerDiff;  // Dir. deriv. diff. (foward/central)
  static  double       _dRelPert;     // Relative perturbation
  static  double       _dDirDerPert;  // Dir. deriv. perturbation
  static  DSANodeDir  *_psKeyNode;    // 'Key' nodes and directions
  static  DSANodeDrv **_psDrvNodeVar; // Nodal coord. deriv. w.r.t des. var.
  static  cNode      **_pcSnsNode;    // Nodes for stress sensitivities
  static  cElement   **_pcSnsElm;     // Elements for stress sensitivities
  static  cNode      **_pcTempNode;   // Nodes with temperature sensit.
  static  DSATempDrv **_psTempDrv;    // Nodal coord. deriv. w.r.t des. var.
  static  cFem        *_pcFem;        // pointer to f.e.model

 public:
  static  cDSA  *Read    (cFem *);
                 cDSA    (void);
  virtual       ~cDSA    (void);
          void   Evaluate(double, cSysMatrix *);
          void   Evaluate(double, cSysMatrix *, cVector &);
          void   Evaluate(double, cSysMatrix *, cVector &, cVector &);

 protected:
  static  void   AssemblyElmList(void);
  static  void   StoreDerDispl  (double *, sNodeDispl *);
  static  void   PrintDerVol    (double *);
  static  void   PrintDerStress (sTensor ***);
  static  void   PrintDerMaxLoad(double *);
  static  void   PrintDerDispl  (cVector *);
  static  void   GetCoordDeriv  (int, int, cNode **, int *, sNodeCoord *);
  static  void   GetTempDeriv   (int, int, cNode **, int *, DSATempDrv *);

          void   EvalDerDispl   (double, cSysMatrix *, cVector *);
          void   EvalPseudoLoad (int, double, cVector &, double *);
          void   EvalDerivStiff (int, cVector &, cVector &);
          double EvalDerBuckLoad(int, double, cVector &, cVector &);
          void   EvalDerStress  (int, cVector &);
          void   EvalDerivStiff (double *, double **);
          void   EvalDirDerVec  (cVector &, cVector &, cVector &,
                                 cVector *, cVector &, cVector *,
                                 cVector &, cVector * );
          void   EvalDirDerVec  (cVector &, cVector &, cVector &,
                                 cVector &);

  virtual double DsaVolume      (cElement *, int, cNode **, sNodeCoord *)=0;
  virtual void   DsaEqvForce    (cLoadElement *, int, cNode **,
                                 sNodeCoord *, double, double *)=0;
  virtual void   DsaIntForce    (cElement *, int, cNode **, sNodeCoord *,
                                 double *)=0;
  virtual void   DsaStiffMat    (cElement *, int, cNode **, sNodeCoord *,
                                 double *, double *)=0;
  virtual void   DsaGeoStiff    (cElement *, int, int, cNode **, sNodeCoord *,
                                 double *, double *, double *)=0;
  virtual void   DsaStress      (cElement *, int, int, cNode **, sNodeCoord *,
                                 double *, double **)=0;
  virtual void   DsaTempIntForce(cElement *, int, cNode **, DSATempDrv *,
                                 double *)=0;
  virtual void   DsaTempStiffMat(cElement *, int, cNode **, DSATempDrv *,
                                 double *, double *)=0;
  virtual void   DsaTempGeoStiff(cElement *, int, cNode **, DSATempDrv *,
                                 double *, double *)=0;
  virtual void   DsaTempStress  (cElement *, int, cNode **, DSATempDrv *,
                                 double **)=0;
};

#endif

---