remove redundant print out

1 files changed, 95 insertions, 79 deletions

diff --git a/main.c b/main.c
index dc46b64..fe765c2 100644
--- a/main.c
+++ b/main.c
@@ -26,9 +26,32 @@ int main(int argc, char** argv)
   double yllcorner;
   double cellsize;
   double nodata;
-  
+
   double *data;
-  
+
+  printf("\n\n");
+
+  printf("	  +----------------------------+\n");
+  printf("	  |                            |\n");
+  printf("	  |        . ...........       |\n");
+  printf("	  |      ...................   |\n");
+  printf("	  |    .... .. ........... ..  |\n");
+  printf("	  |   ... . ..............  .  |\n");
+  printf("	  |  ..     ..............     |\n");
+  printf("	  |  ..      ..         ..     |\n");
+  printf("	  |          ..         ..     |\n");
+  printf("	  |                            |\n");
+  printf("	  +----------------------------+\n\n");
+
+  printf("                  m a m m o t h\n");
+  printf("                  -------------\n\n");
+
+  printf("     I. Ozgen-Xian, G. Kesserwani, D. Caviedes-Voullieme,\n");
+  printf("     S. Molins, Z. Xu, D. Dwivedi, J. D. Moulton, C. I. Steefel,\n");
+  printf("     Wavelet-based local mesh refinement for rainfall-runoff\n");
+  printf("     simulations, Journal of Hydroinformatics, 22, 1059-1077, 2020.\n");
+  printf("     doi: 10.2166/hydro.2020.198\n\n");
+
   if (argc < 2) {
     fprintf(stderr, "[ERR] No input file provided.\n");
     return -1;
@@ -44,25 +67,22 @@ int main(int argc, char** argv)
   }
 
   char key[1024];
-    
+
   while (fscanf(fp, "%s", key) != EOF) {
 
     if (strcmp(key, "datafile") == 0) {
       fscanf(fp, "%s", datafilename);
-      printf("[OK] Data filename set: %s\n", datafilename);
     } else if (strcmp(key, "N") == 0) {
       fscanf(fp, "%d", &nlevels);
-      printf("[OK] # of resolution levels set: %d\n", nlevels);
     } else if (strcmp(key, "threshold") == 0) {
       fscanf(fp, "%lf", &threshold);
-      printf("[OK] Threshold set: %f\n", threshold);
     } else {
       printf("[!!] Key not recognised: %s\n", key);
       printf("[!!] Continue until known key is encountered\n");
     }
 
   }
-    
+
   fclose(fp);
 
   if (get_metadata(datafilename, &nrow, &ncol, &xllcorner, &yllcorner, &cellsize, &nodata)) {
@@ -77,6 +97,8 @@ int main(int argc, char** argv)
   int ncol_padded = ipow(2, powx);
   int nrow_padded = ipow(2, powy);
 
+  printf("[OK] Padded data to %d-by-%d\n", nrow_padded, ncol_padded);
+
   /* read in data */
   data = (double*) calloc(ncol_padded * nrow_padded, sizeof(double));
   for (int i = 0; i < nrow_padded; i ++) {
@@ -84,21 +106,21 @@ int main(int argc, char** argv)
       data[j + ncol_padded * i] = nodata;
     }
   }
-  
+
   if (get_data(datafilename, nrow, ncol, ncol_padded, data)) {
     return -1;
   }
 
-  /* 
+  /*
    * ----------------------------------------------------------------------
-   * Compression step 
+   * Compression step
    * ----------------------------------------------------------------------
    */
 
   double *m = (double*) calloc(ncol_padded * nrow_padded, sizeof(double));
   double *_data = (double*) calloc(ncol_padded * nrow_padded, sizeof(double));
   double *_m = (double*) calloc(ncol_padded * nrow_padded, sizeof(double));
-  
+
   memcpy(_data, data, ncol_padded * nrow_padded * sizeof(double));
 
   int _nrow = nrow_padded;
