int f_new_grid(ARG4) {
struct local_struct *save;
unsigned int i;
int is_u, is_v, ftn_npnts, ftn_nout;
int kgds[200], km;
float *data_in, *data_out;
double x0, y0, dx, dy, xn, yn;
double lov, lad, latin1, latin2;
int proj; // projection: for LC 0 = NP, 128 = SP
char name[NAMELEN];
int j, ibi, ibo, iret, nnx, nny, n_out;
unsigned char *new_sec[8], *s, *bitmap, *bitmap_out, *p;
/* for lambertc */
double r_maj, r_min, ref_lon, ref_lat;
if (mode == -1) { // initialization
decode = 1;
output_order_wanted = raw; // in raw order
#ifdef G95
// initialize g95 runtime library
if (g95_runstop == 0) {
g95_runtime_start(0,NULL);
g95_runstop = 1;
}
#endif
// if ( (sizeof(vectors) / sizeof (vectors[0])) % 2 == 1) fatal_error("new_grid: program error in vectors[]","");
// allocate static variables
*local = save = (struct local_struct *) malloc( sizeof(struct local_struct));
if (save == NULL) fatal_error("memory allocation -wind_speed","");
if ((save->out = ffopen(arg4, file_append ? "ab" : "wb")) == NULL) {
fatal_error("-new_grid: could not open file %s", arg1);
}
save->has_u = 0;
save->radius_major = save->radius_minor = 0.0;
init_sec(save->clone_sec);
s = NULL;
// parse NCEP grids */
ncep_grids(&arg1, &arg2, &arg3);
// for each output grid
if (strcmp(arg1,"latlon") == 0) {
if (sscanf(arg2,"%lf:%d:%lf", &x0, &nnx, &dx) != 3)
fatal_error("new_grid: XDEF wrong:%s",arg2);
if (sscanf(arg3,"%lf:%d:%lf", &y0, &nny, &dy) != 3)
fatal_error("new_grid: YDEF wrong:%s",arg3);
if (x0 < 0.0) x0 += 360.0;
save->nx = nnx;
save->ny = nny;
save->npnts_out = n_out = nnx*nny;
if (n_out <= 0) fatal_error("new_grid: bad nx, ny","");
// make a new section 3
s = sec3_lola(nnx, x0, dx, nny, y0, dy, sec);
}
else if (strncmp(arg1,"mercator:",9) == 0) {
if (sscanf(arg1,"mercator:%lf", &lad) != 1)
fatal_error("new_grid: LaD (latitude interesection) not specified","");
if (sscanf(arg2,"%lf:%d:%lf:%lf", &x0, &nnx, &dx, &xn) != 4)
fatal_error("new_grid: XDEF wrong:%s",arg2);
if (sscanf(arg3,"%lf:%d:%lf:%lf", &y0, &nny, &dy, &yn) != 4)
if (x0 < 0.0) x0 += 360.0;
save->nx = nnx;
save->ny = nny;
save->npnts_out = n_out = nnx*nny;
if (n_out <= 0) fatal_error("new_grid: bad nx, ny","");
// make a new section 3
s = sec3_mercator(lad, nnx, x0, dx, xn, nny, y0, dy, yn, sec);
}
else if (strcmp(arg1,"gaussian") == 0) {
if (sscanf(arg2,"%lf:%d:%lf", &x0, &nnx, &dx) != 3)
fatal_error("new_grid: XDEF wrong:%s",arg2);
if (sscanf(arg3,"%lf:%d", &y0, &nny) != 2)
fatal_error("new_grid: YDEF wrong:%s",arg3);
if (x0 < 0.0) x0 += 360.0;
save->nx = nnx;
save->ny = nny;
save->npnts_out = n_out = nnx*nny;
if (n_out <= 0) fatal_error("new_grid: bad nx, ny","");
// make a new section 3
s = sec3_gaussian(nnx, x0, dx, nny, y0, sec);
}
else if (strncmp(arg1,"lambert:",8) == 0) {
i = sscanf(arg1,"lambert:%lf:%lf:%lf:%lf", &lov, &latin1, &latin2, &lad);
if (i < 2) fatal_error("new_grid: arg1 wrong:%s",arg1);
if (lov < 0.0) lov += 360.0;
if (i < 3) latin2 = latin1;
if (i < 4) lad = latin2;
proj = 0;
if (latin2 < 0.0) proj = 128;
if (sscanf(arg2,"%lf:%d:%lf", &x0, &nnx, &dx) != 3)
fatal_error("new_grid: XDEF wrong:%s",arg2);
if (sscanf(arg3,"%lf:%d:%lf", &y0, &nny, &dy) != 3)
fatal_error("new_grid: YDEF wrong:%s",arg3);
if (x0 < 0.0) x0 += 360.0;
save->nx = nnx;
save->ny = nny;
save->npnts_out = n_out = nnx*nny;
if (n_out <= 0) fatal_error("new_grid: bad nx, ny","");
// make a new section 3
s = sec3_lc(lov, lad, latin1, latin2, proj, nnx, x0, dx, nny, y0, dy, sec);
}
/* for lambertc, input is the lon-lat of center point */
/* can not calc grid until radius is given, so do lambert code to check args */
else if (strncmp(arg1,"lambertc:",9) == 0) {
i = sscanf(arg1,"lambertc:%lf:%lf:%lf:%lf", &lov, &latin1, &latin2, &lad);
if (i < 2) fatal_error("new_grid: arg1 wrong:%s",arg1);
if (lov < 0.0) lov += 360.0;
if (i < 3) latin2 = latin1;
if (i < 4) lad = latin2;
proj = 0;
if (latin2 < 0.0) proj = 128;
if (sscanf(arg2,"%lf:%d:%lf", &x0, &nnx, &dx) != 3)
fatal_error("new_grid: XDEF wrong:%s",arg2);
if (sscanf(arg3,"%lf:%d:%lf", &y0, &nny, &dy) != 3)
fatal_error("new_grid: YDEF wrong:%s",arg3);
if (x0 < 0.0) x0 += 360.0;
save->nx = nnx;
save->ny = nny;
save->npnts_out = n_out = nnx*nny;
if (n_out <= 0) fatal_error("new_grid: bad nx, ny","");
// make a new section 3
s = sec3_lc(lov, lad, latin1, latin2, proj, nnx, x0, dx, nny, y0, dy, sec);
}
else if (strncmp(arg1,"nps:",4) == 0 || strncmp(arg1,"sps:",4) == 0) {
if (sscanf(arg1,"%*[ns]ps:%lf:%lf", &lov, &lad) != 2) fatal_error("new_grid: arg1 wrong:%s",arg1);
if (lad != 60.0) fatal_error("New_grid: only LatD = 60 is supported","");
proj = 0;
if (arg1[0] == 's') proj = 128;
if (sscanf(arg2,"%lf:%d:%lf", &x0, &nnx, &dx) != 3)
fatal_error("new_grid: XDEF wrong:%s",arg2);
if (sscanf(arg3,"%lf:%d:%lf", &y0, &nny, &dy) != 3)
fatal_error("new_grid: YDEF wrong:%s",arg3);
if (lov < 0.0) lov += 360.0;
if (x0 < 0.0) x0 += 360.0;
save->nx = nnx;
save->ny = nny;
save->npnts_out = n_out = nnx*nny;
if (n_out <= 0) fatal_error("new_grid: bad nx, ny","");
// make a new section 3
s = sec3_polar_stereo(lov, lad, proj, nnx, x0, dx, nny, y0, dy, sec);
}
else fatal_error("new_grid: unsupported output grid %s", arg1);
// save new section 3
i = (int) uint4(s); // size of section 3
new_sec[3] = save->sec3 = (unsigned char *) malloc(i * sizeof(unsigned char));
for (j = 0; j < i; j++) save->sec3[j] = s[j];
// apply wind rotation .. change flag 3.3
if (wind_rotation == undefined) {
fprintf(stderr,"Warning: -new_grid wind orientation undefined, "
"use \"-new_grid_winds (grid|earth)\", earth used (N=North Pole)\n");
if ( (p = flag_table_3_3_location(new_sec)) ) *p = *p & (255 - 8);
}
if (wind_rotation == grid && (p = flag_table_3_3_location(new_sec))) *p = *p | 8;
if (mk_kgds(new_sec, save->kgds_out)) fatal_error("new_grid: encoding output kgds","");
/* some vectors need by interpolation routines */
if ((save->rlat = (float *) malloc(n_out * sizeof(float))) == NULL)
fatal_error("new_grid memory allocation","");
if ((save->rlon = (float *) malloc(n_out * sizeof(float))) == NULL)
fatal_error("new_grid memory allocation","");
if ((save->crot = (float *) malloc(n_out * sizeof(float))) == NULL)
fatal_error("new_grid memory allocation","");
if ((save->srot = (float *) malloc(n_out * sizeof(float))) == NULL)
fatal_error("new_grid memory allocation","");
return 0;
}
save = (struct local_struct *) *local;
if (mode == -2) { // cleanup
#ifdef G95
if (g95_runstop == 1) {
g95_runtime_stop();
g95_runstop = 0;
}
#endif
if (save->has_u > 0) {
fprintf(stderr,"-new_grid: last field %s was not interpolated (missing V)\n", save->name);
free(save->u_val);
free_sec(save->clone_sec);
}
free(save->rlon);
free(save->rlat);
free(save->crot);
free(save->srot);
free(save->sec3);
ffclose(save->out);
free(save);
return 0;
}
if (mode >= 0) { // processing
/* The kgds of some output grids will change depending on input grid */
/* for example, radius of earth is not known grib file is read, */
/* and mass vs wind fields */
/* right nowm, only affects lambertc */
if (strncmp(arg1,"lambertc:",8) == 0) {
// lambertc depends on the radius of the earth which is
// set by the input grib file
/* read earth radius */
i = axes_earth(sec, &r_maj, &r_min);
if (i) fatal_error_i("axes_earth: error code %d", i);
if (save->radius_major != r_maj || save->radius_minor != r_min) {
// update sec3 and kgds
i = sscanf(arg1,"lambertc:%lf:%lf:%lf:%lf", &lov, &latin1, &latin2, &lad);
if (i < 2) fatal_error("new_grid: arg1 wrong:%s",arg1);
if (lov < 0.0) lov += 360.0;
if (i < 3) latin2 = latin1;
if (i < 4) lad = latin2;
proj = 0;
if (latin2 < 0.0) proj = 128;
if (sscanf(arg2,"%lf:%d:%lf", &x0, &nnx, &dx) != 3)
fatal_error("new_grid: XDEF wrong:%s",arg2);
if (sscanf(arg3,"%lf:%d:%lf", &y0, &nny, &dy) != 3)
fatal_error("new_grid: YDEF wrong:%s",arg3);
if (x0 < 0.0) x0 += 360.0;
save->nx = nnx;
save->ny = nny;
save->npnts_out = n_out = nnx*nny;
if (n_out <= 0) fatal_error("new_grid: bad nx, ny","");
ref_lon = x0;
ref_lat = y0;
i = new_grid_lambertc(nnx, nny, ref_lon, ref_lat, latin1, latin2, lov, lad, r_maj, r_min, dx, dy, &x0, &y0);
if (i) fatal_error_i("new_grid_lambertc: error code %d", i);
// make a new section 3
s = sec3_lc(lov, lad, latin1, latin2, proj, nnx, x0, dx, nny, y0, dy, sec);
// save new section 3
i = (int) uint4(s); // size of section 3
for (j = 0; j < i; j++) save->sec3[j] = s[j];
// make kgds
new_sec[3] = save->sec3;
if (mk_kgds(new_sec, save->kgds_out)) fatal_error("new_grid: encoding output kgds","");
// save radius of earth, to show sec3 and kgds has been done
save->radius_major = r_maj;
save->radius_minor = r_min;
}
}
if (output_order != raw) fatal_error("new_grid: must be in raw output order","");
i = getName(sec, mode, NULL, name, NULL, NULL);
is_u = is_v = 0;
// for (j = 0 ; j < sizeof(vectors) / sizeof(vectors[0]); j++) {
for (j = 0; vectors[j] != NULL; j++) {
if (strcmp(name,vectors[j]) == 0) {
if (j % 2 == 0) is_u = 1;
else is_v = 1;
break;
}
}
// fprintf(stderr, " %s isu %d isv %d has_u %d\n", name, is_u, is_v, save->has_u);
// for (i = 0; i < 12; i++) { printf("kgds_out[%d] = %d ",i,save->kgds_out[i]); }
// check if V matches expectation
if (is_v && (save->has_u == 0 || (same_sec0(sec,save->clone_sec) != 1 ||
same_sec1(sec,save->clone_sec) != 1 ||
same_sec3(sec,save->clone_sec) != 1 ||
same_sec4(sec,save->clone_sec) != 1) )) {
fprintf(stderr,"-new_grid: %s doesn't pair with previous vector field, field ignored\n", name);
return 0;
}
// if U field - save
if (is_u) {
if (save->has_u > 0) {
fprintf(stderr,"-new_grid: missing V, %s not interpolated\n",save->name);
free(save->u_val);
free_sec(save->clone_sec);
}
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->u_val));
GB2_ParmNum(save->clone_sec) = GB2_ParmNum(sec) + 1;
save->has_u = 1;
strncpy(save->name, name,NAMELEN-1);
save->name[NAMELEN-2]=0;
return 0;
}
// at this point will call polates with either a scalar or vector
n_out = save->npnts_out;
nnx = save->nx;
nny = save->ny;
km = 1; // only one field
if (mk_kgds(sec, kgds)) fatal_error("new_grid: encoding input kgds","");
data_in = (float *) malloc(npnts * (1 + (is_v != 0)) * sizeof(float));
bitmap = (unsigned char *) malloc(npnts * sizeof(unsigned char));
bitmap_out = (unsigned char *) malloc(n_out * sizeof(unsigned char));
data_out = (float *) malloc(n_out * (1 + (is_v != 0)) * sizeof(float));
if (data_in == NULL || data_out == NULL || bitmap == NULL || bitmap_out == NULL)
fatal_error("new_grid: memory allocation problem","");
ibi = 0; // input bitmap is not used
if (is_v) {
for (i = 0; i < npnts; i++) {
if (DEFINED_VAL(data[i]) && DEFINED_VAL(save->u_val[i])) {
data_in[i] = save->u_val[i];
data_in[i+npnts] = data[i];
bitmap[i] = 1;
}
else {
data_in[i] = data_in[i + npnts] = 0.0;
bitmap[i] = 0;
ibi = 1; // input bitmap is used
}
}
if (mode == 98) fprintf(stderr," UV interpolation %s , %s\n", save->name, name);
}
else {
for (i = 0; i < npnts; i++) {
if (DEFINED_VAL(data[i])) {
data_in[i] = data[i];
bitmap[i] = 1;
}
else {
data_in[i] = 0.0;
bitmap[i] = 0;
ibi = 1; // input bitmap is used
}
}
}
// interpolate
// for (i = 0; i < 12; i++) { printf("\nkgds_in[%d] = %d out=%d ",i,kgds[i],save->kgds_out[i]); }
ftn_npnts = (int) npnts;
ftn_nout = (int) n_out;
if (is_v) {
IPOLATEV(&interpol_type, ipopt,kgds,save->kgds_out,
&ftn_npnts, &n_out, &km, &ibi, bitmap, data_in, data_in+npnts,
&ftn_nout,save->rlat,save->rlon, save->crot, save->srot,
&ibo, bitmap_out, data_out, data_out + n_out, &iret);
}
else {
IPOLATES(&interpol_type, ipopt,kgds,save->kgds_out,
&ftn_npnts, &n_out, &km, &ibi, bitmap, data_in, &ftn_nout,
save->rlat,save->rlon, &ibo, bitmap_out, data_out, &iret);
}
if (iret != 0) {
for (i = 0; i < 12; i++) {
fprintf(stderr," IPOLATES error: kgds[%d] input %d output %d\n", i+1,kgds[i],save->kgds_out[i]);
}
if (iret == 2) fatal_error("IPOLATES failed, unrecognized input grid or no grid overlap","");
if (iret == 3) fatal_error("IPOLATES failed, unrecognized output grid","");
fatal_error_i("IPOLATES failed, error %d",iret);
}
n_out = (unsigned int) ftn_nout;
/* use bitmap to set UNDEFINED values */
if (ibo == 1) { // has a bitmap
if (is_v) {
for (i = 0; i < n_out; i++) {
if (bitmap_out[i] == 0) data_out[i] = data_out[i+n_out] = UNDEFINED;
}
}
else {
for (i = 0; i < n_out; i++) {
if (bitmap_out[i] == 0) data_out[i] = UNDEFINED;
}
}
}
// now to write out the grib file
for (i = 0; i < 8; i++) new_sec[i] = sec[i];
new_sec[3] = save->sec3;
if (is_v != 0) {
GB2_ParmNum(new_sec) = GB2_ParmNum(new_sec) - 1;
grib_wrt(new_sec, data_out, n_out, nnx, nny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->out);
GB2_ParmNum(new_sec) = GB2_ParmNum(new_sec) + 1;
grib_wrt(new_sec, data_out+n_out, n_out, nnx, nny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->out);
}
else {
grib_wrt(new_sec, data_out, n_out, nnx, nny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->out);
}
if (flush_mode) fflush(save->out);
free(data_in);
free(bitmap);
free(bitmap_out);
free(data_out);
if (is_v != 0) {
save->has_u = 0;
free(save->u_val);
free_sec(save->clone_sec);
}
}
return 0;
}
int f_wind_speed(ARG1) {
struct local_struct {
float *val;
int has_u;
unsigned char *clone_sec[9];
FILE *output;
};
struct local_struct *save;
unsigned int i;
int is_u;
float *d1, *data_tmp;
int discipline, mastertab, parmcat, parmnum;
if (mode == -1) { // initialization
save_translation = decode = 1;
// allocate static variables
*local = save = (struct local_struct *) malloc( sizeof(struct local_struct));
if (save == NULL) fatal_error("memory allocation -wind_speed","");
if ((save->output = (void *) ffopen(arg1, file_append ? "ab" : "wb")) == NULL) {
fatal_error("-wind_speed: could not open file %s", arg1);
}
save->has_u = 0;
init_sec(save->clone_sec);
return 0;
}
save = *local;
if (mode == -2) { // cleanup
if (save->has_u == 1) {
free(save->val);
free_sec(save->clone_sec);
}
return 0;
}
if (mode >= 0) { // processing
// get variable name parameters
discipline = GB2_Discipline(sec);
mastertab = GB2_MasterTable(sec);
parmcat = GB2_ParmCat(sec);
parmnum = GB2_ParmNum(sec);
if (mode == 99) fprintf(stderr,"-wind_speed %d %d %d %d\n",mastertab,discipline,parmcat,parmnum);
is_u = (mastertab <= 6) && (discipline == 0) && (parmcat == 2) && (parmnum == 2);
if (mode == 99 && is_u) fprintf(stderr,"\n-wind_speed: is u\n");
if (is_u) { // save data
if (save->has_u) {
free(save->val);
free_sec(save->clone_sec);
}
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->val));
GB2_ParmNum(save->clone_sec) = 3; // set id to V
save->has_u = 1;
return 0;
}
// check for V
if (same_sec0(sec,save->clone_sec) == 1 &&
same_sec1(sec,save->clone_sec) == 1 &&
same_sec3(sec,save->clone_sec) == 1 &&
same_sec4(sec,save->clone_sec) == 1) {
// calculate wind speed
if (mode == 99) fprintf(stderr,"\n-wind_speed: calc wind speed\n");
d1= save->val;
for (i = 0; i < ndata; i++) {
if (!UNDEFINED_VAL(data[i]) && !UNDEFINED_VAL(*d1)) {
*d1 = sqrt(data[i]*data[i] + *d1 * *d1);
}
else *d1 = UNDEFINED;
d1++;
}
GB2_ParmNum(save->clone_sec) = 1; // set id to wind speed
// copy data to temp space
if ((data_tmp = (float *) malloc(ndata * sizeof(float))) == NULL)
fatal_error("memory allocation - data_tmp","");
undo_output_order(save->val, data_tmp, ndata);
grib_wrt(save->clone_sec, data_tmp, ndata, nx, ny, use_scale, dec_scale,
bin_scale, wanted_bits, max_bits, grib_type, save->output);
if (flush_mode) fflush(save->output);
free(data_tmp);
// cleanup
free(save->val);
free_sec(save->clone_sec);
save->has_u = 0;
}
}
return 0;
}
int f_ncep_norm(ARG1) {
struct local_struct {
float *val;
int has_val;
unsigned char *clone_sec[9];
FILE *output;
};
struct local_struct *save;
int idx, j, fhr_1, fhr_2, dt1, dt2, new_type, is_ave;
unsigned int i;
float *d1, *data_tmp;
if (mode == -1) { // initialization
save_translation = decode = 1;
// 1/2015 use_scale = 0;
// allocate static variables
*local = save = (struct local_struct *) malloc( sizeof(struct local_struct));
if (save == NULL) fatal_error("memory allocation f_ncep_norm","");
if ((save->output = ffopen(arg1, file_append ? "ab" : "wb")) == NULL) {
fatal_error("f_ncep_norm: could not open file %s", arg1);
}
save->has_val = 0;
init_sec(save->clone_sec);
return 0;
}
save = (struct local_struct *) *local;
if (mode == -2) { // cleanup
ffclose(save->output);
if (save->has_val == 1) {
free(save->val);
free_sec(save->clone_sec);
}
free(save);
return 0;
}
if (mode >= 0) { // processing
idx = stat_proc_n_time_ranges_index(sec);
// only process stat processed fields
if (idx < 0) return 0;
// n_time_ranges has to be one
if (sec[4][idx] != 1) return 0;
// only process averages or accumulations
j = code_table_4_10(sec);
if (mode == 99) fprintf(stderr,"\nncep_norm: code table 4.10 (ave/acc/etc)=%d\n",j);
if (j == 0) is_ave = 1; // average
else if (j == 1) is_ave = 0; // accumulation
else return 0; // only process average or accumulations
fhr_2 = forecast_time_in_units(sec); // start time
dt2 = int4(sec[4]+idx+50-42); // delta-time
if (mode == 99) fprintf(stderr,"\nncep_norm: fhr_2=%d dt2=%d index of dt2=%d\n",fhr_2, dt2, idx+50-42);
if (dt2 == 0) return 0; // dt == 0
// units of fcst and stat proc should be the same if fcst time != 0
if (fhr_2 != 0 && code_table_4_4(sec) != sec[4][49-42+idx]) return 0;
if (save->has_val == 0) { // new data: write and save
if ((data_tmp = (float *) malloc(ndata * sizeof(float))) == NULL)
fatal_error("memory allocation - data_tmp","");
undo_output_order(data, data_tmp, ndata);
grib_wrt(sec, data_tmp, ndata, nx, ny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->output);
if (flush_mode) fflush(save->output);
free(data_tmp);
if (save->has_val == 1) { // copy data to save
free(save->val); // save = new field
free_sec(save->clone_sec);
}
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->val));
save->has_val = 1;
if (mode == 99) fprintf(stderr," ncep_norm: saved as new field\n");
return 0;
}
new_type = 0;
fhr_1 = forecast_time_in_units(save->clone_sec); // start_time of save message
dt1 = int4(save->clone_sec[4]+idx+50-42); // delta-time
if (mode == 99) fprintf(stderr,"ncep_norm: is_ave = %d\n fhr_1 %d dt1 %d fhr_2 %d dt2 %d\n",is_ave,
fhr_1, dt1, fhr_2, dt2);
if (fhr_1 != fhr_2) new_type = 1;
if (new_type == 0) {
if (same_sec0(sec,save->clone_sec) == 0 ||
same_sec1(sec,save->clone_sec) == 0 ||
same_sec3(sec,save->clone_sec) == 0 ||
same_sec4_diff_ave_period(sec,save->clone_sec) == 0) {
if (mode == 99) fprintf(stderr,"ncep_norm: new_type sec test %d %d %d %d\n",
same_sec0(sec,save->clone_sec), same_sec1(sec,save->clone_sec), same_sec3(sec,save->clone_sec),
same_sec4_diff_ave_period(sec,save->clone_sec));
new_type = 1;
}
}
if (mode == 99) fprintf(stderr,"ncep_norm: new_type=%d write and save\n",new_type);
if (new_type == 1) { // fields dont match: write and save
if ((data_tmp = (float *) malloc(ndata * sizeof(float))) == NULL)
fatal_error("memory allocation - data_tmp","");
undo_output_order(data, data_tmp, ndata);
grib_wrt(sec, data_tmp, ndata, nx, ny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->output);
if (flush_mode) fflush(save->output);
free(data_tmp);
if (save->has_val == 1) { // copy data to save
free(save->val); // save = new field
free_sec(save->clone_sec);
}
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->val));
save->has_val = 1;
if (mode == 99) fprintf(stderr," ncep_norm: saved as new type/sequence\n");
return 0;
}
/* now do stuff */
if (dt1 == dt2) return 0; // same ending time
// change metadata
int_char(dt2-dt1, save->clone_sec[4]+50-42+idx); // dt = dt2 - dt1
save->clone_sec[4][17] = sec[4][49-42+idx]; // new forecast time unit
int_char(dt1+fhr_1, save->clone_sec[4]+18); // fhr = fhr + dt1
if (mode == 99) fprintf(stderr,"ncep_norm new fcst time %d + %d\n", dt1,fhr_1);
for (i = idx-7; i < idx; i++) { // ending time from pds2
save->clone_sec[4][i] = sec[4][i];
}
if (mode == 99) {
if (is_ave)
fprintf(stderr," process: factor: NEW*%g - OLD*%g\n", dt2/ (double) (dt2 - dt1),
dt1/ (double) (dt2-dt1));
else fprintf(stderr," process: current-last\n");
}
// change floating point data
d1= save->val;
for (i = 0; i < ndata; i++) {
if (!UNDEFINED_VAL(data[i]) && !UNDEFINED_VAL(*d1) ) {
if (is_ave) {
*d1 = (data[i]*dt2 - *d1*dt1) / (double) (dt2 - dt1);
}
else { // accumulation
*d1 = data[i] - *d1;
}
}
else *d1 = UNDEFINED;
d1++;
}
// write grib output
if ((data_tmp = (float *) malloc(ndata * sizeof(float))) == NULL)
fatal_error("memory allocation - data_tmp","");
undo_output_order(save->val, data_tmp, ndata);
grib_wrt(save->clone_sec, data_tmp, ndata, nx, ny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->output);
if (flush_mode) fflush(save->output);
free(data_tmp);
// save data
free(save->val); // save = new field
free_sec(save->clone_sec);
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->val));
return 0;
}
return 0;
}
int f_submsg_uv(ARG1) {
struct local_struct {
unsigned char *sec[9];
const char *vname;
FILE *output;
};
struct local_struct *save;
int i, j, is_v;
unsigned long int size;
char name[NAMELEN];
unsigned char s[8];
if (mode == -1) { // initialization
// allocate static structure
*local = save = (struct local_struct *) malloc( sizeof(struct local_struct) );
if (save == NULL) fatal_error("submsg_uv: memory allocation","");
if ((save->output = ffopen(arg1, file_append ? "ab" : "wb")) == NULL) {
fatal_error("submsg_uv: could not open file %s", arg1);
}
save->vname = NULL;
init_sec(save->sec);
return 0;
}
save = (struct local_struct *) *local;
if (mode == -2) { // cleanup
if (save->vname != NULL) { // write out cached field
i = wrt_sec(save->sec[0], save->sec[1], save->sec[2], save->sec[3],
save->sec[4], save->sec[5], save->sec[6], save->sec[7], save->output);
if (i) fatal_error_i("submsg_uv: last record problem %i",i);
free_sec(save->sec);
}
ffclose(save->output);
free(save);
return 0;
}
if (mode >= 0 ) { // processing
i = getName(sec, mode, NULL, name, NULL, NULL);
/* see if name == expected vname */
is_v = 0;
if (save->vname != NULL && strcmp(name, save->vname) == 0) {
is_v = 1;
if (same_sec0(sec,save->sec) == 0) is_v = 0;
if (same_sec1(sec,save->sec) == 0) is_v = 0;
if (same_sec2(sec,save->sec) == 0) is_v = 0;
if (same_sec3(sec,save->sec) == 0) is_v = 0;
i = GB2_ParmNum(sec);
j = GB2_ParmCat(sec);
GB2_ParmNum(sec) = GB2_ParmNum(save->sec);
GB2_ParmCat(sec) = GB2_ParmCat(save->sec);
if (same_sec4(sec,save->sec) == 0) is_v = 0;
GB2_ParmNum(sec) = i;
GB2_ParmCat(sec) = j;
}
/* finished tests for U/V sequence */
/* is U/V sequence */
if (is_v) {
size = (unsigned long int) GB2_Sec0_size + GB2_Sec8_size +
(sec[1] ? uint4(sec[1]) : 0) +
(sec[2] ? uint4(sec[2]) : 0) +
(sec[3] ? uint4(sec[3]) : 0) +
(sec[4] ? uint4(sec[4]) : 0) +
(sec[5] ? uint4(sec[5]) : 0) +
(sec[6] ? uint4(sec[6]) : 0) +
(sec[7] ? uint4(sec[7]) : 0) +
(save->sec[4] ? uint4(save->sec[4]) : 0) +
(save->sec[5] ? uint4(save->sec[5]) : 0) +
(save->sec[6] ? uint4(save->sec[6]) : 0) +
(save->sec[7] ? uint4(save->sec[7]) : 0);
fwrite((void *) sec[0], sizeof(char), 8, save->output);
uint8_char(size, s);
fwrite((void *) s, sizeof(char), 8, save->output);
if (sec[1]) {
i = uint4(sec[1]);
if (fwrite((void *)sec[1], sizeof(char), i, save->output) != i) return 1;
}
if (sec[2]) {
i = uint4(sec[2]);
if (fwrite((void *)sec[2], sizeof(char), i, save->output) != i) return 1;
}
if (sec[3]) {
i = uint4(sec[3]);
if (fwrite((void *)sec[3], sizeof(char), i, save->output) != i) return 1;
}
if (save->sec[4]) {
i = uint4(save->sec[4]);
if (fwrite((void *)save->sec[4], sizeof(char), i, save->output) != i) return 1;
}
if (save->sec[5]) {
i = uint4(save->sec[5]);
if (fwrite((void *)save->sec[5],sizeof(char), i, save->output) != i) return 1;
}
if (save->sec[6]) {
i = uint4(save->sec[6]);
if (fwrite((void *)save->sec[6],sizeof(char), i, save->output) != i) return 1;
}
if (save->sec[7]) {
i = uint4(save->sec[7]);
if (fwrite((void *)save->sec[7],sizeof(char), i, save->output) != i) return 1;
}
if (sec[4]) {
i = uint4(sec[4]);
if (fwrite((void *)sec[4], sizeof(char), i, save->output) != i) return 1;
}
if (sec[5]) {
i = uint4(sec[5]);
if (fwrite((void *)sec[5], sizeof(char), i, save->output) != i) return 1;
}
if (sec[6]) {
i = uint4(sec[6]);
if (fwrite((void *)sec[6], sizeof(char), i, save->output) != i) return 1;
}
if (sec[7]) {
i = uint4(sec[7]);
if (fwrite((void *)sec[7], sizeof(char), i, save->output) != i) return 1;
}
s[0] = s[1] = s[2] = s[3] = 55; /* s = "7777" */
if (fwrite((void *) s, sizeof(char), 4, save->output) != 4)
fatal_error("submsg_uv: write record problem","");
save->vname = NULL;
free_sec(save->sec);
return 0;
}
/* has U but not V, write U */
if (save->vname != NULL) {
i = wrt_sec(save->sec[0], save->sec[1], save->sec[2], save->sec[3],
save->sec[4], save->sec[5], save->sec[6], save->sec[7], save->output);
if (i) fatal_error_i("submsg_uv: write record problem %i",i);
free_sec(save->sec);
save->vname = NULL;
}
/* check to see if new field is a U */
save->vname = is_u(name);
/* if U, cache it */
if (save->vname != NULL) {
copy_sec(sec,save->sec);
return 0;
}
/* not U, write it out */
i = wrt_sec(sec[0], sec[1], sec[2], sec[3], sec[4], sec[5], sec[6], sec[7], save->output);
if (i) fatal_error_i("submsg_uv: write problem %i",i);
return 0;
}
return 0;
}
int f_ncep_norm(ARG1) {
struct local_struct {
float *val;
int has_val;
unsigned char *clone_sec[9];
FILE *output;
};
struct local_struct *save;
int j, pdt, fhr_1, fhr_2, dt1, dt2, new_type, is_ave;
unsigned int i;
float *d1, *data_tmp;
if (mode == -1) { // initialization
save_translation = decode = 1;
// allocate static variables
*local = save = (struct local_struct *) malloc( sizeof(struct local_struct));
if (save == NULL) fatal_error("memory allocation f_normalize","");
if ((save->output = (void *) ffopen(arg1, file_append ? "ab" : "wb")) == NULL) {
fatal_error("f_ncep_norm: could not open file %s", arg1);
}
save->has_val = 0;
init_sec(save->clone_sec);
return 0;
}
save = *local;
if (mode == -2) { // cleanup
if (save->has_val == 1) {
free(save->val);
free_sec(save->clone_sec);
free(save);
}
return 0;
}
if (mode >= 0) { // processing
// only hande PDT = 8
pdt = GB2_ProdDefTemplateNo(sec);
if (pdt != 8) return 0;
// only process averages or accumulations
// check for code table 4.8
j = code_table_4_10(sec);
if (mode == 99) fprintf(stderr,"\nncep_norm: code table 4.10 (ave/acc/etc)=%d\n",j);
if (j == 0) is_ave = 1; // average
else if (j == 1) is_ave = 0; // accumulation
else return 0; // only process average or accumulations
// only process when fcst time units == ave/acc time units
if (sec[4][17] != sec[4][48]) {
if (int4(sec[4]+18) != 0) {
return 0;
}
}
fhr_2 = int4(sec[4]+18); // start time
dt2 = int4(sec[4]+49); // delta-time
if (dt2 == 0) return 0; // dt == 0
if (save->has_val == 0) { // new data: write and save
if ((data_tmp = (float *) malloc(ndata * sizeof(float))) == NULL)
fatal_error("memory allocation - data_tmp","");
undo_output_order(data, data_tmp, ndata);
grib_wrt(sec, data_tmp, ndata, nx, ny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->output);
/*
if (grib_type == simple) grib_out(sec, data_tmp, ndata, save->output);
else if (grib_type == jpeg) jpeg_grib_out(sec, data_tmp, ndata, nx,
ny, use_scale, dec_scale, bin_scale, save->output);
else if (grib_type == ieee) ieee_grib_out(sec, data_tmp, ndata,
save->output);
else fatal_error("NCEP_norm: unsupported grib type output","");
*/
if (flush_mode) fflush(save->output);
free(data_tmp);
if (save->has_val == 1) { // copy data to save
free(save->val); // save = new field
free_sec(save->clone_sec);
}
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->val));
save->has_val = 1;
if (mode == 99) fprintf(stderr," ncep_norm: saved as new field\n");
return 0;
}
new_type = 0;
fhr_1 = int4(save->clone_sec[4]+18); // start time of save message
dt1 = int4(save->clone_sec[4]+49); // delta time
if (mode == 99) fprintf(stderr,"ncep_norm: is_ave = %d\n fhr_1 %d dt1 %d fhr_2 %d dt2 %d\n",is_ave,
fhr_1, dt1, fhr_2, dt2);
if (fhr_1 != fhr_2) new_type = 1;
if (new_type == 0) {
if (same_sec0(sec,save->clone_sec) == 0 ||
same_sec1(sec,save->clone_sec) == 0 ||
same_sec3(sec,save->clone_sec) == 0 ||
same_sec4_diff_ave_period(sec,save->clone_sec) == 0) {
new_type = 1;
}
}
if (new_type == 1) { // fields dont match: write and save
if ((data_tmp = (float *) malloc(ndata * sizeof(float))) == NULL)
fatal_error("memory allocation - data_tmp","");
undo_output_order(data, data_tmp, ndata);
grib_wrt(sec, data_tmp, ndata, nx, ny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->output);
/*
if (grib_type == simple) grib_out(sec, data_tmp, ndata, save->output);
else if (grib_type == jpeg) jpeg_grib_out(sec, data_tmp, ndata, nx,
ny, use_scale, dec_scale, bin_scale, save->output);
else if (grib_type == ieee) ieee_grib_out(sec, data_tmp, ndata,
save->output);
*/
if (flush_mode) fflush(save->output);
free(data_tmp);
if (save->has_val == 1) { // copy data to save
free(save->val); // save = new field
free_sec(save->clone_sec);
}
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->val));
save->has_val = 1;
if (mode == 99) fprintf(stderr," ncep_norm: saved as new type/sequence\n");
return 0;
}
/* now do stuff */
if (dt1 == dt2) return 0; // same ending time
// change metadata
int_char(dt2-dt1, save->clone_sec[4]+49); // dt = dt2 - dt1
save->clone_sec[4][17] = sec[4][48]; // new forecast time unit
int_char(dt1+fhr_1, save->clone_sec[4]+18); // fhr = fhr + dt1
for (i = 34; i < 41; i++) { // ending time from pds2
save->clone_sec[4][i] = sec[4][i];
}
if (mode == 99) {
if (is_ave)
fprintf(stderr," process: factor: NEW*%g - OLD*%g\n", dt2/ (double) (dt2 - dt1),
dt1/ (double) (dt2-dt1));
else fprintf(stderr," process: current-last\n");
}
// change floating point data
d1= save->val;
for (i = 0; i < ndata; i++) {
if (!UNDEFINED_VAL(data[i]) && !UNDEFINED_VAL(*d1) ) {
if (is_ave) {
*d1 = (data[i]*dt2 - *d1*dt1) / (double) (dt2 - dt1);
}
else { // accumulation
*d1 = data[i] - *d1;
}
}
else *d1 = UNDEFINED;
d1++;
}
// write grib output
if ((data_tmp = (float *) malloc(ndata * sizeof(float))) == NULL)
fatal_error("memory allocation - data_tmp","");
undo_output_order(save->val, data_tmp, ndata);
grib_wrt(save->clone_sec, data_tmp, ndata, nx, ny, use_scale, dec_scale, bin_scale,
wanted_bits, max_bits, grib_type, save->output);
/*
if (grib_type == simple) grib_out(save->clone_sec, data_tmp, ndata, save->output);
else if (grib_type == jpeg) jpeg_grib_out(save->clone_sec, data_tmp, ndata, nx,
ny, use_scale, dec_scale, bin_scale, save->output);
else if (grib_type == ieee) ieee_grib_out(save->clone_sec, data_tmp, ndata,
save->output);
else if (grib_type == complex1) complex_grib_out(save->clone_sec, data_tmp, ndata,
use_scale, dec_scale, bin_scale, wanted_bits, max_bits, 1, save->output);
else if (grib_type == complex2) complex_grib_out(save->clone_sec, data_tmp, ndata,
use_scale, dec_scale, bin_scale, wanted_bits, max_bits, 2, save->output);
else if (grib_type == complex3) complex_grib_out(save->clone_sec, data_tmp, ndata,
use_scale, dec_scale, bin_scale, wanted_bits, max_bits, 3, save->output);
else fatal_error("NCEP_norm: unsupported grib output type","");
*/
if (flush_mode) fflush(save->output);
free(data_tmp);
// save data
free(save->val); // save = new field
free_sec(save->clone_sec);
copy_sec(sec, save->clone_sec);
copy_data(data,ndata,&(save->val));
return 0;
}
return 0;
}
