fe_profile.c

有限元分析源代码

       printf("Enter Assign_p_Array() : elmt = %4d : task = %4d\n", elmt_no, task);
#endif

   UNITS_SWITCH = CheckUnits();

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

   slp = lookup("ThicknessIntegPts"); /* number of integration pts in thickness direction*/

   if(slp == NULL){
      iThicknessIntegPts = UNIT_INTEG_PTS; /* 2 as default */
   }
   else {
      iThicknessIntegPts = (int) slp->u.q->value;
   }

   iNO_INTEG_pts = iInPlaneIntegPts*iThicknessIntegPts;

   slp = lookup("GaussIntegPts"); /* number of integration pts in thickness direction*/
   if(slp == NULL){
      p->integ_ptr->integ_pts = UNIT_INTEG_PTS; /* 2 as default */
   }
   else {
      p->integ_ptr->integ_pts = (int) slp->u.q->value;
   }

   el              = &frp->element[elmt_no-1];  /* element ptr               */
   elmt_attr_no    =  el->elmt_attr_no;
   eap             = &frp->eattr[elmt_attr_no -1]; 
   p->elmt_state   =  el->esp->state;

   for (i = 0; i <= NO_ELEMENTS_IN_LIBRARY; i++) { 
      if(!strcmp(elmt_library[i].name, eap->elmt_type)) { 
           n = i;
           break;
      }
   }

   if(task != PROPTY) {
      if(p->elmt_no != elmt_no) { /* check if already values assigned */
         p->elmt_no        =  elmt_no;
         p->elmt_attr_no   =  elmt_attr_no;
         p->dof_per_node   =  elmt_library[n].no_dof;
         p->no_dimen       =  elmt_library[n].no_dimen;
         p->elmt_type      =  elmt_library[n].name;
         p->nodes_per_elmt = (int) MIN(frp->no_nodes_per_elmt,
                                       elmt_library[n].no_node_per_elmt);
         p->size_of_stiff  =  p->nodes_per_elmt* p->dof_per_node;

         free((char *) p->material_name);
         p->material_name = SaveString( frp->eattr[elmt_attr_no-1].material );

         /* p->work_section[] = working arrary of section properties for element */
         /* p->work_material[] = working arrary of material properties for element */

         for(i = 1; i <= UNIT_MATERIAL_ATTR; i++) {  
             if( eap->work_material[i-1].value != 0 ) {
                 p->work_material[i-1].value = eap->work_material[i-1].value;
                 if( UNITS_SWITCH == ON )
                    UnitsCopy( p->work_material[i-1].dimen, eap->work_material[i-1].dimen );
             }
         }
         for(i = 1; i <= UNIT_SECTION_ATTR; i++) {  
             if( eap->work_section[i-1].value != 0 ) {
                 p->work_section[i-1].value = eap->work_section[i-1].value;
                 if( UNITS_SWITCH == ON )
                    UnitsCopy( p->work_section[i-1].dimen, eap->work_section[i-1].dimen );
             }
         }
         if(el->LC_ptr->name != (char *)NULL){
            free((char *) p->LC_ptr->name);
            p->LC_ptr->name  = SaveString(el->LC_ptr->name);
            p->LC_ptr->n     = el->LC_ptr->n;
            p->LC_ptr->alpha = el->LC_ptr->alpha;
            p->LC_ptr->beta  = el->LC_ptr->beta;
         }
         else{
            free((char *) p->LC_ptr->name);
            p->LC_ptr->name  = (char *)NULL;
            p->LC_ptr->n     = 0.0;
            p->LC_ptr->alpha = 0.0;
            p->LC_ptr->beta  = 0.0;
         }
         p->LC_ptr->ialph   = el->LC_ptr->ialph;
         p->LC_ptr->pen     = el->LC_ptr->pen;
         p->LC_ptr->load[0] = el->LC_ptr->load[0];
         p->LC_ptr->load[1] = el->LC_ptr->load[1];
         p->LC_ptr->load[2] = el->LC_ptr->load[2];
         p->LC_ptr->load[3] = el->LC_ptr->load[3];
         p->LC_ptr->load[4] = el->LC_ptr->load[4];
         p->LC_ptr->load[5] = el->LC_ptr->load[5];

         for(j = 1; j <= iNO_INTEG_pts; j++) {
             p->LC_ptr->R[j-1] = el->LC_ptr->R[j-1];
             p->LC_ptr->H[j-1] = el->LC_ptr->H[j-1];
             for(i = 1; i <= 6; i++)
                 p->LC_ptr->back_stress[i-1][j-1] 
                 = el->LC_ptr->back_stress[i-1][j-1];
         }

      }
   }

