fe_profile.c

有限元分析源代码

	                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;
       }

       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++ ) {
                       if(p->nodal_init_stress[i-1][j-1].dimen != NULL &&
                          p->nodal_init_stress[i-1][j-1].dimen->units_name != NULL)
	                  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;
        }
   }

   switch (task) {
      case PROPTY:
           for(i = 1; i <= UNIT_SECTION_ATTR; i++) {
               p->work_section[i-1].value 
               = frp->eattr[elmt_attr_no-1].work_section[i-1].value;
           }

           if(UNITS_SWITCH == ON ){
              for(i = 1; i <= UNIT_SECTION_ATTR; i++) 
                  UnitsCopy( p->work_section[i-1].dimen,
                  frp->eattr[elmt_attr_no-1].work_section[i-1].dimen );
           }

           for(i = 1; i <= UNIT_MATERIAL_ATTR; i++) {
               p->work_material[i-1].value 
               = frp->eattr[elmt_attr_no-1].work_material[i-1].value;
              if(UNITS_SWITCH == ON )
                 UnitsCopy( p->work_material[i-1].dimen,
                 frp->eattr[elmt_attr_no-1].work_material[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];
            }
	break;

       case STIFF:
       case MASS_MATRIX:

            if(task == MASS_MATRIX)
               for(i = 1;i <= p->size_of_stiff; i++) {
                   p->nodal_loads[i-1].value = 0.0;
                   if( UNITS_SWITCH == ON )
                      ZeroUnits( p->nodal_loads[i-1].dimen );
               }

            /* p->node_connect[] = list of nodal connectivities */

            for(j = 1; j <= p->nodes_per_elmt;j++)
                p->node_connect[j-1] = el->node_connect[j-1];

            for(j = 1; j <= iNO_INTEG_pts; j++) {
                p->effect_pl_strain[j-1]   = el->rp->effect_pl_strain[j-1];
                p->eff_pl_strain_incr[j-1] = 0.0;
                for(i = 1; i <= 9; i++){
                    p->stress->uMatrix.daa[i-1][j-1] 
                    = el->rp->stress->uMatrix.daa[i-1][j-1];
                    p->strain_pl->uMatrix.daa[i-1][j-1] 
                    = el->rp->strain_pl->uMatrix.daa[i-1][j-1];
                    p->strain_pl_incr->uMatrix.daa[i-1][j-1] 
                    = 0.0;
                }
            }

            for(j = 1; j <= frp->no_nodes_per_elmt; j++) {
                node_no = el->node_connect[j-1];
                if(node_no != 0) {
                   for(i=1;i <= p->no_dimen; i++) {
                       p->coord[i-1][j-1].value 
                       = frp->node[node_no -1].coord[i-1].value;
                       if(UNITS_SWITCH == ON )
                          UnitsCopy( p->coord[i-1][j-1].dimen,
                          frp->node[node_no -1].coord[i-1].dimen );
                   }
                }
            }

            /*  initialize and Transfer Element Displacements */

            if( UNITS_SWITCH == ON ) {
               for(i = 1; i <= p->dof_per_node; i++) {
                   ZeroUnits( &(p->displ->spRowUnits[i-1]) );
               }
               for(i = 1; i <= p->nodes_per_elmt; i++) {
                   ZeroUnits( &(p->displ->spColUnits[i-1]) );
               }
            }

            for(i=1; i <= p->dof_per_node; i++) {
                for(j=1; j <= p->nodes_per_elmt; j++) {
                    p->displ->uMatrix.daa[i-1][j-1]      = el->rp->displ->uMatrix.daa[i-1][j-1];
                    p->displ_incr->uMatrix.daa[i-1][j-1] = 0.0;
                }
            }
            break;

       case LOAD_MATRIX:
       case EQUIV_NODAL_LOAD:

            for(i = 1; i <= p->size_of_stiff; i++) 
	        p->nodal_loads[i-1].value   = 0.0;

            if(UNITS_SWITCH == ON ) {
               for(i = 1; i <= p->size_of_stiff; i++) {
                   ZeroUnits( &(p->equiv_nodal_load->spRowUnits[i-1]) );
                   ZeroUnits( p->nodal_loads[i-1].dimen );
               }
               ZeroUnits( &(p->equiv_nodal_load->spColUnits[0]) );
            }

            dof_per_elmt = p->nodes_per_elmt*p->dof_per_node;
            for(j = 1; j <= dof_per_elmt; j++) {
                p->equiv_nodal_load->uMatrix.daa[j-1][0] = 0.0;
            }
    
            for(j = 1; j <= p->nodes_per_elmt; j++) {
               p->nodal_temp[j-1].value = frp->eforces->elib_ptr[j-1].temp_change.value; 
               if(UNITS_SWITCH == ON )
                  UnitsCopy( p->nodal_temp[j-1].dimen,
                  frp->eforces->elib_ptr[j-1].temp_change.dimen );
               for( i = 1; i <= p->no_dimen; i++) {
                   /*== subjected to change later ==*/
                    p->nodal_traction[i-1][j-1].value = 0.0;
                    if(UNITS_SWITCH == ON )
                       ZeroUnits( p->nodal_traction[i-1][j-1].dimen );
                    if(frp->eforces->elib_ptr[j-1].body_force != NULL) {
                       p->nodal_body_force[i-1][j-1].value 
                       = frp->eforces->elib_ptr[j-1].body_force[i-1].value; 
                       if( UNITS_SWITCH == ON )
                          UnitsCopy( p->nodal_body_force[i-1][j-1].dimen,
                          frp->eforces->elib_ptr[j-1].body_force[i-1].dimen );
                    }
                    else {
                       p->nodal_body_force[i-1][j-1].value  = 0.0;
                       if(UNITS_SWITCH == ON )
                          ZeroUnits( p->nodal_body_force[i-1][j-1].dimen );
                    }
               }
            }

            for(j = 1; j <= p->nodes_per_elmt; j++) {
               for( i = 1; i <= p->dof_per_node; i++) { 
                 if(frp->eforces->elib_ptr[j-1].init_strain != NULL)
                    p->nodal_init_strain[i-1][j-1] 
                    = frp->eforces->elib_ptr[j-1].init_strain[i-1];
                 else
                    p->nodal_init_strain[i-1][j-1] = 0.0;
                 if(frp->eforces->elib_ptr[j-1].init_stress != NULL) {
                    p->nodal_init_stress[i-1][j-1].value 
                    = frp->eforces->elib_ptr[j-1].init_stress[i-1].value; 
                    if( UNITS_SWITCH == ON )
                       UnitsCopy( p->nodal_init_stress[i-1][j-1].dimen,
                       frp->eforces->elib_ptr[j-1].init_stress[i-1].dimen );
                 }
                 else {
                   p->nodal_init_stress[i-1][j-1].value  = 0.0;
                   if(UNITS_SWITCH == ON )
                      ZeroUnits( p->nodal_init_stress[i-1][j-1].dimen );
                 }
               }
            }

            for(j=1;j <= p->nodes_per_elmt;j++) {
               node_no = el->node_connect[j-1];
               if(node_no != 0){
                  for(i=1;i<=p->no_dimen;i++) {
                      p->coord[i-1][j-1].value 
                      = frp->node[node_no -1].coord[i-1].value;    
                      if( UNITS_SWITCH == ON )
                         UnitsCopy( p->coord[i-1][j-1].dimen,
                         frp->node[node_no -1].coord[i-1].dimen );
                  }
               }
            }

            /* Assign the nodal load and stress in previous step to p->nodal Load */

            for(k = 1; k <= p->size_of_stiff; k++)
                    p->nodal_loads[k-1].value = 0.0;

            for(j = 1; j <= iNO_INTEG_pts; j++) {
                p->effect_pl_strain[j-1]   = el->rp->effect_pl_strain[j-1];
                p->eff_pl_strain_incr[j-1] = 0.0;
                for(i = 1; i <= 9; i++){
                    p->stress->uMatrix.daa[i-1][j-1]
                    = el->rp->stress->uMatrix.daa[i-1][j-1];
                    p->strain_pl->uMatrix.daa[i-1][j-1] 
                    = el->rp->strain_pl->uMatrix.daa[i-1][j-1];
                    p->strain_pl_incr->uMatrix.daa[i-1][j-1] 
                    = 0.0;
                }
            }

            for(i=1; i <= p->dof_per_node; i++) {
            for(j=1; j <= p->nodes_per_elmt; j++) {
                p->displ->uMatrix.daa[i-1][j-1]      = el->rp->displ->uMatrix.daa[i-1][j-1];
                p->displ_incr->uMatrix.daa[i-1][j-1] = 0.0;
            }
            }
            break;

       case PRESSLD:
       case STRESS_LOAD:

            for(i=1;i<=p->size_of_stiff ;i++){
               p->nodal_loads[i-1].value  = 0.0;
               if( UNITS_SWITCH == ON )
                  ZeroUnits( p->nodal_loads[i-1].dimen );
            }

            for(j = 1; j <= iNO_INTEG_pts; j++){
                p->effect_pl_strain[j-1]   = el->rp->effect_pl_strain[j-1];
                p->eff_pl_strain_incr[j-1] = 0.0;
                for(i = 1; i <= 9; i++){
                    p->stress->uMatrix.daa[i-1][j-1] 
                    = el->rp->stress->uMatrix.daa[i-1][j-1];
                    p->strain_pl->uMatrix.daa[i-1][j-1]
                    = el->rp->strain_pl->uMatrix.daa[i-1][j-1];
                    p->strain_pl_incr->uMatrix.daa[i-1][j-1]
                    = 0.0;
                }
            }

            for(i=1; i <= p->dof_per_node; i++) {
            for(j=1; j <= p->nodes_per_elmt; j++) {
                p->displ->uMatrix.daa[i-1][j-1] = el->rp->displ->uMatrix.daa[i-1][j-1];
                p->displ_incr->uMatrix.daa[i-1][j-1] = 0.0;
            }
            }

            for(j=1;j<= p->nodes_per_elmt ;j++) {
               node_no = el->node_connect[j-1];
               if(node_no != 0){
                  for(i=1;i<=p->no_dimen;i++) {