init.c

有限元程序

static struct {
	char        *name;
	int	     kval;
	} fe_objects[] = {
            "ElementAttr",     ELMT_ATTR,
            "SectionAttr",     SECT_ATTR,
           "MaterialAttr",     MATL_ATTR,
              "FiberAttr",     FIB_ATTR,
           "SetUnitsType",     UNIT,
                   "type",     TYPE,
                "section",     SECTION,
               "material",     MATERIAL,
                  "fiber",     FIBER,
                    "map",     MAP,
                     "to",     TO,
                   "ldof",     LDOF,
                   "gdof",     GDOF,
	       "LinkNode",     LINK_NODE,
		"AddElmt",     ADD_ELMT,
	};

#define NO_OBJECTS (sizeof(fe_objects)/sizeof(fe_objects[0]))

/*
 *  ------------------------------------------------
 *  Adjustable Parameters for Finite Element Problem
 *  ------------------------------------------------
 */

static struct {
	char        *name;
	double 	    value;
	} fe_parameters[] = {
                "NDimension",  (double) UNIT_NDM,
       	       "NDofPerNode",  (double) UNIT_NDF,
        "MaxNodesPerElement",  (double) UNIT_NEN,
           "InPlaneIntegPts",  (double) UNIT_IN_PLANE_INTEG_PTS,
         "ThicknessIntegPts",  (double) UNIT_INTEG_PTS,
             "GaussIntegPts",  (double) UNIT_INTEG_PTS,
        };


#define NO_PARAMETERS (sizeof(fe_parameters)/sizeof(fe_parameters[0]))

/* 
 *  ============================================
 *  Engineering Units : see units.h for details.
 *  ============================================
 */ 

static DIMENSIONS eng_units[] = {

/* LENGTH */         "micron",   1E-6,  1,  0,  0, 0, 0, SI,
                         "mm",   1E-3,  1,  0,  0, 0, 0, SI,
                         "cm",   1E-2,  1,  0,  0, 0, 0, SI,
                         "dm",   1E-1,  1,  0,  0, 0, 0, SI,
                          "m",    1.0,  1,  0,  0, 0, 0, SI,
                         "km",   1E+3,  1,  0,  0, 0, 0, SI,

/* MASS   */              "g",   1E-3,  0,  1,  0, 0, 0, SI,
                         "kg",    1.0,  0,  1,  0, 0, 0, SI,
                         "Mg",   1E+6,  0,  1,  0, 0, 0, SI,

/* TIME   */            "sec",    1.0,  0,  0,  1, 0, 0, SI_US,
                         "ms", 0.0010,  0,  0,  1, 0, 0, SI_US, /* micro sec */
                        "min",   60.0,  0,  0,  1, 0, 0, SI_US,
                         "hr", 3600.0,  0,  0,  1, 0, 0, SI_US, 

/* TEMPERATURE */     "deg_C",    1.0,  0,  0,  0, 1, 0, SI,
                      "DEG_C",    1.0,  0,  0,  0, 1, 0, SI,   /* incr. temp. only */

/* FREQUENCY   */        "Hz",      1.0,  0,  0, -1, 0, 0, SI_US,
/* SPEED       */       "rpm", 1.0/60.0,  0,  0, -1, 0, 0, SI_US,  /* rev per min */
                        "cps",      1.0,  0,  0, -1, 0, 0, SI_US,  /* cycle per sec */

/* FORCE       */         "N",      1.0,  1,  1, -2, 0, 0, SI,
                         "kN",     1E+3,  1,  1, -2, 0, 0, SI,
                        "kgf",  9.80665,  1,  1, -2, 0, 0, SI,

/* PRESSURE    */        "Pa",      1.0, -1,  1, -2, 0, 0, SI,
                        "kPa",     1E+3, -1,  1, -2, 0, 0, SI,
                        "MPa",     1E+6, -1,  1, -2, 0, 0, SI,
                        "GPa",     1E+9, -1,  1, -2, 0, 0, SI,

/* ENERGY      */       "Jou",      1.0,  2,  1, -2, 0, 0, SI,
                         "kJ",     1E+3,  2,  1, -2, 0, 0, SI,

/* POWER       */      "Watt",      1.0,  2,  1, -3, 0, 0, SI,
                         "kW",     1E+3,  2,  1, -3, 0, 0, SI,

/* LENGTH */             "in",      1.0,  1,  0,  0, 0, 0, US,
                        "mil",     1E-3,  1,  0,  0, 0, 0, US,
                   "micro_in",     1E-6,  1,  0,  0, 0, 0, US,
                         "ft",     12.0,  1,  0,  0, 0, 0, US,
                       "yard",     36.0,  1,  0,  0, 0, 0, US,
                       "mile",  63360.0,  1,  0,  0, 0, 0, US,

/* VOLUME */         "gallon",      1.0,  3,  0,  0, 0, 0, US,
                     "barrel",      1.0,  3,  0,  0, 0, 0, US,

/* MASS   */         "lb",          1.0,  0,  1,  0, 0, 0, US,
                  "grain",     1.0/7E+3,  0,  1,  0, 0, 0, US,
                    "ton",         2E+3,  0,  1,  0, 0, 0, US,
                    "klb",         1E+3,  0,  1,  0, 0, 0, US,

/* TEMPERATURE */ "deg_F",          1.0,  0,  0,  0, 1, 0, US,
                  "DEG_F",          1.0,  0,  0,  0, 1, 0, US,/* incre. temp only */

/* FORCE  */        "lbf",          1.0,  1,  1, -2, 0, 0, US,
                   "kips",         1E+3,  1,  1, -2, 0, 0, US,

/* PRESSURE */      "psi",          1.0, -1,  1, -2, 0, 0, US,
                    "ksi",         1E+3, -1,  1, -2, 0, 0, US,

/* PLANE ANGLE */   "deg",   0.01745329,  0,  0,  0, 0, 1, SI_US,
                    "rad",          1.0,  0,  0,  0, 0, 1, SI_US,
};

