fe_print.c

有限元程序

                 printf(" %12.2f\n",   nforces->fn[2].value/nforces->fn[2].dimen->scale_factor);
             }
          } else {
             printf("=================================== \n");
             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);
             }
          }
      }

      if(frame->no_dof == 2) {
          if(UNITS_SWITCH == ON ) {
             for( i=1 ; i<=frame->no_dof ; i++ )
                 UnitsSimplify( nforces->fn[i-1].dimen );

             printf("=====================================\n");
             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\n",   nforces->fn[1].value/nforces->fn[1].dimen->scale_factor);
             }
          } else {
             printf("=============================\n");
             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\n",   nforces->fn[1].value);
             }
         }
      }
   }

   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) {
         if( UNITS_SWITCH == ON ) {
            for( i=1 ; i<=frame->no_dof ; i++ )
                 UnitsSimplify( nforces->fn[i-1].dimen );

            printf("============================================================================================\n");
            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");
         } else {
            printf("========================================== \n");
            printf("Node#       Fx      Fy     Fz     Mx    My \n");
            printf("========================================== \n");
         }
      }

      if(frame->no_dof == 5) {
         if( UNITS_SWITCH == ON ) {
            for( i=1 ; i<=frame->no_dof ; i++ )
                 UnitsSimplify( nforces->fn[i-1].dimen );

            printf("===================================================================================\n");
            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");
         } else {
            printf("========================================== \n");
            printf("Node#       Fx      Fy     Fz     Mx    My \n");
            printf("========================================== \n");
         }
      }

      if( UNITS_SWITCH == 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"); 
         }
      }

      if( UNITS_SWITCH == 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"); 
         }
      }
   }

   /* [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\n");
    printf("============= End of Finite Element Mesh Description ==============\n");
    printf("\n\n");
}


/* 
 *  =========================================================
 *  Print_Stress() : Print Stresses.
 *
 *  Input  : Matrix * : Matrix of Stresses.....
 *  Output : void
 *  =========================================================
 */ 

#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 __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 (linear and nonlinear cases) */

    /* Stresses corresponding to linear response */

    if(m1 != (MATRIX *) NULL)
    for(elmt_no = 1; elmt_no <= frame->no_elements; elmt_no++) {

        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);
                              ZeroUnits(&(array->displ->spColUnits[i-1]));
                          }
                       }
                       break;
                  case 4:
                  case 8:
                       ii = eap->map_ldof_to_gdof[k-1];
                       jj = frame->node[node_no - 1].bound_id[ii-1];
                       if(jj > 0) {
                          array->displ->uMatrix.daa[k-1][i-1] = m1->uMatrix.daa[jj-1][0];
                          if( UNITS_SWITCH == ON ) {
                              UnitsCopy(&(array->displ->spRowUnits[k-1]), &(m1->spRowUnits[jj-1]));
                              ZeroUnits( &(array->displ->spColUnits[i-1]) );
                          }
                        } else {