filter.c File Reference

Filter subroutine. Uses hanning and wrap edges. More...

#include <filter.h>
Include dependency graph for filter.c:

Go to the source code of this file.

Functions

void filter (double *bufferf, double *buffer, char *type, int width, int ni, int nj, int nt)
 Filter master subroutine.

Detailed Description

Filter subroutine. Uses hanning and wrap edges.

Definition in file filter.c.


Function Documentation

void filter ( double *  bufferf,
double *  buffer,
char *  type,
int  width,
int  ni,
int  nj,
int  nt 
)

Filter master subroutine.

Uses wrap edges.

Parameters:
[out] bufferf Filtered version of buffer input matrix.
[in] buffer Input matrix.
[in] type Type of filter. Possible values: hanning.
[in] width Width of filter.
[in] ni Horizontal dimension of buffer input matrix.
[in] nj Horizontal dimension of buffer input matrix.
[in] nt Temporal dimension of buffer input matrix.

Definition at line 58 of file filter.c.

References alloc_error(), filter(), and filter_window().

Referenced by filter(), main(), and remove_seasonal_cycle().

00058                                                                                        {
00069   double *filter = NULL; /* Filter window vector */
00070   double *tmpvec = NULL; /* Temporary vector */
00071 
00072   int half_width; /* Half-width of filter window. */
00073   int i; /* Loop counter for ni. */
00074   int j; /* Loop counter for nj. */
00075   int t; /* Loop counter. */
00076   int tt; /* Loop counter. */
00077 
00078   double sum; /* To sum values over filter window width. */
00079 
00080   /*  (void) fprintf(stdout, "%s: Filtering data with a %s filter.\n", __FILE__, type);*/
00081 
00082   if ( !strcmp(type, "hanning") ) {
00083     /* Hanning filter implementation */
00084 
00085     /* Compute filter window vector */
00086     (void) filter_window(&filter, type, width);
00087     
00088     /* Half-width */
00089     half_width = ( width - 1 ) / 2;
00090     
00091     /* Expanded version of vector: wrapping edges. */
00092     tmpvec = (double *) calloc(nt*2, sizeof(double));
00093     if (tmpvec == NULL) alloc_error(__FILE__, __LINE__);
00094 
00095     for (j=0; j<nj; j++)
00096       for (i=0; i<ni; i++) {
00097         
00098         for (t=0; t<half_width; t++) {
00099           tmpvec[t] = buffer[i+j*ni+(nt-half_width+t)*ni*nj];
00100         }
00101         for (t=half_width; t<(half_width+nt); t++) {
00102           tmpvec[t] = buffer[i+j*ni+(t-half_width)*ni*nj];
00103         }
00104         for (t=(half_width+nt); t<(nt*2); t++) {
00105           tmpvec[t] = buffer[i+j*ni+(t-(half_width+nt))*ni*nj];
00106         }
00107         
00108         /* Apply filter. */
00109         for (t=0; t<nt; t++) {
00110           sum = 0.0;
00111           for (tt=t; tt<(t+width-1); tt++)
00112             sum += (filter[tt-t] * tmpvec[tt]);
00113           bufferf[i+j*ni+t*ni*nj] = sum;
00114         }
00115       }
00116     
00117     /* Free memory */
00118     (void) free(filter);
00119     (void) free(tmpvec);
00120   }
00121   else {
00122     /* Unknown filter type */
00123     (void) fprintf(stderr, "%s: ABORT: Unknown filtering type: %s\n", __FILE__, type);
00124     (void) abort();
00125   }
00126 }


Generated on 12 May 2016 for DSCLIM by  doxygen 1.6.1