test_mean_variance_dist_clusters.c File Reference

Test program for mean_variance_dist_clusters. More...

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <libgen.h>
#include <zlib.h>
#include <hdf5.h>
#include <netcdf.h>
#include <udunits.h>
#include <utils.h>
#include <filter.h>
#include <clim.h>
#include <classif.h>
#include <pceof.h>
#include <gsl/gsl_statistics.h>
Include dependency graph for test_mean_variance_dist_clusters.c:

Go to the source code of this file.

Defines

#define _GNU_SOURCE
 GNU extensions.

Functions

void show_usage (char *pgm)
 C prototypes.
void handle_netcdf_error (int status, int lineno)
int main (int argc, char **argv)
 Main program.

Detailed Description

Test program for mean_variance_dist_clusters.

Definition in file test_mean_variance_dist_clusters.c.


Define Documentation

#define _GNU_SOURCE

GNU extensions.

Definition at line 59 of file test_mean_variance_dist_clusters.c.


Function Documentation

int main ( int  argc,
char **  argv 
)

Main program.

Parameters:
[in] argc Number of command-line arguments.
[in] argv Vector of command-line argument strings.
Returns:
Status.

Read dimensions variables

Read data variable

Close NetCDF files

Dimensions function of season

Variables function of season

Dimensions

Variables

Close NetCDF files

Definition at line 112 of file test_mean_variance_dist_clusters.c.

References alloc_error(), banner(), handle_netcdf_error(), mean_variance_dist_clusters(), normalize_pc(), show_usage(), and sub_period_common().