@@ -106,7 +128,7 @@ int main(int argc, char** argv)
 
   for (int n = 0; n < nlevels; n ++) {
 
-    /* 
+    /*
      * If non-divisible by 2, DHT can't be applied since it depends on
      * pair-wise comparisons. In this case, we exit with fail.
      */
@@ -118,10 +140,10 @@ int main(int argc, char** argv)
     /*
      * carry out the DHT
      */
-    
+
     compress(_data, _m, _nrow, _ncol);
-    
-    /* 
+
+    /*
      * Now get the new image matrix. We know that it is located at the
      * upper left corner of the compressed image M, and has dimensions
      * ncol/2 x nrow/2.
@@ -129,7 +151,7 @@ int main(int argc, char** argv)
 
     _nrow = _nrow / 2;
     _ncol = _ncol / 2;
-    
+
     /* Resize _data */
     _data = (double*) realloc(_data, _ncol * _nrow * sizeof(double));
 
@@ -155,7 +177,7 @@ int main(int argc, char** argv)
 
     char filename[1024];
     sprintf(filename, "output/m-%d.asc", n);
-    
+
     FILE *fp = fopen(filename, "w");
 
     for (int i = 0; i < 2 * _nrow; i ++) {
@@ -164,7 +186,7 @@ int main(int argc, char** argv)
       }
       fprintf(fp, "\n");
     }
-    
+
     fclose(fp);
 
 #endif
@@ -173,14 +195,14 @@ int main(int argc, char** argv)
 
     /* Resize _m */
     _m = (double*) realloc(_m, _ncol * _nrow * sizeof(double));
-    
+
     printf("[OK] M is resized\n");
-    
+
   }
 
-  /* 
+  /*
    * ----------------------------------------------------------------------
-   * Decompression step 
+   * Decompression step
    * ----------------------------------------------------------------------
    * Decompressing the DHT, in each level we look at the details and
    * see if they are significant.  i = 0 is the coarsest level, and
@@ -188,9 +210,9 @@ int main(int argc, char** argv)
    * respectively.
    * ----------------------------------------------------------------------
    */
-  
+
   int *levels = (int*) calloc(nrow_padded * ncol_padded, sizeof(int));
-  
+
   /* Set resolution level to highest at the beginning */
   for (int i = 0; i < nrow_padded; i ++) {
     for (int j = 0; j < ncol_padded; j ++) {
@@ -208,9 +230,9 @@ int main(int argc, char** argv)
       _m[j + _ncol * i] = m[j + i * ncol_padded];
     }
   }
-  
+
   int *flag = (int*) calloc(_nrow * _ncol / 4, sizeof(double));
-  
+
   for (int n = 0; n < nlevels; n ++) {
 
     printf("[OK] Thresholding image at level %d\n", n);
@@ -221,28 +243,28 @@ int main(int argc, char** argv)
     /* Tag cells that are sufficiently refined */
     for (int i = 0; i < _nrow/2; i ++) {
       for (int j = 0; j < _ncol/2; j ++) {
-	
+
 	if (flag[j + i * _ncol/2] == 1) {
 
 	  int coef = ipow(2, nlevels - n);
-	  
+
 	  if (levels[coef * j + coef * i * ncol_padded] > n) {
-	    
+
 	    for (int m = coef * i; m < coef * i + coef; m ++) {
 	      for (int p = coef * j; p < coef * j + coef; p ++) {
 		levels[p + m * ncol_padded] = n;
 	      }
 	    }
-	    
+
 	  }
-	  
+
 	}
-	
+
       }
     }
 
 #if DEBUG_IO
-    
+
     char filename[1024];
     sprintf(filename, "f-%d.asc", n);
 
@@ -254,11 +276,11 @@ int main(int argc, char** argv)
       }
       fprintf(fp, "\n");
     }
-    
+
     fclose(fp);
 
 #endif
-    
+
     /* Decompress the blur image to move to the next refinement level */
     decompress(_m, _nrow, _ncol);
 
@@ -271,7 +293,7 @@ int main(int argc, char** argv)
 
     printf("[OK] M is transferred\n");
 
-    /* 
+    /*
      * Adjust the dimensions. We are now refining so _ncol and _nrow
      * need to be doubled
      */
