fe_allocate.c

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

int  i,j,k, el_attr_no;

int       UNITS_SWITCH;
int      iNO_INTEG_pts;
int   iInPlaneIntegPts;
int iThicknessIntegPts;

#ifdef DEBUG
       printf("*** Enter FrameAlloc()\n");
#endif

     UNITS_SWITCH = CheckUnits();

    /* --------------------------------------------- */
    /* Allocate and initialize EFRAME data structure */
    /* --------------------------------------------- */

    frp = (EFRAME *) MyCalloc(1,sizeof(EFRAME));

    sp = lookup("NDimension");         /* No of dimensions : 2 or 3 */
    frp->no_dimen = (int) sp->u.q->value;

    sp = lookup("NDofPerNode");        /* No gdof per node */
    frp->no_dof = (int) sp->u.q->value;

    sp = lookup("MaxNodesPerElement"); /* Max no nodes per element */
    frp->no_nodes_per_elmt = (int) sp->u.q->value;

    sp = lookup("InPlaneIntegPts");   /* number of integration pts in plane/surface      */
    if(sp == NULL) 
       iInPlaneIntegPts = 2*2;        /* 2x2 as default */
    else
       iInPlaneIntegPts = (int) sp->u.q->value;

    sp = lookup("ThicknessIntegPts"); /* number of integration pts in thickness direction*/
    if(sp == NULL) 
       iThicknessIntegPts = 2;        /* 2 as default */
    else
       iThicknessIntegPts = (int) sp->u.q->value;

    /* ---------------------------------------------- */
    /* Allocate Pointers to component data structures */
    /* ---------------------------------------------- */

    frp->node      = (NODE *)    MyCalloc( UNIT_NODES,    sizeof(NODE));
    frp->element   = (ELEMENT *) MyCalloc( UNIT_ELEMENTS, sizeof(ELEMENT));
    frp->eattr     = (ELEMENT_ATTR *) MyCalloc(UNIT_ELEMENT_ATTR, sizeof(ELEMENT_ATTR));
    frp->rigid     = (RIGID *) MyCalloc( UNIT_RIGIDS,   sizeof(RIGID));
    frp->jdiag     = (int *)   MyCalloc((UNIT_NODES * UNIT_NDF), sizeof(int));
    frp->nforces   = (NODE_LOADS *) MyCalloc( UNIT_NFORCES, sizeof(NODE_LOADS));
    frp->eforces   = (ELEMENT_LOADS *) MyCalloc( UNIT_ELEMENTS, sizeof(ELEMENT_LOADS));

    /* ----------------------------------------------------- */
    /* Allocation of Arrays within Component Data Structures */ 
    /* ----------------------------------------------------- */

    for(i=1; i <= UNIT_NODES; i++) {

        np = &frp->node[i-1];
        np->coord = (QUANTITY *) MyCalloc(frp->no_dimen, sizeof(QUANTITY));
        if( UNITS_SWITCH == ON ) {
           for(j = 1; j <= frp->no_dimen; j++){
              np->coord[j-1].dimen    =(DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
           }
        }

        np->bound_id = (int *) MyCalloc(frp->no_dof, sizeof(int));
        np->rb_num   = (int ) 0;

        np->disp     = (QUANTITY *) MyCalloc(frp->no_dof, sizeof(QUANTITY));
        if( UNITS_SWITCH == ON ) {
           for (j = 1; j <= frp->no_dof; j++) {
              np->disp[j-1].dimen  = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
           }
        }

        np->TrT = (MATRIX *) MyCalloc(1,sizeof(MATRIX));
    }

    iNO_INTEG_pts = iThicknessIntegPts*iInPlaneIntegPts;

    for(i=1; i<= UNIT_ELEMENTS; i++) {

        ep                 = &frp->element[i-1];
        ep->elmt_attr_name = (char *) NULL;
        ep->elmt_attr_no   = (int) 0;
        ep->node_connect   = (int  *) MyCalloc((frp->no_nodes_per_elmt+1),sizeof(int));
        ep->d_array        = (int  *) MyCalloc(frp->no_nodes_per_elmt, sizeof(int));
        ep->rp             = (RESPONSE *) MyCalloc(1,sizeof(RESPONSE));
        ep->esp            = (ELEMENT_STATE *) MyCalloc(1,sizeof(ELEMENT_STATE));
        ep->esp->state     = (int) 0;

        ep->LC_ptr         = (MATER_LOAD_CURVE *) MyCalloc(1,sizeof(MATER_LOAD_CURVE));
        ep->LC_ptr->name   = (char *) NULL;
        ep->LC_ptr->R      = (double *) MyCalloc(iNO_INTEG_pts,sizeof(double));
        ep->LC_ptr->H      = (double *) MyCalloc(iNO_INTEG_pts,sizeof(double));
        ep->LC_ptr->back_stress = MatrixAllocIndirectDouble(6, iNO_INTEG_pts);

        ep->rp->Forces     = MatrixAllocIndirect("nodal_force",DOUBLE_ARRAY,frp->no_dof,UNIT_NODES);

        ep->rp->displ     = MatrixAllocIndirect("displ", DOUBLE_ARRAY, frp->no_dof, UNIT_NODES);
        ep->rp->stress    = MatrixAllocIndirect("stress", DOUBLE_ARRAY,9,iNO_INTEG_pts);
        ep->rp->strain_pl = MatrixAllocIndirect("strain_pl",DOUBLE_ARRAY,9,iNO_INTEG_pts);
        ep->rp->strain_pl_incr     = MatrixAllocIndirect("strain_pl_incr",DOUBLE_ARRAY,9,iNO_INTEG_pts);
        ep->rp->effect_pl_strain   = (double *) MyCalloc(iNO_INTEG_pts, sizeof(double));
        ep->rp->eff_pl_strain_incr = (double *) MyCalloc(iNO_INTEG_pts, sizeof(double));

        if(UNITS_SWITCH == ON) {
           ep->rp->min_moment.dimen  = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
           ep->rp->max_moment.dimen  = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
           ep->rp->min_shear.dimen   = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
           ep->rp->max_shear.dimen   = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
           ep->rp->Mzc.dimen         = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
        }
    }

    for(i=1; i<= UNIT_ELEMENT_ATTR; i++) {

        eap                   = &frp->eattr[i-1];
        eap->name             = (char *) NULL;
        eap->elmt_type        = (char *) NULL;
        eap->map_ldof_to_gdof = (int  *) MyCalloc(6,sizeof(int));
        eap->material         = (char *) NULL;
        eap->section          = (char *) NULL;
        eap->work_material    = (QUANTITY *) MyCalloc(UNIT_MATERIAL_ATTR,sizeof(QUANTITY)); 
        eap->work_section     = (QUANTITY *) MyCalloc(UNIT_SECTION_ATTR,sizeof(QUANTITY));

        if( UNITS_SWITCH == ON ) {
           for(j = 1; j <= UNIT_MATERIAL_ATTR; j++) {
              eap->work_material[j-1].dimen = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
              ZeroUnits(eap->work_material[j-1].dimen);
           }
           for(j = 1; j <= UNIT_SECTION_ATTR; j++) {
              eap->work_section[j-1].dimen = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
              ZeroUnits(eap->work_section[j-1].dimen);
           }
        }
    }

   /* In the following: 10 is arbitrary and is subjected to change*/
    for(i=1; i <= UNIT_RIGIDS;i++) {
        rig                  = &frp->rigid[i-1];
        rig->rbody_attr_name = (char *) NULL;
        rig->in              = (int *) MyCalloc(10, sizeof(int)); 
        rig->rest_dof        = (int *) MyCalloc(6, sizeof(int));
        rig->per_nodes       = (int *) MyCalloc(10, sizeof(int));
        rig->prop            = (QUANTITY *) MyCalloc(10, sizeof(QUANTITY));  
        if( UNITS_SWITCH == ON ) {
           for(j = 1; j <= 10; j++) 
              rig->prop[j-1].dimen = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
        }
    }
    for(i=1; i <= UNIT_ELEMENTS; i++) {
        elsp                       = &frp->eforces[i-1];
        elsp->no_loads_faces       = 1;                        
        elsp->face_direc           = (double *) MyCalloc(frp->no_dimen, sizeof(double));
        elsp->elib_ptr             = (ELOAD_LIB *) MyCalloc(UNIT_NODES, sizeof(ELOAD_LIB));
        elsp->elib_ptr->name       = (char *) NULL;
        elsp->elib_ptr->nopl       = (int *) MyCalloc(4, sizeof(int));
        elsp->elib_ptr->pr         = (MATRIX *) MyCalloc(1,sizeof(MATRIX));
        elsp->elib_ptr->face_no           = (int) 0;
        elsp->elib_ptr->numnp_face        = (int) 0;
        elsp->elib_ptr->pr->iNoRows       = 4;
        elsp->elib_ptr->pr->iNoColumns    = 3;
        elsp->elib_ptr->pr->cpMatrixName  = (char *)NULL;
        if( UNITS_SWITCH == ON ) {
            elsp->elib_ptr->pr->spRowUnits = BufferInit(4);
            elsp->elib_ptr->pr->spColUnits = BufferInit(3);
        }
    }

    for(i=1; i <= UNIT_NODES; i++) {
       elp                       = &elsp->elib_ptr[i-1];
       elp->body_force           = (QUANTITY *) MyCalloc(frp->no_dimen, sizeof(QUANTITY));
       elp->init_stress          = (QUANTITY *) MyCalloc(frp->no_dimen, sizeof (QUANTITY));
       elp->init_strain          = (double *) MyCalloc(frp->no_dimen, sizeof (double));
       elp->traction             = (QUANTITY *) MyCalloc(frp->no_dimen, sizeof(QUANTITY));
       if( UNITS_SWITCH == ON ) {
          for(j = 1; j <= frp->no_dimen; j++) {
              elp->body_force[j-1].dimen  = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
          }
          for(j = 1; j <= frp->no_dimen; j++) {
              elp->init_stress[j-1].dimen  = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
          }
          for(j = 1; j <= frp->no_dimen; j++) {
              elp->traction[j-1].dimen  = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
          }
       }
    }

    for (i=1; i <= UNIT_NFORCES; i++) {
       nlp         = &frp->nforces[i-1];
       nlp->fn     = (QUANTITY *) MyCalloc(frp->no_dof, sizeof(QUANTITY));
       nlp->node_f = (int) 0; 
       if( UNITS_SWITCH == ON ) {
          for(j = 1; j <= frp->no_dof; j++) {
             nlp->fn[j-1].dimen  = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
          }
       }
    }

    /*------------------------------------------------------*/
    /* Assignment of max_no_ parameters for CheckSpace()    */
    /*------------------------------------------------------*/

    max_no_nodes        = UNIT_NODES;
    max_no_elements     = UNIT_ELEMENTS;
    max_no_nforces      = UNIT_NFORCES;
    max_no_loaded_elmts = UNIT_EFORCES;
    max_no_rigid        = UNIT_RIGIDS;
    max_no_eqs          = UNIT_NODES * UNIT_NDF;

#ifdef DEBUG
       printf("*** Leave FrameAlloc()\n\n");
#endif

    return(frp);
}