#define NO_UNITS (sizeof(eng_units)/sizeof(eng_units[0]))

/*
 *  =====================================================
 *  Init_Problem() : Initialize database for symbol table
 *  =====================================================
 */

Init_Problem() {
int            i;
SYMBOL        *s;
int UNITS_SWITCH;

    UNITS_SWITCH = CheckUnits();

    /* Macro Language Keywords and Constants */

    for (i = 0; i < NO_KEYWORDS; i++)
 	build_table(keywords[i].name,  keywords[i].kval, 0.0);

    for (i = 0; i < NO_CONSTANTS; i++) {
	s = build_table(consts[i].name, QUAN, 0.0);

	s->u.q          = (QUANTITY *) MyCalloc(1,sizeof(QUANTITY));
	s->u.q->value   = consts[i].cval;
        if(UNITS_SWITCH==ON) {
           s->u.q->dimen   = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
           ZeroUnits(s->u.q->dimen);
           s->u.q->dimen->units_type = SI_US;
        }
    }

    /* Builtin Quantity Functions */

    for (i = 0; i < NO_BUILTIN_QUANTITY; i++)  {
	s = build_table(builtin_quantity[i].name, BLTIN_QUANTITY, 0.0);
	s->u.quantityptr = builtin_quantity[i].func;
    }

    for (i = 0; i < NO_BUILTIN1_QUANTITY; i++)  {
	s = build_table(builtin1_quantity[i].name, BLTIN1_QUANTITY, 0.0);
	s->u.quantityptr = builtin1_quantity[i].func;
    }

    for (i = 0; i < NO_BUILTIN2_QUANTITY; i++)  {
        s = build_table(builtin2_quantity[i].name, BLTIN2_QUANTITY, 0.0);
        s->u.quantityptr = builtin2_quantity[i].func;
    }

    for (i = 0; i < NO_BUILTIN3_QUANTITY; i++)  {
	s = build_table(builtin3_quantity[i].name, BLTIN3_QUANTITY, 0.0);
	s->u.quantityptr = builtin3_quantity[i].func;
    }

    /* Builtin Matrix Functions */

    for (i = 0; i < NO_BUILTIN_MATRIX; i++)  {
	s = build_table(builtin_matrix[i].name, BLTIN_MATRIX, 0.0);
	s->u.matrixptr = builtin_matrix[i].func;
    }

    for (i = 0; i < NO_BUILTIN1_MATRIX; i++)  {
	s = build_table(builtin1_matrix[i].name, BLTIN1_MATRIX, 0.0);
	s->u.matrixptr = builtin1_matrix[i].func;
    }

    for (i = 0; i < NO_BUILTIN2_MATRIX; i++)  {
       s = build_table(builtin2_matrix[i].name, BLTIN2_MATRIX, 0.0);
       s->u.matrixptr = builtin2_matrix[i].func;
    }

    for (i = 0; i < NO_BUILTIN3_MATRIX; i++)  {
       s = build_table(builtin3_matrix[i].name, BLTIN3_MATRIX, 0.0);
       s->u.matrixptr = builtin3_matrix[i].func;
    }

    for (i = 0; i < NO_BUILTINVar_MATRIX; i++)  {
       s = build_table(builtinvar_matrix[i].name, BLTINVar_MATRIX, 0.0);
       s->u.matrixptr = builtinvar_matrix[i].func;
    }

    /* Engineering Units and Quantities */

    for (i = 0; i < NO_UNITS; i++) {
         if((eng_units[i].units_type != SI_US)        &&
            (eng_units[i].units_type != SI)           &&
            strcmp(eng_units[i].units_name, "deg_C")  &&
            strcmp(eng_units[i].units_name, "deg_F"))
            eng_units[i] = UnitsScaleConvert(eng_units[i], SI);

            s = build_table(eng_units[i].units_name, DIMENSION, 0.0);

	    s->u.q =        (QUANTITY *) MyMalloc(sizeof(QUANTITY));

	    s->u.q->dimen = (DIMENSIONS *)    MyMalloc(sizeof(DIMENSIONS));
	    s->u.q->dimen->units_name   = eng_units[i].units_name;
	    s->u.q->dimen->units_type   = eng_units[i].units_type;
	    s->u.q->dimen->scale_factor = eng_units[i].scale_factor;
	    s->u.q->value               = eng_units[i].scale_factor;
	    s->u.q->dimen->length_expnt = eng_units[i].length_expnt;
	    s->u.q->dimen->mass_expnt   = eng_units[i].mass_expnt;
	    s->u.q->dimen->time_expnt   = eng_units[i].time_expnt;
	    s->u.q->dimen->temp_expnt   = eng_units[i].temp_expnt;
	    s->u.q->dimen->radian_expnt = eng_units[i].radian_expnt;
    }

    /* Finite Element Functions, Objects and Solution Procedures */

    for (i = 0; i < NO_FE_MESH; i++) {
	s = build_table(fe_mesh[i].name, MESH, 0.0);
	s->u.voidptr = fe_mesh[i].func;
    }

    for (i = 0; i < NO_FE_NODE; i++) {
	s = build_table(fe_node[i].name, NODE_QUANT, 0.0);
	s->u.voidptr = fe_node[i].func;
    }

    for (i = 0; i < NO_BLTIN_FE_FUNC; i++) {
	s = build_table(builtin_fe_function[i].name, BLTIN_FE_FUNC, 0.0);
	s->u.voidptr = builtin_fe_function[i].func;
    }

    for (i = 0; i < NO_BLTIN1_FE_FUNC; i++) {
	s = build_table(builtin1_fe_function[i].name, BLTIN1_FE_FUNC, 0.0);
	s->u.voidptr = builtin1_fe_function[i].func;
    }

    for (i = 0; i < NO_OBJECTS; i++) {
        s = build_table(fe_objects[i].name, fe_objects[i].kval, 0.0);
    }

    /* Load Adjustable Parameters for Size of Finite Element Problem */

    for (i = 0; i < NO_PARAMETERS; i++) {
        s = build_table(fe_parameters[i].name, QUAN, 0.0);

        s->u.q =        (QUANTITY *) MyMalloc(sizeof(QUANTITY));
        s->u.q->value               = fe_parameters[i].value;
        if(UNITS_SWITCH==ON) {
           s->u.q->dimen   = (DIMENSIONS *)MyMalloc(sizeof(DIMENSIONS));
           ZeroUnits(s->u.q->dimen);
           s->u.q->dimen->units_type = SI_US;
        }
    }	
}