fe_print.c

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

                                                                               nforces->fn[1].dimen->units_name,
                                                                               nforces->fn[2].dimen->units_name);
                   printf("-----------------------------------------------\n");

                   for(i = 1;i <= frame->no_node_loads; i++) {
                       nforces = &frame->nforces[i-1];
                       for( j=1 ; j<=frame->no_dof ; j++ )
                            UnitsSimplify( nforces->fn[j-1].dimen );
                       printf("%5d ",(int) nforces->node_f); 
                       printf(" %12.2f ",   nforces->fn[0].value/nforces->fn[0].dimen->scale_factor);
                       printf(" %12.2f ",   nforces->fn[1].value/nforces->fn[1].dimen->scale_factor);
                       printf(" %12.2f\n",   nforces->fn[2].value/nforces->fn[2].dimen->scale_factor);
                   }
                   break;
                case OFF:
                   printf("Node#        Fx         Fy       Mz \n");
                   printf("---------------------------------------\n");

                   for(i = 1;i <= frame->no_node_loads; i++) {
                       nforces = &frame->nforces[i-1];
                       printf("%5d ",(int) nforces->node_f); 
                       printf(" %12.2f ",   nforces->fn[0].value);
                       printf(" %12.2f ",   nforces->fn[1].value);
                       printf(" %12.2f\n ",   nforces->fn[2].value);
                   }
                   break;
                default:
                   break;
              }
          }
          if(frame->no_dof == 2){
             switch(UNITS_SWITCH) {
                case ON:
                   for( i=1 ; i<=frame->no_dof ; i++ )
                        UnitsSimplify( nforces->fn[i-1].dimen );
                   printf("Node#        Fx (%s)        Fy (%s)\n",
                                     nforces->fn[0].dimen->units_name,
                                     nforces->fn[1].dimen->units_name);
                  printf("-----------------------------------------------\n");
                  for(i = 1;i <= frame->no_node_loads; i++) {
                      nforces = &frame->nforces[i-1];
                      for( j=1 ; j<=frame->no_dof ; j++ )
                           UnitsSimplify( nforces->fn[j-1].dimen );
                      printf("%5d ",(int) nforces->node_f);
                      printf(" %12.2f ",   nforces->fn[0].value/nforces->fn[0].dimen->scale_factor);
                      printf(" %12.2f ",   nforces->fn[1].value/nforces->fn[1].dimen->scale_factor);
                  }
                  break;
                  case OFF:
                      printf("Node#        Fx            Fy  \n");
                      printf("-----------------------------------------------\n");
                      for(i = 1;i <= frame->no_node_loads; i++) {
                      nforces = &frame->nforces[i-1];
                      printf("%5d ",(int) nforces->node_f); 
                      printf(" %12.2f ",   nforces->fn[0].value);
                      printf(" %12.2f ",   nforces->fn[1].value);
                 }
                 break;
                 default:
                 break;
             }
          }
       }

       if(frame->no_node_loads >= 1 && (frame->no_dimen == 3)) {

          printf("                        \n");
          printf("EXTERNAL NODAL LOADINGS \n");
          nforces = &frame->nforces[0];
          if(frame->no_dof == 6){
            printf("--------------------------------------------------------------------------------------------\n");
            switch( UNITS_SWITCH ) {
              case ON:
                for( i=1 ; i<=frame->no_dof ; i++ )
                     UnitsSimplify( nforces->fn[i-1].dimen );
                printf("Node#       Fx (%s)      Fy (%s)     Fz (%s)     Mx (%s)    My (%s)     Mz (%s)\n",
                        nforces->fn[0].dimen->units_name,
                        nforces->fn[1].dimen->units_name,
                        nforces->fn[2].dimen->units_name,
                        nforces->fn[3].dimen->units_name,
                        nforces->fn[4].dimen->units_name,
                        nforces->fn[5].dimen->units_name);
                printf("--------------------------------------------------------------------------------------------\n");
                break;
              case OFF:
                printf("Node#       Fx       Fy      Fz      Mx     My      Mz \n");
                break;
              default:
                break;
            }
          }

          if(frame->no_dof == 5){
            printf("-----------------------------------------------------------------------------------\n");
            switch( UNITS_SWITCH ) {
              case ON:
                  for( i=1 ; i<=frame->no_dof ; i++ )
                       UnitsSimplify( nforces->fn[i-1].dimen );
                  printf("Node#       Fx (%s)     Fy (%s)    Fz (%s)    Mx (%s)   My (%s)\n",
                          nforces->fn[0].dimen->units_name,
                          nforces->fn[1].dimen->units_name,
                          nforces->fn[2].dimen->units_name,
                          nforces->fn[3].dimen->units_name,
                          nforces->fn[4].dimen->units_name);
                  printf("-----------------------------------------------------------------------------------\n");
                 break;
              case OFF:
                  printf("Node#       Fx      Fy     Fz     Mx    My \n");
                 break;
              default:
                 break;
            }
          }

          switch( UNITS_SWITCH ) {
            case ON:
                for(i = 1;i <= frame->no_node_loads; i++) {
                    nforces = &frame->nforces[i-1];
                    for( j=1 ; j<=frame->no_dof ; j++ )
                         UnitsSimplify( nforces->fn[j-1].dimen );
                    printf("%5d ",(int) nforces->node_f); 
                    printf("%12.3f ",   nforces->fn[0].value/nforces->fn[0].dimen->scale_factor);
                    printf("%12.3f ",   nforces->fn[1].value/nforces->fn[1].dimen->scale_factor);
                    printf("%12.3f ",   nforces->fn[2].value/nforces->fn[2].dimen->scale_factor);
                    printf("%12.3f ",   nforces->fn[3].value/nforces->fn[3].dimen->scale_factor);
                    printf("%12.3f ",   nforces->fn[4].value/nforces->fn[4].dimen->scale_factor);
                    if(frame->no_dof == 6)
                    printf("%12.3f",  nforces->fn[5].value/nforces->fn[5].dimen->scale_factor); 
                    printf("\n"); 
                }
               break;
            case OFF:
                for(i = 1;i <= frame->no_node_loads; i++) {
                    nforces = &frame->nforces[i-1];
                    printf("%5d ",(int) nforces->node_f); 
                    printf("%12.3f ",   nforces->fn[0].value);
                    printf("%12.3f ",   nforces->fn[1].value);
                    printf("%12.3f ",   nforces->fn[2].value);
                    printf("%12.3f ",   nforces->fn[3].value);
                    printf("%12.3f ",   nforces->fn[4].value);
                    if(frame->no_dof == 6)
                    printf("%12.3f",  nforces->fn[5].value);
                    printf("\n"); 
                }
               break;
            default:
               break;
          }
       }

    /* [e] : Print Element Forces */

       if(frame->no_element_loads >= 1) {
          printf("\n");
          printf("------------------------------------------------\n");
          printf("Element Loads : a,b = (in), Px,Py,Pz = (kips/in)\n");
          printf("------------------------------------------------\n");

          printf("\n");
          printf("Elmt#\n");
          printf("-----\n\n");

          for(i=1; i <= frame->no_element_loads; i++) {
              elsp = &frame->eforces[i-1];
              elmt = &frame->element[elsp->elmt_no -1];
              elp    = elsp->elib_ptr;

              if(iel_no == 1) {
                 for(j=1;j<=elsp->no_loads_faces;j++) {
                     printf("%5d %4d %5d %12.5f %12.5f %5d %13.5f %13.5f\n", elsp->elmt_no,
                     elp->face_no,elp->nopl[1],elp->pr->uMatrix.daa[1][1],   
                     elp->pr->uMatrix.daa[1][2],elp->nopl[2],elp->pr->uMatrix.daa[2][1],elp->pr->uMatrix.daa[2][2]);
                 }
              }

              if(iel_no == 5) {
                 if(elp->type == -1) { /* dist loading */
                    printf("%5d :  a = %13.5f  b = %13.5f\n",elsp->elmt_no, elp->a.value, elp->b.value);
                    printf("      : Px = %13.5f Py = %13.5f Pz = %13.5f\n", elp->bx.value,elp->by.value,elp->bz.value);
                 }
                 else { /* point load  & moments*/
                    printf("%5d :  a = %13.5f  b = %13.5f\n",elsp->elmt_no, elp->a.value, elp->b.value);
                    printf("      : Px = %13.5f Py = %13.5f Pz = %13.5f\n", elp->bx.value,elp->by.value,elp->bz.value);
                    printf("      : Mx = %13.5f My = %13.5f Mz = %13.5f\n", elp->mx.value,elp->my.value,elp->mz.value);
                 }
              }

              if(iel_no == 7 || iel_no == 2) {
                 if(elp->type == -1) { /* distributed loading */
                    printf("%5d : a = %13.5f b = %13.5f Py = %13.5f\n",elsp->elmt_no, elp->a.value, elp->b.value, elp->by.value);
                 }
                 else
                    printf("%5d : a = %13.5f b = %13.5f P  = %13.5f\n",elsp->elmt_no, elp->a.value, elp->b.value, elp->P.value);
              }
          } 
       }

    /* [f] : End Message */

       printf("\n");
       printf("============= End of Finite Element Mesh Description ==============\n");
       printf("\n\n");
}