@@ -280,7 +302,7 @@ int main(int argc, char** argv)
 
     /* Resize _m */
     _m = (double*) realloc(_m, _ncol * _nrow * sizeof(double));
-    
+
     printf("[OK] M is resized\n");
 
     /* Transfer m back */
@@ -296,7 +318,7 @@ int main(int argc, char** argv)
     flag = (int*) realloc(flag, (_nrow * _ncol / 4) * sizeof(double));
 
     printf("[OK] Flag is resized\n");
-    
+
   }
 
   /*
@@ -309,8 +331,8 @@ int main(int argc, char** argv)
   FILE *mptr; /* Terrain data */
   mptr = fopen("output/m.asc", "w");
 #endif
-  
-  FILE *lptr; /* Level data   */  
+
+  FILE *lptr; /* Level data   */
   lptr = fopen("output/l.asc", "w");
 
   for (int i = 0; i < nrow_padded; i ++) {
@@ -326,16 +348,16 @@ int main(int argc, char** argv)
     fprintf(lptr, "\n");
   }
 
-  /* 
+  /*
    * ----------------------------------------------------------------------
-   * Housekeeping 
+   * Housekeeping
    * ----------------------------------------------------------------------
    */
 
 #if DEBUG_IO
   fclose(mptr);
 #endif
-  
+
   fclose(lptr);
 
   free(levels);
@@ -343,22 +365,22 @@ int main(int argc, char** argv)
   free(_data);
   free(m);
   free(data);
-  
+
   printf("[OK] Finished successfully\n");
 
   return 0;
-  
+
 }
 
 /*
- * Functions related to reading in the data set 
+ * Functions related to reading in the data set
  */
 
 int get_metadata(char *datafilename, int *nrow, int *ncol, double *xllcorner, double *yllcorner, double *cellsize, double *nodata)
 {
 
   FILE *dp;
-  
+
   printf("[OK] Reading in: %s\n", datafilename);
   dp = fopen(datafilename, "r");
 
@@ -368,42 +390,36 @@ int get_metadata(char *datafilename, int *nrow, int *ncol, double *xllcorner, do
   }
 
   char key[1024];
-  
+
   while (fscanf(dp, "%s", key) != EOF) {
-    
+
     if (strcmp(key, "ncols") == 0) {
       fscanf(dp, "%d", ncol);
-      printf("[OK] # of columns set: %d\n", *ncol);
     } else if (strcmp(key, "nrows") == 0) {
       fscanf(dp, "%d", nrow);
-      printf("[OK] # of rows set: %d\n", *nrow);
     } else if (strcmp(key, "xllcorner") == 0) {
       fscanf(dp, "%lf", xllcorner);
-      printf("[OK] x-coordinate of lower left corner set: %lf\n", *xllcorner);
     } else if (strcmp(key, "yllcorner") == 0) {
       fscanf(dp, "%lf", yllcorner);
-      printf("[OK] y-coordinate of lower left corner set: %lf\n", *yllcorner);
     } else if (strcmp(key, "cellsize") == 0) {
       fscanf(dp, "%lf", cellsize);
-      printf("[OK] cell size set: %lf\n", *cellsize);
     } else if (strcmp(key, "nodata_value") == 0) {
       fscanf(dp, "%lf", nodata);
-      printf("[OK] No data value set: %lf\n", *nodata);
       return 0;
     } else {
       printf("[!!] Key not recognised: %s\n", key);
       printf("[!!] Continue until known key is encountered\n");
     }
-    
+
   }
 
   fclose(dp);
-  
+
   return 0;
 }
 
 int get_data(char *datafilename, int nrow, int ncol, int ncol_padded, double *data) {
-  
+
   FILE *dp;
   dp = fopen(datafilename, "r");
 
@@ -418,7 +434,7 @@ int get_data(char *datafilename, int nrow, int ncol, int ncol_padded, double *da
   while (fscanf(dp, "%s", key) != EOF) {
 
     if (strcmp(key, "nodata_value") == 0) {
-      
+
       fscanf(dp, "%lf", &nodata);
       printf("[OK] Starting to read data\n");
 
@@ -427,16 +443,16 @@ int get_data(char *datafilename, int nrow, int ncol, int ncol_padded, double *da
 	  fscanf(dp, "%lf", &data[j + ncol_padded * i]);
 	}
       }
-      
+
     }
-    
+
   }
 
   return 0;
-  
+
 }
 