00113 {
00121   //  int nlat;
00122   // int nlon;
00123   //  int nlat_sub;
00124   //int nlon_sub;
00125   int ntime;
00126   int neof;
00127   int neof_poid;
00128   int neof_learn;
00129   int npts_learn;
00130   int nseason_learn;
00131   int *nclust_learn = NULL;
00132   int *ntime_learn = NULL;
00133   int *nclust = NULL;
00134 
00135   size_t dimval;
00136 
00137   char *filein = NULL;
00138   char *filein_poid = NULL;
00139   char *filein_learn = NULL;
00140 
00141   int istat, ncinid, ncinid_poid, ncinid_learn;
00142   int varinid, timeinid, timediminid;
00143   //  int loninid, londiminid, latinid, latdiminid;
00144   int eofdiminid;
00145   int eofdiminid_poid;
00146   int eofdiminid_learn, ptsdiminid_learn, seasondiminid_learn;
00147   int *clust_dimid = NULL;
00148   int *time_learn_dimid = NULL;
00149   int *clust_learn_dimid = NULL;
00150   int *time_learn_varid = NULL;
00151   int *cst_varid = NULL;
00152   int *reg_varid = NULL;
00153   int *rrd_varid = NULL;
00154   int *ta_varid = NULL;
00155   int eca_pc_learn_varid;
00156   int *clust_varid = NULL;
00157   int *poid_varid = NULL;
00158   int tancp_mean_varid, tancp_var_varid;
00159   nc_type vartype_main;
00160   nc_type vartype_time;
00161   int varndims;
00162   int vardimids[NC_MAX_VAR_DIMS];    /* dimension ids */
00163 
00164   size_t start[3];
00165   size_t count[3];
00166 
00167   size_t t_len;
00168   char *time_units = NULL;
00169   char *cal_type = NULL;
00170   ut_system *unitSystem = NULL; /* Unit System (udunits) */
00171   ut_unit *dataunits = NULL; /* udunits variable */
00172 
00173   char attname[1000];
00174   float valf;
00175 
00176   double *psl_pc = NULL;
00177   double *buf_sub = NULL;
00178   double *buftmp = NULL;
00179   int ntime_sub;
00180   double *timein = NULL;
00181   int *year = NULL;
00182   int *month = NULL;
00183   int *day = NULL;
00184   int *hour = NULL;
00185   int *min = NULL;
00186   double *sec = NULL;
00187   //  double *lat = NULL;
00188   // double *lon = NULL;
00189 
00190   double **poid = NULL;
00191   double **time_learn = NULL;
00192   int **year_learn = NULL;
00193   int **month_learn = NULL;
00194   int **day_learn = NULL;
00195   int **hour_learn = NULL;
00196   int **min_learn = NULL;
00197   double **sec_learn = NULL;
00198   double **cst_learn = NULL;
00199   double **reg_learn = NULL;
00200   double **rrd_learn = NULL;
00201   double **ta_learn = NULL;
00202   double *eca_pc_learn = NULL;
00203   double *tancp_mean = NULL;
00204   double *tancp_var = NULL;
00205 
00206   double **mean_dist = NULL;
00207   double **var_dist = NULL;
00208 
00209   double *var_pc_norm_all = NULL;
00210 
00211   double fillvalue_poid;
00212   double fillvalue_cst;
00213   double fillvalue_reg;
00214   double fillvalue_rrd;
00215   double fillvalue_ta;
00216 
00217   double first_variance = -9999.9999;
00218   
00219   char varname[500];
00220 
00221   int nseason = 4;
00222 
00223   int i;
00224   int t;
00225   int ii;
00226 
00227   /* Print BEGIN banner */
00228   (void) banner(basename(argv[0]), "1.0", "BEGIN");
00229 
00230   /* Get command-line arguments and set appropriate variables */
00231   for (i=1; i<argc; i++) {
00232     if ( !strcmp(argv[i], "-h") ) {
00233       (void) show_usage(basename(argv[0]));
00234       (void) banner(basename(argv[0]), "OK", "END");
00235       return 0;
00236     }
00237     else if ( !strcmp(argv[i], "-i") ) {
00238       filein = (char *) malloc((strlen(argv[++i])+1) * sizeof(char));
00239       if (filein == NULL) alloc_error(__FILE__, __LINE__);
00240       (void) strcpy(filein, argv[i]);
00241     }
00242     else if ( !strcmp(argv[i], "-i_poid") ) {
00243       filein_poid = (char *) malloc((strlen(argv[++i])+1) * sizeof(char));
00244       if (filein_poid == NULL) alloc_error(__FILE__, __LINE__);
00245       (void) strcpy(filein_poid, argv[i]);
00246     }
00247     else if ( !strcmp(argv[i], "-i_learn") ) {
00248       filein_learn = (char *) malloc((strlen(argv[++i])+1) * sizeof(char));
00249       if (filein_learn == NULL) alloc_error(__FILE__, __LINE__);
00250       (void) strcpy(filein_learn, argv[i]);
00251     }
00252     else {
00253       (void) fprintf(stderr, "%s:: Wrong arg %s.\n\n", basename(argv[0]), argv[i]);
00254       (void) show_usage(basename(argv[0]));
00255       (void) banner(basename(argv[0]), "ABORT", "END");
00256       (void) abort();
00257     }
00258   }
00259 
00260   /* Initialize udunits */
00261   ut_set_error_message_handler(ut_ignore);
00262   unitSystem = ut_read_xml(NULL);
00263   ut_set_error_message_handler(ut_write_to_stderr);
00264 
00265   /* Read data in NetCDF file */
00266   printf("%s: Reading info from input file %s.\n", __FILE__, filein);
00267   istat = nc_open(filein, NC_NOWRITE, &ncinid);  /* open for reading */
00268   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00269 
00270   istat = nc_inq_dimid(ncinid, "time", &timediminid);  /* get ID for time dimension */
00271   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00272   istat = nc_inq_dimlen(ncinid, timediminid, &dimval); /* get time length */
00273   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00274   ntime = (int) dimval;
00275 
00276   istat = nc_inq_dimid(ncinid, "eof", &eofdiminid);  /* get ID for eof dimension */
00277   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00278   istat = nc_inq_dimlen(ncinid, eofdiminid, &dimval); /* get lon length */
00279   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00280   neof = (int) dimval;
00281   
00282   istat = nc_inq_varid(ncinid, "time", &timeinid);  /* get ID for time variable */
00283   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00284 
00285   istat = nc_inq_varid(ncinid, "pc_proj", &varinid); /* get variable ID */
00286   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00287 
00289   /* Allocate memory and set start and count */
00290 
00291   /* Get time dimensions and type */
00292   istat = nc_inq_var(ncinid, timeinid, (char *) NULL, &vartype_time, &varndims, vardimids, (int *) NULL); /* get variable information */
00293   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00294   
00295   if (varndims != 1) {
00296     (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00297     (void) banner(basename(argv[0]), "ABORT", "END");
00298     (void) abort();
00299   }
00300 
00301   /* Allocate memory and set start and count */
00302   start[0] = 0;
00303   count[0] = (size_t) ntime;
00304   timein = malloc(ntime * sizeof(double));
00305   if (timein == NULL) alloc_error(__FILE__, __LINE__);
00306 
00307   /* Read values from netCDF variable */
00308   istat = nc_get_vara_double(ncinid, timeinid, start, count, timein);
00309   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00310 
00311   /* Check values of time variable because many times they are all zero. In that case assume a 1 increment and a start at zero. */
00312   for (t=0; t<ntime; t++)
00313     if (timein[t] != 0.0)
00314       break;
00315   if (t == ntime) {
00316     fprintf(stderr, "WARNING: Time variable values all zero!!! Fixing time variable to index value...\n");
00317     for (t=0; t<ntime; t++)
00318       timein[t] = (double) t;
00319   }
00320 
00323   /* Get variable information */
00324   istat = nc_inq_var(ncinid, varinid, (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00325   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00326 
00327   if (varndims != 2) {
00328     (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00329     (void) banner(basename(argv[0]), "ABORT", "END");
00330     (void) abort();
00331   }
00332 
00333   /* Allocate memory and set start and count */
00334   start[0] = 0;
00335   start[1] = 0;
00336   start[2] = 0;
00337   count[0] = (size_t) ntime;
00338   count[1] = (size_t) neof;
00339   count[2] = 0;
00340   /* Allocate memory */
00341   psl_pc = (double *) calloc(ntime*neof, sizeof(double));
00342   if (psl_pc == NULL) alloc_error(__FILE__, __LINE__);
00343 
00344   /* Read values from netCDF variable */
00345   printf("%s: Reading data from input file %s.\n", __FILE__, filein);
00346   istat = nc_get_vara_double(ncinid, varinid, start, count, psl_pc);
00347   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00348 
00349 
00350   /* Get time units attribute length */
00351   istat = nc_inq_attlen(ncinid, timeinid, "units", &t_len);
00352   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00353   /* Allocate required space before retrieving values */
00354   time_units = (char *) malloc(t_len * sizeof(char));
00355   if (time_units == NULL) alloc_error(__FILE__, __LINE__);
00356   /* Get time units attribute value */
00357   istat = nc_get_att_text(ncinid, timeinid, "units", time_units);
00358   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00359   time_units[t_len-2] = '\0'; /* null terminate */
00360 
00361   /* Get calendar type attribute length */
00362   istat = nc_inq_attlen(ncinid, timeinid, "calendar", &t_len);
00363   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00364   /* Allocate required space before retrieving values */
00365   cal_type = (char *) malloc(t_len + 1);
00366   if (cal_type == NULL) alloc_error(__FILE__, __LINE__);
00367   /* Get calendar type attribute value */
00368   istat = nc_get_att_text(ncinid, timeinid, "calendar", cal_type);
00369   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00370   cal_type[t_len] = '\0'; /* null terminate */
00371 
00372   /* Compute time info */
00373 
00374   year = (int *) malloc(ntime * sizeof(int));
00375   if (year == NULL) alloc_error(__FILE__, __LINE__);
00376   month = (int *) malloc(ntime * sizeof(int));
00377   if (month == NULL) alloc_error(__FILE__, __LINE__);
00378   day = (int *) malloc(ntime * sizeof(int));
00379   if (day == NULL) alloc_error(__FILE__, __LINE__);
00380   hour = (int *) malloc(ntime * sizeof(int));
00381   if (hour == NULL) alloc_error(__FILE__, __LINE__);
00382   min = (int *) malloc(ntime * sizeof(int));
00383   if (min == NULL) alloc_error(__FILE__, __LINE__);
00384   sec = (double *) malloc(ntime * sizeof(double));
00385   if (sec == NULL) alloc_error(__FILE__, __LINE__);
00386 
00387   dataunits = ut_parse(unitSystem, time_units, UT_ASCII);
00388   for (t=0; t<ntime; t++)
00389     istat = utCalendar2_cal(timein[t], dataunits, &(year[t]), &(month[t]), &(day[t]), &(hour[t]), &(min[t]), &(sec[t]), cal_type);
00390   (void) free(time_units);
00391   (void) ut_free(dataunits);
00392   (void) free(cal_type);
00393 
00394   /* Read data in NetCDF file */
00395   printf("%s: Reading info from input file %s.\n", __FILE__, filein_poid);
00396   istat = nc_open(filein_poid, NC_NOWRITE, &ncinid_poid);  /* open for reading */
00397   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00398 
00399   istat = nc_inq_dimid(ncinid_poid, "eof", &eofdiminid_poid);  /* get ID for eof dimension */
00400   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00401   istat = nc_inq_dimlen(ncinid_poid, eofdiminid_poid, &dimval); /* get eof length */
00402   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00403   neof_poid = (int) dimval;
00404 
00405   clust_dimid = malloc(nseason * sizeof(int));
00406   if (clust_dimid == NULL) alloc_error(__FILE__, __LINE__);
00407   poid_varid = malloc(nseason * sizeof(int));
00408   if (poid_varid == NULL) alloc_error(__FILE__, __LINE__);
00409 
00410   clust_varid = malloc(nseason * sizeof(int));
00411   if (clust_varid == NULL) alloc_error(__FILE__, __LINE__);
00412 
00413   nclust = malloc(nseason * sizeof(int));
00414   if (nclust == NULL) alloc_error(__FILE__, __LINE__);
00415 
00416   poid = (double **) malloc(nseason * sizeof(double *));
00417   if (poid == NULL) alloc_error(__FILE__, __LINE__);
00418 
00419   for (i=0; i<nseason; i++) {
00420     if (i == 0)
00421       (void) strcpy(varname, "clust_aut");
00422     else if (i == 1)
00423       (void) strcpy(varname, "clust_hiv");
00424     else if (i == 2)
00425       (void) strcpy(varname, "clust_pri");
00426     else if (i == 3)
00427       (void) strcpy(varname, "clust_ete");
00428     else
00429       exit(1);
00430     istat = nc_inq_dimid(ncinid_poid, varname, &(clust_dimid[i]));  /* get ID for clust_aut dimension */
00431     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00432     istat = nc_inq_dimlen(ncinid_poid, clust_dimid[i], &dimval); /* get dimension length */
00433     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00434     nclust[i] = (int) dimval;
00435   
00436     if (i == 0)
00437       (void) strcpy(varname, "poid_aut");
00438     else if (i == 1)
00439       (void) strcpy(varname, "poid_hiv");
00440     else if (i == 2)
00441       (void) strcpy(varname, "poid_pri");
00442     else if (i == 3)
00443       (void) strcpy(varname, "poid_ete");
00444     else
00445       exit(1);
00446     istat = nc_inq_varid(ncinid_poid, varname, &(poid_varid[i])); /* get poid variable ID */
00447     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00448 
00449     /* Get variable information */
00450     istat = nc_inq_var(ncinid_poid, poid_varid[i], (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00451     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00452     
00453     if (varndims != 2) {
00454       (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00455       (void) banner(basename(argv[0]), "ABORT", "END");
00456       (void) abort();
00457     }
00458 
00459     /* Get missing value and assume the same for all seasons */
00460     if (i == 0) {
00461       (void) strcpy(attname, "missing_value");
00462       if (vartype_main == NC_FLOAT) {
00463         istat = nc_get_att_float(ncinid_poid, poid_varid[0], attname, &valf);
00464         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00465         fillvalue_poid = (double) valf;
00466       }
00467       else if (vartype_main == NC_DOUBLE) {
00468         istat = nc_get_att_double(ncinid_poid, poid_varid[0], attname, &fillvalue_poid);
00469         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00470       }
00471     }
00472 
00473     /* Allocate memory and set start and count */
00474     start[0] = 0;
00475     start[1] = 0;
00476     start[2] = 0;
00477     count[0] = (size_t) nclust[i];
00478     count[1] = (size_t) neof_poid;
00479     count[2] = (size_t) 0;
00480     /* Allocate memory */
00481     poid[i] = (double *) calloc(nclust[i] * neof_poid, sizeof(double));
00482     if (poid[i] == NULL) alloc_error(__FILE__, __LINE__);
00483     
00484     /* Read values from netCDF variable */
00485     printf("%s: Reading data from input file %s.\n", __FILE__, filein_poid);
00486     istat = nc_get_vara_double(ncinid_poid, poid_varid[i], start, count, poid[i]);
00487     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00488 
00489   }
00490 
00491 
00493   /* Close the intput netCDF file. */
00494   istat = ncclose(ncinid_poid);
00495   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00496 
00497 
00498   /* Read data in NetCDF file */
00499   printf("%s: Reading info from input file %s.\n", __FILE__, filein_learn);
00500   istat = nc_open(filein_learn, NC_NOWRITE, &ncinid_learn);  /* open for reading */
00501   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00502 
00503   istat = nc_inq_dimid(ncinid_learn, "eof", &eofdiminid_learn);  /* get ID for eof dimension */
00504   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00505   istat = nc_inq_dimlen(ncinid_learn, eofdiminid_learn, &dimval); /* get eof length */
00506   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00507   neof_learn = (int) dimval;
00508 
00509   istat = nc_inq_dimid(ncinid_learn, "pts", &ptsdiminid_learn);  /* get ID for pts dimension */
00510   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00511   istat = nc_inq_dimlen(ncinid_learn, ptsdiminid_learn, &dimval); /* get pts length */
00512   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00513   npts_learn = (int) dimval;
00514 
00515   istat = nc_inq_dimid(ncinid_learn, "season", &seasondiminid_learn);  /* get ID for season dimension */
00516   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00517   istat = nc_inq_dimlen(ncinid_learn, seasondiminid_learn, &dimval); /* get season length */
00518   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00519   nseason_learn = (int) dimval;
00520 
00522   time_learn_dimid = malloc(nseason_learn * sizeof(int));
00523   if (time_learn_dimid == NULL) alloc_error(__FILE__, __LINE__);
00524   time_learn_varid = malloc(nseason_learn * sizeof(int));
00525   if (time_learn_varid == NULL) alloc_error(__FILE__, __LINE__);
00526   clust_learn_dimid = malloc(nseason_learn * sizeof(int));
00527   if (clust_learn_dimid == NULL) alloc_error(__FILE__, __LINE__);
00528 
00529   cst_varid = malloc(nseason_learn * sizeof(int));
00530   if (cst_varid == NULL) alloc_error(__FILE__, __LINE__);
00531   reg_varid = malloc(nseason_learn * sizeof(int));
00532   if (reg_varid == NULL) alloc_error(__FILE__, __LINE__);
00533   rrd_varid = malloc(nseason_learn * sizeof(int));
00534   if (rrd_varid == NULL) alloc_error(__FILE__, __LINE__);
00535   ta_varid = malloc(nseason_learn * sizeof(int));
00536   if (ta_varid == NULL) alloc_error(__FILE__, __LINE__);
00537 
00538   nclust_learn = malloc(nseason_learn * sizeof(int));
00539   if (nclust_learn == NULL) alloc_error(__FILE__, __LINE__);
00540   ntime_learn = malloc(nseason_learn * sizeof(int));
00541   if (ntime_learn == NULL) alloc_error(__FILE__, __LINE__);
00542 
00544   time_learn = (double **) malloc(nseason_learn * sizeof(double *));
00545   if (time_learn == NULL) alloc_error(__FILE__, __LINE__);
00546   cst_learn = (double **) malloc(nseason_learn * sizeof(double *));
00547   if (cst_learn == NULL) alloc_error(__FILE__, __LINE__);
00548   reg_learn = (double **) malloc(nseason_learn * sizeof(double *));
00549   if (reg_learn == NULL) alloc_error(__FILE__, __LINE__);
00550   rrd_learn = (double **) malloc(nseason_learn * sizeof(double *));
00551   if (rrd_learn == NULL) alloc_error(__FILE__, __LINE__);
00552   ta_learn = (double **) malloc(nseason_learn * sizeof(double *));
00553   if (ta_learn == NULL) alloc_error(__FILE__, __LINE__);
00554 
00555   year_learn = (int **) malloc(nseason_learn * sizeof(int *));
00556   if (year_learn == NULL) alloc_error(__FILE__, __LINE__);
00557   month_learn = (int **) malloc(nseason_learn * sizeof(int *));
00558   if (month_learn == NULL) alloc_error(__FILE__, __LINE__);
00559   day_learn = (int **) malloc(nseason_learn * sizeof(int *));
00560   if (day_learn == NULL) alloc_error(__FILE__, __LINE__);
00561   hour_learn = (int **) malloc(nseason_learn * sizeof(int *));
00562   if (hour_learn == NULL) alloc_error(__FILE__, __LINE__);
00563   min_learn = (int **) malloc(nseason_learn * sizeof(int *));
00564   if (min_learn == NULL) alloc_error(__FILE__, __LINE__);
00565   sec_learn = (double **) malloc(nseason_learn * sizeof(double *));
00566   if (sec_learn == NULL) alloc_error(__FILE__, __LINE__);
00567 
00568   for (i=0; i<nseason_learn; i++) {
00569 
00571     if (i == 0)
00572       (void) strcpy(varname, "time_aut");
00573     else if (i == 1)
00574       (void) strcpy(varname, "time_hiv");
00575     else if (i == 2)
00576       (void) strcpy(varname, "time_pri");
00577     else if (i == 3)
00578       (void) strcpy(varname, "time_ete");
00579     else
00580       exit(1);
00581     istat = nc_inq_dimid(ncinid_learn, varname, &(time_learn_dimid[i]));  /* get ID for time_learn dimension */
00582     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00583     istat = nc_inq_dimlen(ncinid_learn, time_learn_dimid[i], &dimval); /* get dimension length */
00584     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00585     ntime_learn[i] = (int) dimval;
00586 
00587     istat = nc_inq_varid(ncinid_learn, varname, &(time_learn_varid[i]));  /* get ID for variable */
00588     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00589 
00590     /* Allocate memory and set start and count */
00591     start[0] = 0;
00592     start[1] = 0;
00593     start[2] = 0;
00594     count[0] = (size_t) ntime_learn[i];
00595     count[1] = (size_t) 0;
00596     count[2] = (size_t) 0;
00597     /* Allocate memory */
00598     time_learn[i] = (double *) calloc(ntime_learn[i], sizeof(double));
00599     if (time_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00600     
00601     /* Read values from netCDF variable */
00602     printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00603     istat = nc_get_vara_double(ncinid_learn, time_learn_varid[i], start, count, time_learn[i]);
00604     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00605     //    printf("%d %lf\n",i,time_learn[i][0]);
00606 
00607     /* Get variable information */
00608     istat = nc_inq_var(ncinid_learn, time_learn_varid[i], (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00609     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00610     
00611     if (varndims != 1) {
00612       (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00613       (void) banner(basename(argv[0]), "ABORT", "END");
00614       (void) abort();
00615     }
00616 
00617     /* Get time units attribute length */
00618     istat = nc_inq_attlen(ncinid_learn, time_learn_varid[i], "units", &t_len);
00619     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00620     /* Allocate required space before retrieving values */
00621     time_units = (char *) malloc(t_len * sizeof(char));
00622     if (time_units == NULL) alloc_error(__FILE__, __LINE__);
00623     /* Get time units attribute value */
00624     istat = nc_get_att_text(ncinid_learn, time_learn_varid[i], "units", time_units);
00625     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00626     time_units[t_len-2] = '\0'; /* null terminate */
00627     
00628     /* Get calendar type attribute length */
00629     istat = nc_inq_attlen(ncinid_learn, time_learn_varid[i], "calendar", &t_len);
00630     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00631     /* Allocate required space before retrieving values */
00632     cal_type = (char *) malloc(t_len + 1);
00633     if (cal_type == NULL) alloc_error(__FILE__, __LINE__);
00634     /* Get calendar type attribute value */
00635     istat = nc_get_att_text(ncinid_learn, time_learn_varid[i], "calendar", cal_type);
00636     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00637     cal_type[t_len] = '\0'; /* null terminate */
00638     
00639     /* Compute time info */
00640     year_learn[i] = (int *) malloc(ntime_learn[i] * sizeof(int));
00641     if (year_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00642     month_learn[i] = (int *) malloc(ntime_learn[i] * sizeof(int));
00643     if (month_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00644     day_learn[i] = (int *) malloc(ntime_learn[i] * sizeof(int));
00645     if (day_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00646     hour_learn[i] = (int *) malloc(ntime_learn[i] * sizeof(int));
00647     if (hour_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00648     min_learn[i] = (int *) malloc(ntime_learn[i] * sizeof(int));
00649     if (min_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00650     sec_learn[i] = (double *) malloc(ntime_learn[i] * sizeof(double));
00651     if (sec_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00652 
00653     dataunits = ut_parse(unitSystem, time_units, UT_ASCII);
00654     for (t=0; t<ntime_learn[i]; t++)
00655       istat = utCalendar2_cal(time_learn[i][t], dataunits,
00656                               &(year_learn[i][t]), &(month_learn[i][t]), &(day_learn[i][t]), &(hour_learn[i][t]),
00657                               &(min_learn[i][t]), &(sec_learn[i][t]), cal_type);
00658 
00659     (void) free(time_units);
00660     (void) ut_free(dataunits);
00661     (void) free(cal_type);
00662 
00663 
00664     if (i == 0)
00665       (void) strcpy(varname, "clust_aut");
00666     else if (i == 1)
00667       (void) strcpy(varname, "clust_hiv");
00668     else if (i == 2)
00669       (void) strcpy(varname, "clust_pri");
00670     else if (i == 3)
00671       (void) strcpy(varname, "clust_ete");
00672     else
00673       exit(1);
00674     istat = nc_inq_dimid(ncinid_learn, varname, &(clust_learn_dimid[i]));  /* get ID for clust_learn dimension */
00675     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00676     istat = nc_inq_dimlen(ncinid_learn, clust_learn_dimid[i], &dimval); /* get dimension length */
00677     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00678     nclust_learn[i] = (int) dimval;
00679   
00680 
00682     if (i == 0)
00683       (void) strcpy(varname, "cst_aut");
00684     else if (i == 1)
00685       (void) strcpy(varname, "cst_hiv");
00686     else if (i == 2)
00687       (void) strcpy(varname, "cst_pri");
00688     else if (i == 3)
00689       (void) strcpy(varname, "cst_ete");
00690     else
00691       exit(1);
00692     istat = nc_inq_varid(ncinid_learn, varname, &(cst_varid[i])); /* get cst variable ID */
00693     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00694 
00695     /* Get variable information */
00696     istat = nc_inq_var(ncinid_learn, cst_varid[i], (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00697     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00698     
00699     if (varndims != 1) {
00700       (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00701       (void) banner(basename(argv[0]), "ABORT", "END");
00702       (void) abort();
00703     }
00704 
00705     /* Get missing value and assume the same for all seasons */
00706     if (i == 0) {
00707       (void) strcpy(attname, "missing_value");
00708       if (vartype_main == NC_FLOAT) {
00709         istat = nc_get_att_float(ncinid_learn, cst_varid[0], attname, &valf);
00710         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00711         fillvalue_cst = (double) valf;
00712       }
00713       else if (vartype_main == NC_DOUBLE) {
00714         istat = nc_get_att_double(ncinid_learn, cst_varid[0], attname, &fillvalue_cst);
00715         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00716       }
00717     }
00718 
00719     /* Allocate memory and set start and count */
00720     start[0] = 0;
00721     start[1] = 0;
00722     start[2] = 0;
00723     count[0] = (size_t) npts_learn;
00724     count[1] = (size_t) 0;
00725     count[2] = (size_t) 0;
00726     /* Allocate memory */
00727     cst_learn[i] = (double *) calloc(npts_learn, sizeof(double));
00728     if (cst_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00729     
00730     /* Read values from netCDF variable */
00731     printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00732     istat = nc_get_vara_double(ncinid_learn, cst_varid[i], start, count, cst_learn[i]);
00733     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00734 
00735 
00736     if (i == 0)
00737       (void) strcpy(varname, "reg_aut");
00738     else if (i == 1)
00739       (void) strcpy(varname, "reg_hiv");
00740     else if (i == 2)
00741       (void) strcpy(varname, "reg_pri");
00742     else if (i == 3)
00743       (void) strcpy(varname, "reg_ete");
00744     else
00745       exit(1);
00746     istat = nc_inq_varid(ncinid_learn, varname, &(reg_varid[i])); /* get reg variable ID */
00747     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00748 
00749     /* Get variable information */
00750     istat = nc_inq_var(ncinid_learn, reg_varid[i], (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00751     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00752     
00753     if (varndims != 2) {
00754       (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00755       (void) banner(basename(argv[0]), "ABORT", "END");
00756       (void) abort();
00757     }
00758 
00759     /* Get missing value and assume the same for all seasons */
00760     if (i == 0) {
00761       (void) strcpy(attname, "missing_value");
00762       if (vartype_main == NC_FLOAT) {
00763         istat = nc_get_att_float(ncinid_learn, reg_varid[0], attname, &valf);
00764         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00765         fillvalue_reg = (double) valf;
00766       }
00767       else if (vartype_main == NC_DOUBLE) {
00768         istat = nc_get_att_double(ncinid_learn, reg_varid[0], attname, &fillvalue_reg);
00769         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00770       }
00771     }
00772 
00773     /* Allocate memory and set start and count */
00774     start[0] = 0;
00775     start[1] = 0;
00776     start[2] = 0;
00777     count[0] = (size_t) nclust_learn[i];
00778     count[1] = (size_t) npts_learn;
00779     count[2] = (size_t) 0;
00780     /* Allocate memory */
00781     reg_learn[i] = (double *) calloc(nclust_learn[i] * npts_learn, sizeof(double));
00782     if (reg_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00783     
00784     /* Read values from netCDF variable */
00785     printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00786     istat = nc_get_vara_double(ncinid_learn, reg_varid[i], start, count, reg_learn[i]);
00787     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00788 
00789 
00790     if (i == 0)
00791       (void) strcpy(varname, "rrd_aut");
00792     else if (i == 1)
00793       (void) strcpy(varname, "rrd_hiv");
00794     else if (i == 2)
00795       (void) strcpy(varname, "rrd_pri");
00796     else if (i == 3)
00797       (void) strcpy(varname, "rrd_ete");
00798     else
00799       exit(1);
00800     istat = nc_inq_varid(ncinid_learn, varname, &(rrd_varid[i])); /* get rrd variable ID */
00801     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00802 
00803     /* Get variable information */
00804     istat = nc_inq_var(ncinid_learn, rrd_varid[i], (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00805     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00806     if (varndims != 2) {
00807       (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00808       (void) banner(basename(argv[0]), "ABORT", "END");
00809       (void) abort();
00810     }
00811 
00812     /* Get missing value and assume the same for all seasons */
00813     if (i == 0) {
00814       (void) strcpy(attname, "missing_value");
00815       if (vartype_main == NC_FLOAT) {
00816         istat = nc_get_att_float(ncinid_learn, rrd_varid[0], attname, &valf);
00817         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00818         fillvalue_rrd = (double) valf;
00819       }
00820       else if (vartype_main == NC_DOUBLE) {
00821         istat = nc_get_att_double(ncinid_learn, rrd_varid[0], attname, &fillvalue_rrd);
00822         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00823       }
00824     }
00825 
00826     /* Allocate memory and set start and count */
00827     start[0] = 0;
00828     start[1] = 0;
00829     start[2] = 0;
00830     count[0] = (size_t) ntime_learn[i];
00831     count[1] = (size_t) npts_learn;
00832     count[2] = (size_t) 0;
00833     /* Allocate memory */
00834     rrd_learn[i] = (double *) calloc(ntime_learn[i] * npts_learn, sizeof(double));
00835     if (rrd_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00836     
00837     /* Read values from netCDF variable */
00838     printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00839     istat = nc_get_vara_double(ncinid_learn, rrd_varid[i], start, count, rrd_learn[i]);
00840     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00841 
00842 
00843     if (i == 0)
00844       (void) strcpy(varname, "ta_aut");
00845     else if (i == 1)
00846       (void) strcpy(varname, "ta_hiv");
00847     else if (i == 2)
00848       (void) strcpy(varname, "ta_pri");
00849     else if (i == 3)
00850       (void) strcpy(varname, "ta_ete");
00851     else
00852       exit(1);
00853     istat = nc_inq_varid(ncinid_learn, varname, &(ta_varid[i])); /* get ta variable ID */
00854     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00855 
00856     /* Get variable information */
00857     istat = nc_inq_var(ncinid_learn, ta_varid[i], (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00858     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00859     
00860     if (varndims != 1) {
00861       (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00862       (void) banner(basename(argv[0]), "ABORT", "END");
00863       (void) abort();
00864     }
00865 
00866     /* Get missing value and assume the same for all seasons */
00867     if (i == 0) {
00868       (void) strcpy(attname, "missing_value");
00869       if (vartype_main == NC_FLOAT) {
00870         istat = nc_get_att_float(ncinid_learn, ta_varid[0], attname, &valf);
00871         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00872         fillvalue_ta = (double) valf;
00873       }
00874       else if (vartype_main == NC_DOUBLE) {
00875         istat = nc_get_att_double(ncinid_learn, ta_varid[0], attname, &fillvalue_ta);
00876         if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00877       }
00878     }
00879 
00880     /* Allocate memory and set start and count */
00881     start[0] = 0;
00882     start[1] = 0;
00883     start[2] = 0;
00884     count[0] = (size_t) ntime_learn[i];
00885     count[1] = (size_t) 0;
00886     count[2] = (size_t) 0;
00887     /* Allocate memory */
00888     ta_learn[i] = (double *) calloc(ntime_learn[i], sizeof(double));
00889     if (ta_learn[i] == NULL) alloc_error(__FILE__, __LINE__);
00890     
00891     /* Read values from netCDF variable */
00892     printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00893     istat = nc_get_vara_double(ncinid_learn, ta_varid[i], start, count, ta_learn[i]);
00894     if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00895 
00896   } /* Season loop */
00897 
00898   istat = nc_inq_varid(ncinid_learn, "eca_pc_learn", &eca_pc_learn_varid); /* get variable ID */
00899   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00900   
00901   /* Get variable information */
00902   istat = nc_inq_var(ncinid_learn, eca_pc_learn_varid, (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00903   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00904   
00905   if (varndims != 1) {
00906     (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00907     (void) banner(basename(argv[0]), "ABORT", "END");
00908     (void) abort();
00909   }
00910   
00911   /* Allocate memory and set start and count */
00912   start[0] = 0;
00913   start[1] = 0;
00914   start[2] = 0;
00915   count[0] = (size_t) neof_learn;
00916   count[1] = (size_t) 0;
00917   count[2] = (size_t) 0;
00918   /* Allocate memory */
00919   eca_pc_learn = (double *) calloc(neof_learn, sizeof(double));
00920   if (eca_pc_learn == NULL) alloc_error(__FILE__, __LINE__);
00921   
00922   /* Read values from netCDF variable */
00923   printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00924   istat = nc_get_vara_double(ncinid_learn, eca_pc_learn_varid, start, count, eca_pc_learn);
00925   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00926 
00927 
00928   istat = nc_inq_varid(ncinid_learn, "tancp_mean", &tancp_mean_varid); /* get variable ID */
00929   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00930   
00931   /* Get variable information */
00932   istat = nc_inq_var(ncinid_learn, tancp_mean_varid, (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00933   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00934   
00935   if (varndims != 1) {
00936     (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00937     (void) banner(basename(argv[0]), "ABORT", "END");
00938     (void) abort();
00939   }
00940   
00941   /* Allocate memory and set start and count */
00942   start[0] = 0;
00943   start[1] = 0;
00944   start[2] = 0;
00945   count[0] = (size_t) nseason_learn;
00946   count[1] = (size_t) 0;
00947   count[2] = (size_t) 0;
00948   /* Allocate memory */
00949   tancp_mean = (double *) calloc(nseason_learn, sizeof(double));
00950   if (tancp_mean == NULL) alloc_error(__FILE__, __LINE__);
00951   
00952   /* Read values from netCDF variable */
00953   printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00954   istat = nc_get_vara_double(ncinid_learn, tancp_mean_varid, start, count, tancp_mean);
00955   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00956 
00957 
00958   istat = nc_inq_varid(ncinid_learn, "tancp_var", &tancp_var_varid); /* get variable ID */
00959   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00960   
00961   /* Get variable information */
00962   istat = nc_inq_var(ncinid_learn, tancp_var_varid, (char *) NULL, &vartype_main, &varndims, vardimids, (int *) NULL);
00963   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00964   
00965   if (varndims != 1) {
00966     (void) fprintf(stderr, "Error NetCDF type and/or dimensions Line %d.\n", __LINE__);
00967     (void) banner(basename(argv[0]), "ABORT", "END");
00968     (void) abort();
00969   }
00970   
00971   /* Allocate memory and set start and count */
00972   start[0] = 0;
00973   start[1] = 0;
00974   start[2] = 0;
00975   count[0] = (size_t) nseason_learn;
00976   count[1] = (size_t) 0;
00977   count[2] = (size_t) 0;
00978   /* Allocate memory */
00979   tancp_var = (double *) calloc(nseason_learn, sizeof(double));
00980   if (tancp_var == NULL) alloc_error(__FILE__, __LINE__);
00981   
00982   /* Read values from netCDF variable */
00983   printf("%s: Reading data from input file %s.\n", __FILE__, filein_learn);
00984   istat = nc_get_vara_double(ncinid_learn, tancp_var_varid, start, count, tancp_var);
00985   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
00986   
00987 
00988   /***** BEGIN Compute mean and variance of distances to clusters *****/
00989 
00990   (void) printf("Computing mean and variance of distances to clusters.\n");
00991 
00992   mean_dist = (double **) malloc(nseason * sizeof(double *));
00993   if (mean_dist == NULL) alloc_error(__FILE__, __LINE__);
00994   var_dist = (double **) malloc(nseason * sizeof(double *));
00995   if (var_dist == NULL) alloc_error(__FILE__, __LINE__);
00996 
00997   for (i=0; i<nseason; i++) {
00998 
00999     mean_dist[i] = (double *) malloc(nclust[i] * sizeof(double));
01000     if (mean_dist[i] == NULL) alloc_error(__FILE__, __LINE__);
01001     var_dist[i] = (double *) malloc(nclust[i] * sizeof(double));
01002     if (var_dist[i] == NULL) alloc_error(__FILE__, __LINE__);
01003 
01004     /* Normalisation of the principal component by the square root of the variance of the first one */
01005 
01006     var_pc_norm_all = (double *) malloc(neof * sizeof(double));
01007     if (var_pc_norm_all == NULL) alloc_error(__FILE__, __LINE__);
01008     buftmp = (double *) malloc(ntime*neof * sizeof(double));
01009     if (buftmp == NULL) alloc_error(__FILE__, __LINE__);
01010 
01011     first_variance = -9999.9999;
01012     (void) normalize_pc(var_pc_norm_all, &first_variance, buftmp, psl_pc, neof, ntime);
01013 
01014     /* Select sub period of field analyzed */
01015     /* Assuming season=0 is autumn and the rest in order, that is winter, spring, summer */
01016     (void) sub_period_common(&buf_sub, &ntime_sub, buftmp, year, month, day, year_learn[i], month_learn[i], day_learn[i], 1,
01017                              neof, 1, ntime, ntime_learn[i]);
01018     (void) free(buftmp);
01019     
01020     (void) mean_variance_dist_clusters(mean_dist[i], var_dist[i], buf_sub, poid[i], eca_pc_learn, var_pc_norm_all,
01021                                        neof, nclust[i], ntime_sub);
01022     (void) free(buf_sub);
01023     (void) free(var_pc_norm_all);
01024 
01025     printf("Season: %d\n", i);
01026     for (ii=0; ii<nclust[i]; ii++)
01027       printf("Cluster #%d. Mean and variance of distances to clusters: %lf %lf\n", ii, mean_dist[i][ii], var_dist[i][ii]);
01028 
01029   }
01030 
01031   /***** END Compute mean and variance of distances to clusters *****/
01032 
01033 
01035   /* Close the intput netCDF file. */
01036   istat = ncclose(ncinid);
01037   if (istat != NC_NOERR) handle_netcdf_error(istat, __LINE__);
01038 
01039   (void) ut_free_system(unitSystem);  
01040 
01041   (void) free(psl_pc);
01042 
01043   (void) free(timein);
01044   (void) free(filein);
01045   (void) free(filein_poid);
01046   (void) free(filein_learn);
01047 
01048   for (i=0; i<nseason; i++) {
01049     (void) free(poid[i]);
01050     (void) free(mean_dist[i]);
01051     (void) free(var_dist[i]);
01052   }
01053   for (i=0; i<nseason_learn; i++) {
01054     (void) free(time_learn[i]);
01055     (void) free(cst_learn[i]);
01056     (void) free(reg_learn[i]);
01057     (void) free(rrd_learn[i]);
01058     (void) free(ta_learn[i]);
01059     (void) free(year_learn[i]);
01060     (void) free(month_learn[i]);
01061     (void) free(day_learn[i]);
01062     (void) free(hour_learn[i]);
01063     (void) free(min_learn[i]);
01064     (void) free(sec_learn[i]);
01065   }
01066   (void) free(poid);
01067   (void) free(mean_dist);
01068   (void) free(var_dist);
01069   (void) free(time_learn);
01070   (void) free(cst_learn);
01071   (void) free(reg_learn);
01072   (void) free(rrd_learn);
01073   (void) free(ta_learn);
01074   (void) free(year_learn);
01075   (void) free(month_learn);
01076   (void) free(day_learn);
01077   (void) free(hour_learn);
01078   (void) free(min_learn);
01079   (void) free(sec_learn);
01080 
01081   (void) free(clust_dimid);
01082   (void) free(poid_varid);
01083   (void) free(clust_varid);
01084   (void) free(time_learn_dimid);
01085   (void) free(time_learn_varid);
01086   (void) free(clust_learn_dimid);
01087 
01088   (void) free(cst_varid);
01089   (void) free(reg_varid);
01090   (void) free(rrd_varid);
01091   (void) free(ta_varid);
01092 
01093   (void) free(nclust);
01094 
01095   (void) free(nclust_learn);
01096   (void) free(ntime_learn);
01097   (void) free(eca_pc_learn);
01098   (void) free(tancp_mean);
01099   (void) free(tancp_var);
01100 
01101   /* Print END banner */
01102   (void) banner(basename(argv[0]), "OK", "END");
01103 
01104   return 0;
01105 }

void show_usage ( char *  pgm  ) 

C prototypes.

Local Subroutines.

Show usage for program command-line arguments.

Parameters:
[in] pgm Program name.

Definition at line 1111 of file test_mean_variance_dist_clusters.c.

01111                            {
01116   (void) fprintf(stderr, "%s: usage:\n", pgm);
01117   (void) fprintf(stderr, "-i: input NetCDF file\n");
01118   (void) fprintf(stderr, "-o: output NetCDF file\n");
01119   (void) fprintf(stderr, "-h: help\n");
01120 
01121 }


Generated on 12 May 2016 for DSCLIM by  doxygen 1.6.1