fe_database.h

利用语言编写的有限元分析软件

/*
 *  ============================================================================= 
 *  ALADDIN Version 1.0 :
 *        fe_database.h : Database for Finite Element Machine
 *                                                                     
 *  Copyright (C) 1995 by Mark Austin, Xiaoguang Chen, and Wane-Jang Lin
 *  Institute for Systems Research,                                           
 *  University of Maryland, College Park, MD 20742                                   
 *                                                                     
 *  This software is provided "as is" without express or implied warranty.
 *  Permission is granted to use this software for any on any computer system
 *  and to redistribute it freely, subject to the following restrictions:
 * 
 *  1. The authors are not responsible for the consequences of use of
 *     this software, even if they arise from defects in the software.
 *  2. The origin of this software must not be misrepresented, either
 *     by explicit claim or by omission.
 *  3. Altered versions must be plainly marked as such, and must not
 *     be misrepresented as being the original software.
 *  4. This notice is to remain intact.
 *                                                                    
 *  Written by: Mark Austin, Xiaoguang Chen, and Wane-Jang Lin      December 1995
 *  ============================================================================= 
 */

#ifndef FE_DATABASE_H
#define FE_DATABASE_H

typedef struct element_response {
     MATRIX                 *Forces;
     MATRIX                 *stress;
     MATRIX                  *displ; 
     MATRIX              *strain_pl;
     MATRIX         *strain_pl_incr;
     double       *effect_pl_strain;
     double     *eff_pl_strain_incr;
     QUANTITY            min_moment;
     QUANTITY       max_moment, Mzc;
     QUANTITY  min_shear, max_shear;
     MATRIX     *Q_saved,  *q_saved;
     MATRIX  	*sr_saved, *er_saved;    /* matrix[no_integ_pt][ifib] */
     MATRIX     *s0_saved, *e0_saved;
     MATRIX  	*sx_saved, *ex_saved;
} RESPONSE;

typedef struct mater_load_curve {
   char                  *name;   /* load curve type                       */
   double                   *R;   /* radius of yield surface               */
   double        **back_stress;   /* back stress vector                    */
   double                   *H;   /* tangent of stress-plastic strain curve*/
   double                alpha;   /* parameter for Ramberg-Osgood relation */
   double                    n;   /* strain hardening exponent             */
   double                 beta;   /* parameter for strain hardening        */
                                  /* beta = 0 kinematic hardening          */
                                  /* beta = 1 isotropic hardening          */
   /*  variables defined for elmt_shell_4n_q  */
   int                   ialph;   /* Rotation constant ; 0=none, 1=hughes  */
   double                  pen;   /* Penalty constant                      */
   double              load[6];   /* Loading parameters, per unit area     */
                                  /* [0]: uniform loading in 1-direction   */
                                  /* [1]: uniform loading in 2-direction   */
                                  /* [2]: pressure loading normal to shell */
                                  /* [3]: gravity loading in x-direction   */
                                  /* [4]: gravity loading in y-direction   */
                                  /* [5]: gravity loading in z-direction   */
} MATER_LOAD_CURVE;

/*
 * ------------------
 * Nodes and Elements  
 * ------------------
 */

typedef struct node {
        QUANTITY       *coord;     /* Coordinates of node            */
        int            *bound_id;  /* Boundary Constratint ID        */
        int             rb_num;    /* component of rigid body number */
        QUANTITY       *disp;
        MATRIX         *TrT;
} NODE;

typedef struct element_state {
        int             state; /* state = 1    elastic-plastic deformation */
                               /* state = 0    elastic deformation         */
	int	**yielding_saved, **pre_range_saved, **pre_load_saved;

} ELEMENT_STATE;

typedef struct element {
        char     *elmt_attr_name;  /* Elmt_Attr name                      */
        int        *node_connect;  /* List of Nodal Connectivities        */
	int         elmt_attr_no;  /* Elmt Attribute No (stored in frame) */
        int             *d_array;  /* Destination array storage           */
        RESPONSE             *rp;  /* Response Pointer                    */
        ELEMENT_STATE       *esp;  /* Deformation State of the Element    */
        MATER_LOAD_CURVE *LC_ptr;  /* properties for describe yield       */
                                   /* surface and stress-strain curve     */

} ELEMENT;

/*
 *  ------------------------------- 
 *  Data Structure For Rigid Bodies 
 *  ------------------------------- 
 */

typedef struct rigid {
        char       *rbody_attr_name;  /* Specified Rbody_Attr name              */
        int              nodes_conn;  /* number of nodes connected              */
        int                 rb_type;  /* assigned aelmt type                    */
        int                     *in;  /* node numbers connected by rigid body   */
	int              *per_nodes;  /* list of perimeter nodes                */
        int               *rest_dof;  /* array of dofs: 1/o-dof un-/ restricted */
        QUANTITY      xcg, ycg, zcg;  /* coordinates of c.g. of rigid body      */
        QUANTITY              *prop;  /* properties input for rigid body        */
} RIGID;


/*
 *  -----------------------------------------------------------------------
 *  Working Arrays for Element, Material and Section Attributes 
 * 
 *  Note : MATERIAL and SECTION Attributes only stored in Symbol Table.
 *       : ELEMENT_ATTR is stored in symbol table and frame data structure.
 *       : Space for "double *d" only used when attached to frame. 
 *  -----------------------------------------------------------------------
 */

typedef struct fiber_attr {
	QUANTITY	y, z;
	QUANTITY	area;
	QUANTITY	Es, Et, fy;
} FIBER_ATTR;

typedef struct fiber_elmt {
	int		no_fiber;
	FIBER_ATTR      *fiber;   /* Array of fibers for all fiber properties */
}FIBER_ELMT;

typedef struct elmt_attr {
        char                    *name;
        char               *elmt_type;
        char                *material;
        char                 *section;
        char         *fiber_attr_name;
        int         *map_ldof_to_gdof;
        QUANTITY       *work_material;   /* Working Array for Material Properties    */
        QUANTITY        *work_section;   /* Working Array for Section  Properties    */
	FIBER_ELMT        *work_fiber;
} ELEMENT_ATTR;
                                         /* notes :                                  */
                                         /* For given elmement No, element property  */
                                         /* can be recalled from these two working   */
                                         /* arraries instead of looking up hashing   */
                                         /* table                                    */

typedef struct section_attr {
        char *section_name;
        int   section_type; 
        QUANTITY      Ixx;           /* [0] */
        QUANTITY      Iyy;           /* [1] */
        QUANTITY      Izz;           /* [2] */
        QUANTITY      Ixz;           /* [3] */