-/* 
+/*
  * Functions related to discrete Haar wavelet transform
  */
 
@@ -456,13 +472,13 @@ int compress(double* data, double *m, int nrow, int ncol)
   /*
    * Get the coefficient matrix for left matrix multiplication:
    *
-   * C = Wm A 
+   * C = Wm A
    *
    * This matrix needs to have dimension `nrow x nrow'. After that,
    * carry out the matrix multiplication to get the column-compressed
    * matrix C.
    */
-  
+
   double *wm;
   wm = (double*) calloc(nrow * nrow, sizeof(double));
 
@@ -470,7 +486,7 @@ int compress(double* data, double *m, int nrow, int ncol)
 
   double *c;
   c = (double*) calloc(nrow * ncol, sizeof(double));
-  
+
   matmul(wm, nrow, nrow, data, nrow, ncol, c);
 
   /*
@@ -481,7 +497,7 @@ int compress(double* data, double *m, int nrow, int ncol)
    *
    * This will compress the image one level.
    */
-  
+
   double *wn;
   wn = (double*) calloc(ncol * ncol, sizeof(double));
 
@@ -500,20 +516,20 @@ int compress(double* data, double *m, int nrow, int ncol)
 int decompress(double *data, int nrow, int ncol) {
 
   printf("[OK] Decompressing a %d-by-%d matrix\n", nrow, ncol);
-  
+
   double *wm = (double*) calloc(nrow * nrow, sizeof(double));
   double *wn = (double*) calloc(ncol * ncol, sizeof(double));
-  
+
   double *c1 = (double*) calloc(nrow * ncol, sizeof(double));
   double *c2 = (double*) calloc(nrow * ncol, sizeof(double));
-  
+
   /* Reconstruct the DHT to move to finer resolution */
-  
+
   get_wavelet_matrix(wm, nrow);
   get_wavelet_matrix(wn, ncol);
 
   transpose(wm, nrow, nrow);
-    
+
   matmul(wm, nrow, nrow, data, nrow, ncol, c1);
   matmul(c1, nrow, ncol, wn, ncol, ncol, c2);
 
@@ -527,12 +543,12 @@ int decompress(double *data, int nrow, int ncol) {
   free(wn);
   free(c1);
   free(c2);
-  
+
   return 0;
 }
 
 int hard_threshold(double *m, int *flag, int n, int nlevels, int nrow, int ncol, double threshold) {
-  /* 
+  /*
    * Hard thresholding as explained in (Caviedes-Voullieme and
    * Kesserwani, 2015: Benchmarking a multi-resolution discontinuous
    * Galerkin shallow water model, Advances in Water Resources,
@@ -566,20 +582,20 @@ int hard_threshold(double *m, int *flag, int n, int nlevels, int nrow, int ncol,
       double abs_v = 0.0;
       double abs_h = 0.0;
       double abs_d = 0.0;
-            
+
       _b = m[j + ncol * i];
       _v = m[(j + ncol/2) + ncol * i];
       _h = m[j + ncol * (nrow/2 + i)];
       _d = m[(j + ncol/2) + ncol * (nrow/2 + i)];
 
       /* printf(">>> %d %d %f %f %f %f\n", j, i, _b, _v, _h, _d); */
-      
+
       abs_b = fabs(_b);
       max_b = (max_b < abs_b) ? abs_b : max_b;
 
       abs_v = fabs(_v);
       max_v = (max_v < abs_v) ? abs_v : max_v;
-      
+
       abs_h = fabs(_h);
       max_h = (max_h < abs_h) ? abs_h : max_h;
 
@@ -602,9 +618,9 @@ int hard_threshold(double *m, int *flag, int n, int nlevels, int nrow, int ncol,
 	/* Can't be coarsened */
 	flag[j + (ncol/2) * i] = -1;
       }
-      
+
     }
   }
-    
+
   return 0;
 }