/*
 *  ==================================================================
 *  Check Allocation of elmt arrays & load values :  depends on 'task'
 *  ==================================================================
 */

    if(p->size_of_stiff > max_size_of_stiff) {

       /* Stiffness Matrix */

       MatrixFreeIndirect(p->stiff);
       p->stiff = MatrixAllocIndirect("stiff/mass",DOUBLE_ARRAY,
                  p->size_of_stiff, p->size_of_stiff);

       if(UNITS_SWITCH == ON ) {

          /* Applied Nodal Loads */

          for( i=1 ; i <= max_size_of_stiff ; i++ ) {
               free((char *) p->nodal_loads[i-1].dimen->units_name);
	       free((char *) p->nodal_loads[i-1].dimen);
          }
       }

       free((char *) p->nodal_loads);
       p->nodal_loads  = (QUANTITY *) MyCalloc(p->size_of_stiff, sizeof(QUANTITY));

       if( UNITS_SWITCH == ON ) {
           for (i = 1; i <= p->size_of_stiff; i++)
                p->nodal_loads[i-1].dimen =(DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS)); 
       }

       MatrixFreeIndirect( p->equiv_nodal_load );
       p->equiv_nodal_load = MatrixAllocIndirect("equiv_nodal_loads",
                             DOUBLE_ARRAY,p->size_of_stiff,1); 

       max_size_of_stiff = p->size_of_stiff;
   }

   if( p->nodes_per_elmt > max_nodes_per_elmt ) {
       if(p->no_dimen > max_no_dimen ) {
	           for(i=1 ; i<=max_no_dimen ; i++ ) {
                       if(UNITS_SWITCH == ON ) {
	                  for(j=1 ; j<= max_nodes_per_elmt ; j++ ) {
	                      free((char *) p->coord[i-1][j-1].dimen->units_name);
	                      free((char *) p->coord[i-1][j-1].dimen);
	                      free((char *) p->nodal_traction[i-1][j-1].dimen->units_name);
	                      free((char *) p->nodal_traction[i-1][j-1].dimen);
	                  }
                       }
	               free((char *) p->coord[i-1]);
	               free((char *) p->nodal_traction[i-1]);
	           }
	           free((char *) p->coord);
	           free((char *) p->nodal_traction);

                   p->coord = (QUANTITY **) MyCalloc(p->no_dimen, sizeof(QUANTITY *));
                   p->nodal_traction =(QUANTITY **) MyCalloc(p->no_dimen,sizeof(QUANTITY *));
                   for(i = 1; i <= p->no_dimen; i++) {
                       p->coord[i-1] = (QUANTITY *) MyCalloc(p->nodes_per_elmt,
                                                             sizeof(QUANTITY));
                       p->nodal_traction[i-1] = (QUANTITY *) MyCalloc(p->nodes_per_elmt,
                                                                      sizeof(QUANTITY));  
                       if(UNITS_SWITCH == ON ) {
                          for(j = 1; j <= p->nodes_per_elmt; j++) {
                              p->coord[i-1][j-1].dimen 
                              = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
                              p->nodal_traction[i-1][j-1].dimen 
                              = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));  
	                   }
                        }
                    }
                    max_no_dimen = p->no_dimen;
	        }
	        else { /* p->no_dimen <= max_no_dimen &&         */
                       /* p->nodes_per_elmt > max_nodes_per_elmt */

	            for( i=1 ; i<=max_no_dimen ; i++ ) {
                       if(UNITS_SWITCH == ON ) {
	                  for(j=1 ; j<= max_nodes_per_elmt ; j++ ) {
	                      free((char *) p->coord[i-1][j-1].dimen->units_name);
	                      free((char *) p->coord[i-1][j-1].dimen);
	                      free((char *) p->nodal_traction[i-1][j-1].dimen->units_name);
	                      free((char *) p->nodal_traction[i-1][j-1].dimen);
	                  }
                       }
	               free((char *) p->coord[i-1]);
	               free((char *) p->nodal_traction[i-1]);
	            }

                    for(i = 1; i <= max_no_dimen; i++) {
                        p->coord[i-1] = (QUANTITY *) MyCalloc(p->nodes_per_elmt,
                                                              sizeof(QUANTITY));
                        p->nodal_traction[i-1] = (QUANTITY *) MyCalloc(p->nodes_per_elmt,
                                                              sizeof(QUANTITY));  
                        if( UNITS_SWITCH == ON ) {
                           for (j = 1; j <= p->nodes_per_elmt; j++) {
                               p->coord[i-1][j-1].dimen  
                               = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
                               p->nodal_traction[i-1][j-1].dimen
                               = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));  
	                   }
                        }
                    }
	        }

	        if( p->dof_per_node > max_no_dof ) {

                    MatrixFreeIndirect( p->displ );
                    p->displ = MatrixAllocIndirect("displacement", DOUBLE_ARRAY,
                               p->dof_per_node, p->nodes_per_elmt);

	            for(i=1 ; i<=max_no_dof ; i++ ) {
                        if(UNITS_SWITCH == ON ) {
	                   for(j=1 ; j<= max_nodes_per_elmt ; j++ ) {
	                       free((char *) p->nodal_body_force[i-1][j-1].dimen->units_name);
	                       free((char *) p->nodal_body_force[i-1][j-1].dimen);
	                   }
                        }
	                free((char *) p->nodal_body_force[i-1]);
	            }
	            free((char *) p->nodal_body_force);
                    p->nodal_body_force = (QUANTITY **) MyCalloc(p->dof_per_node, sizeof(QUANTITY *));  

                    for(i = 1; i <= p->dof_per_node; i++) {
                        p->nodal_body_force[i-1] 
                        = (QUANTITY *) MyCalloc(p->nodes_per_elmt, sizeof(QUANTITY));  
                        if( UNITS_SWITCH == ON ) {
                           for(j = 1; j <= p->nodes_per_elmt; j++)
                               p->nodal_body_force[i-1][j-1].dimen 
                               = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
                        }
                    }

	            MatrixFreeIndirectDouble( p->nodal_init_strain, max_no_dof );
                    p->nodal_init_strain = 
                    (double **) MatrixAllocIndirectDouble(p->dof_per_node, p->nodes_per_elmt);

	            for( i=1 ; i<=max_no_dof ; i++ ) {
                        if(UNITS_SWITCH == ON ) {
	                   for(j=1 ; j<= max_nodes_per_elmt ; j++ ) {
	                       free((char *)p->nodal_init_stress[i-1][j-1].dimen->units_name);
	                       free((char *)p->nodal_init_stress[i-1][j-1].dimen);
	                   }
                        }
	                free((char *) p->nodal_init_stress[i-1]);
	            }
	            free((char *) p->nodal_init_stress);
                    p->nodal_init_stress 
                    = (QUANTITY **) MyCalloc(p->dof_per_node, sizeof(QUANTITY *));  
                    for(i = 1; i <= p->dof_per_node; i++) {
                        p->nodal_init_stress[i-1]
                        = (QUANTITY *) MyCalloc(p->nodes_per_elmt, sizeof(QUANTITY));  
                        if( UNITS_SWITCH == ON ) {
                           for(j = 1; j <= p->nodes_per_elmt; j++) 
                               p->nodal_init_stress[i-1][j-1].dimen 
                               = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
                        }
                    }
                    if( UNITS_SWITCH == ON ) {
	               for( j=1 ; j<= max_no_dof ; j++ ) {
	                   free((char *) p->nodal_temp[j-1].dimen->units_name);
	                   free((char *) p->nodal_temp[j-1].dimen);
	               }
                    }
	            free((char *) p->nodal_temp);
                    p->nodal_temp = (QUANTITY *) MyCalloc(p->dof_per_node, sizeof(QUANTITY));  
                    if( UNITS_SWITCH == ON ) {
                       for (i = 1; i <= p->dof_per_node; i++)
                           p->nodal_temp[i-1].dimen 
                           = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
                    }
                    max_no_dof         = p->dof_per_node;
	        }
	        else { /* p->dof_per_node <= max_no_dof &&       */
                       /* p->nodes_per_elmt > max_nodes_per_elmt */

                    MatrixFreeIndirect( p->displ );
                    p->displ = MatrixAllocIndirect("displacement", 
                               DOUBLE_ARRAY, max_no_dof, p->nodes_per_elmt);

	            for( i=1 ; i <= max_no_dof ; i++ ) {
                        if( UNITS_SWITCH == ON ) {
	                   for( j=1 ; j<= max_nodes_per_elmt ; j++ ) {
	                          free((char *)p->nodal_body_force[i-1][j-1].dimen->units_name);
	                          free((char *)p->nodal_body_force[i-1][j-1].dimen);

	                   }
                        }
	                free((char *) p->nodal_body_force[i-1]);
	            }
                    for (i = 1; i <= max_no_dof; i++) {
                        p->nodal_body_force[i-1] 
                        = (QUANTITY *) MyCalloc(p->nodes_per_elmt, sizeof(QUANTITY));  
                        if( UNITS_SWITCH == ON ) {
                           for(j = 1; j <= p->nodes_per_elmt; j++)
                               p->nodal_body_force[i-1][j-1].dimen 
                               = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
                        }
                    }

	            for( i=1; i <= max_no_dof; i++ ) {
	                free((char *) p->nodal_init_strain[i-1] );
	                p->nodal_init_strain[i-1] 
                        = (double *)MyCalloc(p->nodes_per_elmt, sizeof(double));
	            }

	            for( i=1 ; i<=max_no_dof ; i++ ) {
                        if( UNITS_SWITCH == ON ) {
	                   for( j=1 ; j<= max_nodes_per_elmt ; j++ ) {
	                          free((char *)p->nodal_init_stress[i-1][j-1].dimen->units_name);
     	                          free((char *)p->nodal_init_stress[i-1][j-1].dimen);
	                   }
                        }
	                free((char *) p->nodal_init_stress[i-1]);
	            }
                    for(i = 1; i <= max_no_dof; i++) {
                        p->nodal_init_stress[i-1]
                        = (QUANTITY *) MyCalloc(p->nodes_per_elmt, sizeof(QUANTITY));  
                        if( UNITS_SWITCH == ON ) {
                           for(j = 1; j <= p->nodes_per_elmt; j++) 
                               p->nodal_init_stress[i-1][j-1].dimen
                               = (DIMENSIONS *) MyCalloc(1,sizeof(DIMENSIONS));
                        }
                    }
	        }
                free((char *) p->node_connect);
                p->node_connect = iVectorAlloc(p->nodes_per_elmt);

                max_nodes_per_elmt = p->nodes_per_elmt;
    } else { 

      /* p->nodes_per_elmt <= max_nodes_per_elmt */

      if( p->no_dimen > max_no_dimen ) {
          for( i=1 ; i<=max_no_dimen ; i++ ) {
               if( UNITS_SWITCH == ON ) {
	           for( j=1 ; j<= max_nodes_per_elmt ; j++ ) {
	                free((char *) p->coord[i-1][j-1].dimen->units_name);