/*
 *  -----------------------------
 *  Print Displacements, Stresses 
 *  -----------------------------
 */

#ifdef  __STDC__
MATRIX *Print_Stress( MATRIX *m1, ... )
#else
MATRIX *Print_Stress(va_alist)
va_dcl
#endif
{
#ifdef __STDC__
va_list        arg_ptr;
#else
va_list        arg_ptr;
MATRIX             *m1;
#endif

ELEMENT            *ep;
ELEMENT_ATTR      *eap;
double       *elvector;
double       mzc,   mz; 
int            node_no;
int            elmt_no;
int       elmt_attr_no;
int    i, j, k, jj, ii;
int             length;
int       UNITS_SWITCH;

DIMENSIONS      *dp_length_temp;
DIMENSIONS       *dp_force_temp;
double    xi[17],eta[17],wg[17];
double              *gamma, *wt;
int                     l, lint;

SYMBOL                     *slp;
int            iInPlaneIntegPts;
int          iThicknessIntegPts;
int               iNO_INTEG_pts;

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

#ifdef __STDC__
       va_start(arg_ptr, m1);
#else
       va_start(arg_ptr);
       m1 = va_arg(arg_ptr, MATRIX *)
#endif
       va_end(arg_ptr);

/*---------------------------------------*/
    UNITS_SWITCH = CheckUnits();

    /* [a] : Print Header */

    printf("\n\n");
    printf("MEMBER FORCES \n");
    printf("------------------------------------------------------------------------------\n");

    /* [b] :Calculate and Print Element Stresses */

    if(m1 != (MATRIX *) NULL) /* stress corresponding to linear response */
       for(elmt_no = 1; elmt_no <= frame->no_elements; elmt_no++) {

#ifdef DEBUG
        printf(" elmt No = %d \n", elmt_no);
#endif
           array = Assign_p_Array(frame, elmt_no, array, STRESS);
           array = elmlib(array, PROPTY);

           /* Transfer Fixed Displacements */

           ep           = &frame->element[elmt_no-1];
           elmt_attr_no = ep->elmt_attr_no;  
           eap          = &frame->eattr[elmt_attr_no-1];
           for(i=1; i <= array->nodes_per_elmt; i++) {
               k = 1; 
               node_no = ep->node_connect[i-1];
               for(j = 1; j <= array->dof_per_node; j++) {
                   switch((int) array->nodes_per_elmt) {
                     case 2:
                     case 3:
                        ii = eap->map_ldof_to_gdof[j-1];
                        jj = frame->node[node_no - 1].bound_id[ii-1];
                        if(jj > 0) {
                           array->displ->uMatrix.daa[j-1][i-1] = m1->uMatrix.daa[jj-1][0];
                           if( UNITS_SWITCH == ON ) {
                              UnitsCopy(&(array->displ->spRowUnits[j-1]), &(m1->spRowUnits[jj-1]));
                              ZeroUnits(&(array->displ->spColUnits[i-1]));
                           }
                        }
                        else {
                           array->displ->uMatrix.daa[j-1][i-1]
                           = frame->node[node_no -1].disp[ii-1].value;
                           if( UNITS_SWITCH == ON ) {
                              UnitsCopy(&(array->displ->spRowUnits[j-1]),
                                frame->node[node_no -1].disp[ii-1].dimen);