/[escript]/trunk/paso/src/SystemMatrix_saveHB.c
ViewVC logotype

Diff of /trunk/paso/src/SystemMatrix_saveHB.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1311 by gross, Wed Mar 14 00:15:24 2007 UTC revision 1312 by ksteube, Mon Sep 24 06:18:44 2007 UTC
# Line 1  Line 1 
1    
2  /* $Id$ */  /* $Id$ */
3    
4  /*  /*******************************************************
5  ********************************************************************************   *
6  *               Copyright   2006 by ACcESS MNRF                                *   *           Copyright 2003-2007 by ACceSS MNRF
7  *                                                                              *   *       Copyright 2007 by University of Queensland
8  *                 http://www.access.edu.au                                     *   *
9  *           Primary Business: Queensland, Australia                            *   *                http://esscc.uq.edu.au
10  *     Licensed under the Open Software License version 3.0             *   *        Primary Business: Queensland, Australia
11  *        http://www.opensource.org/licenses/osl-3.0.php                        *   *  Licensed under the Open Software License version 3.0
12  ********************************************************************************   *     http://www.opensource.org/licenses/osl-3.0.php
13  */   *
14     *******************************************************/
15    
16  /**************************************************************/  /**************************************************************/
17    
# Line 25  Line 27 
27  #include "Paso.h"  #include "Paso.h"
28  #include "SystemMatrix.h"  #include "SystemMatrix.h"
29    
30  /* TODO: Refactor the stuff in here into hbio, just like mmio! */  void Paso_SystemMatrix_saveHB( Paso_SystemMatrix *A_p, char *filename_p ) {
31        FILE *fileHandle_p = NULL;
32  static dim_t M, N, nz;          if (A_p->mpi_info->size > 1) {
33            Paso_setError(TYPE_ERROR,"Paso_SystemMatrix_saveHB: currently single processor runs are supported.\n");
34  static int calc_digits( int );              return;
35  static void fmt_str( int, int, int*, int*, int*, char*, char* );          }
36  static void print_data( FILE*, int, int, int, char*, void*, int, int );      fileHandle_p = fopen( filename_p, "w" );
37  static void generate_HB( FILE*, dim_t*, dim_t*, double* );      if( fileHandle_p == NULL ) {
   
 /* function to get number of digits in an integer */  
 int calc_digits( int var )  
 {  
     int digits = 1;  
     while( (var/=10) )  
         digits++;  
   
     return digits;  
 }  
   
 /* function to generate the format string.  
  *  
  * use maxlen to determine no. of entries per line  
  * use nvalues to determine no. of lines  
  */  
 void fmt_str( int nvalues, int integer, int *width, int *nlines, int *nperline, char *pfmt, char *fmt )  
 {  
     int per_line;  
     int maxlen = *width;  
   
     if( integer && maxlen < 10 )  
         maxlen = 10;  
     else  
         maxlen = 13;  
   
     per_line = 80 / maxlen;  
     *nlines = nvalues / per_line;  
     if( nvalues % per_line )  
         (*nlines)++;  
   
     *nperline = per_line;  
     if( integer )  
     {  
         sprintf( pfmt, "(%dI%d)", per_line, maxlen );  
         sprintf( fmt, "%%%dd", maxlen );  
     }  
     else  
     {  
         sprintf( pfmt, "(1P%dE%d.6)", per_line, maxlen );  
         sprintf( fmt, "%%%d.6E", maxlen );  
     }  
     *width = maxlen;  
 }  
   
 /* function to print the actual data in the right format */  
 void print_data( FILE *fp, int n_perline, int width, int nval, char *fmt, void *ptr, int integer, int adjust )  
 {  
     double *data = ptr;  
     int entries_done = 0;  
     int padding, i, j;  
     char pad_fmt[10];  
   
     padding = 80 - n_perline*width;  
     sprintf( pad_fmt, "%%%dc", padding );  
   
     if( adjust != 1 )  
         adjust = 0;  
   
     if( integer )  
     {  
         dim_t *data = ptr;  
         for(i=0; i<nval; i++ )  
         {  
             fprintf( fp, fmt, data[i]+adjust );  
             entries_done++;  
             if( entries_done == n_perline )  
             {  
                 if( padding )  
                     fprintf( fp, pad_fmt, ' ' );  
                 fprintf( fp, "\n" );  
                 entries_done = 0;  
             }  
         }  
     }  
     else  
     {  
         for(i=0; i<nval; i++ )  
         {  
             fprintf( fp, fmt, data[i] );  
             entries_done++;  
             if( entries_done == n_perline )  
             {  
                 if( padding )  
                     fprintf( fp, pad_fmt, ' ' );  
                 fprintf( fp, "\n" );  
                 entries_done = 0;  
             }  
         }  
     }  
     if( entries_done )  
     {  
         sprintf( pad_fmt, "%%%dc\n", (80 - entries_done*width) );  
         fprintf( fp, pad_fmt, ' ' );  
     }  
 }  
   
 void generate_HB( FILE *fp, dim_t *col_ptr, dim_t *row_ind, double *val )  
 {  
     char buffer[81];  
   
     int val_lines, ind_lines, ptr_lines;  
     int val_perline, ind_perline, ptr_perline;  
     int val_width, ind_width, ptr_width;  
     char ptr_pfmt[7], ind_pfmt[7], val_pfmt[11];  
     char ptr_fmt[10], ind_fmt[10], val_fmt[10];  
   
     /* line 1 */  
     sprintf( buffer, "%-72s%-8s", "Matrix Title", "Key" );  
     buffer[80] = '\0';  
     fprintf( fp, "%s\n", buffer );  
   
     /* line 2 */  
     ptr_width = calc_digits( nz+1 );  
     fmt_str( N+1, 1, &ptr_width, &ptr_lines, &ptr_perline, ptr_pfmt, ptr_fmt );  
     ind_width = calc_digits( N );  
     fmt_str( nz, 1, &ind_width, &ind_lines, &ind_perline, ind_pfmt, ind_fmt );  
     val_width = 13;  
     fmt_str( nz, 0, &val_width, &val_lines, &val_perline, val_pfmt, val_fmt );  
     sprintf( buffer, "%14d%14d%14d%14d%14d%10c", (ptr_lines+ind_lines+val_lines), ptr_lines, ind_lines, val_lines, 0, ' ' );  
     buffer[80] = '\0';  
     fprintf( fp, "%s\n", buffer );  
   
     /* line 3 */  
     sprintf( buffer, "%c%c%c%11c%14d%14d%14d%14d%10c", 'R', 'U', 'A', ' ', M, N, nz, 0, ' ' );  
     buffer[80] = '\0';  
     fprintf( fp, "%s\n", buffer );  
   
     /* line 4 */  
     sprintf( buffer, "%16s%16s%20s%28c", ptr_pfmt, ind_pfmt, val_pfmt, ' ');  
     buffer[80]='\0';  
     fprintf( fp, "%s\n", buffer );  
   
     /* line 5 */  
     /* NOT PRESENT */  
   
     /* write the actual data */  
     print_data( fp, ptr_perline, ptr_width, (N+1), ptr_fmt, col_ptr, 1, 1 );  
     print_data( fp, ind_perline, ind_width, nz, ind_fmt, row_ind, 1, 1 );  
     print_data( fp, val_perline, val_width, nz, val_fmt, val, 0, 0 );  
 }  
   
 void Paso_SystemMatrix_saveHB( Paso_SystemMatrix *A_p, char *filename_p )  
 {  
         int i, curr_col,j ;  
     int iPtr, iCol, ir, ic;  
         index_t index_offset=(A_p->type & MATRIX_FORMAT_OFFSET1 ? 1:0);  
     dim_t *row_ind=NULL, *col_ind = NULL, *col_ptr=NULL;  
     /* open the file */  
     FILE *fileHandle_p = fopen( filename_p, "w" );  
     if( fileHandle_p == NULL )  
     {  
38          Paso_setError(IO_ERROR,"File could not be opened for writing.");          Paso_setError(IO_ERROR,"File could not be opened for writing.");
39          return;          return;
40      }      }
41    
           
     /* check the internal storage type  
      * currently ONLY support for CSC  
      */  
42      if ( A_p->type & MATRIX_FORMAT_CSC) {      if ( A_p->type & MATRIX_FORMAT_CSC) {
43                  if( A_p->row_block_size == 1 && A_p->col_block_size == 1 )               Paso_SparseMatrix_saveHB_CSC( A_p->mainBlock,fileHandle_p);
                 {  
                     M = A_p->num_rows;  
                     N = A_p->num_cols;  
                     nz = A_p->len;  
                     generate_HB( fileHandle_p, A_p->pattern->ptr, A_p->pattern->index, A_p->val );  
                 }  
                 else  
                 {  
   
 /*                  fprintf( fileHandle_p, "NEED unrolling!\n" ); */  
                     M = A_p->num_rows*A_p->row_block_size;  
                     N = A_p->num_cols*A_p->col_block_size;  
                     nz = A_p->len;  
   
                     row_ind = MEMALLOC( nz, dim_t );  
                     col_ind = MEMALLOC( nz, dim_t );  
   
                     i = 0;  
                     for( iCol=0; iCol<A_p->pattern->n_ptr; iCol++ )  
                         for( ic=0; ic<A_p->col_block_size; ic++)  
                             for( iPtr=A_p->pattern->ptr[iCol]-index_offset; iPtr<A_p->pattern->ptr[iCol+1]-index_offset; iPtr++)  
                                 for( ir=0; ir<A_p->row_block_size; ir++ )  
                                 {  
                                     row_ind[i] = (A_p->pattern->index[iPtr]-index_offset)*A_p->row_block_size+ir+1;  
                                     col_ind[i] = iCol*A_p->col_block_size+ic+1;  
                                     i++;  
                                 }  
   
                     /* get the col_ptr */  
                     col_ptr = MEMALLOC( (N+1), dim_t );  
   
                     curr_col = 0;  
                     for(j=0; (j<nz && curr_col<N); curr_col++ )  
                     {  
                         while( col_ind[j] != curr_col )  
                             j++;  
                         col_ptr[curr_col] = j;  
                     }  
                     col_ptr[N] = nz;  
   
                     /* generate the HB file */  
                     generate_HB( fileHandle_p, col_ptr, row_ind, A_p->val );  
   
                     /* free the allocated memory */  
                     MEMFREE( col_ptr );  
                     MEMFREE( col_ind );  
                     MEMFREE( row_ind );  
                 }  
44          } else {          } else {
45                  Paso_setError(TYPE_ERROR,"Paso_SystemMatrix_saveHB: only CSC is currently supported.\n");                Paso_setError(TYPE_ERROR,"Paso_SystemMatrix_saveHB: only CSC is currently supported.\n");
46      }      }
47    
48      /* close the file */      /* close the file */
# Line 252  void Paso_SystemMatrix_saveHB( Paso_Syst Line 50  void Paso_SystemMatrix_saveHB( Paso_Syst
50    
51      return;      return;
52  }  }
   
 /*  
  * $Log$  
  * Revision 1.2  2005/09/15 03:44:39  jgs  
  * Merge of development branch dev-02 back to main trunk on 2005-09-15  
  *  
  * Revision 1.1.2.1  2005/09/05 06:29:48  gross  
  * These files have been extracted from finley to define a stand alone libray for iterative  
  * linear solvers on the ALTIX. main entry through Paso_solve. this version compiles but  
  * has not been tested yet.  
  *  
  *  
  */  

Legend:
Removed from v.1311  
changed lines
  Added in v.1312

  ViewVC Help
Powered by ViewVC 1.1.26