int f_grib(ARG1) {
unsigned long int size;
int i;
unsigned char s[8];
if (mode == -1) {
if ((*local = (void *) ffopen(arg1, file_append ? "ab" : "wb")) == NULL) {
fatal_error("Could not open %s", arg1);
}
}
else if (mode >= 0) {
/* figure out size of grib file */
size = (unsigned long int) GB2_Sec0_size + GB2_Sec1_size(sec) + GB2_Sec2_size(sec) +
+ GB2_Sec3_size(sec) + GB2_Sec4_size(sec) + GB2_Sec5_size(sec) + GB2_Sec6_size(sec)
+ GB2_Sec7_size(sec) + GB2_Sec8_size;
/* section 0 */
fwrite((void *) sec[0], sizeof(char), 8, (FILE *) *local);
uint8_char(size, s);
fwrite((void *) s, sizeof(char), 8, (FILE *) *local);
for (i = 1; i <= 7; i++) {
if (sec[i]) {
size = uint4(sec[i]);
fwrite((void *) sec[i], sizeof(char), size, (FILE *) *local);
}
}
s[0] = s[1] = s[2] = s[3] = 55; /* s = "7777" */
fwrite((void *) s, sizeof(char), 4, (FILE *) *local);
// fwrite((void *) "7777", sizeof(char), 4, (FILE *) *local);
if (flush_mode) fflush((FILE *) *local);
}
return 0;
}
int f_hybrid(ARG0) {
int pdtsize, n, secsize, k;
if (mode >= 0) {
pdtsize = prod_def_temp_size(sec); // size of PDT with no extra vert coordinates
secsize = GB2_Sec4_size(sec); // size of PDT + vert coordinatese + extras
n = uint2(&(sec[4][5])); // number of vert coordinate values
if (n % 2 != 0) fatal_error_i("vertical coordinate parameters should be in pairs, n=%d", n);
if (n == 0) return 0;
if (pdtsize + 4*n > secsize)
fatal_error("not enough space allocated for vertical coordinate data","");
sprintf(inv_out,"Hybrid levels=%d", n/2);
inv_out += strlen(inv_out);
for (k = 1; k <= n/2; k++) {
sprintf(inv_out," %d=(%9.6f,%9.6f)", k, (double) ieee2flt(sec[4]+pdtsize+k*8-8),
(double) ieee2flt(sec[4]+pdtsize+k*8-4));
inv_out += strlen(inv_out);
}
}
return 0;
}
/*
* HEADER:400:JMA:inv:0:inventory for JMA locally defined PDT
*/
int f_JMA(ARG0) {
int pdt, i, nr;
int center;
if (mode < 0) return 0;
center = GB2_Center(sec);
if (center != JMA1 && center != JMA2) return 0;
pdt = GB2_ProdDefTemplateNo(sec);
if (pdt < 50000) return 0;
if (pdt == 51022) {
sprintf(inv_out,"site=%c%c%c%c", sec[4][24], sec[4][25], sec[4][26], sec[4][27]);
inv_out += strlen(inv_out);
if (mode >= 1) {
sprintf(inv_out,":site_id#=%u", uint2(sec[4]+28));
inv_out += strlen(inv_out);
sprintf(inv_out,":site_lon=%lf:site_lat=%lf:site_elev=%.1lfm",int4(sec[4]+18)*1e-6,
int4(sec[4]+14)*1e-6,int2(sec[4]+22)*0.1) ;
inv_out += strlen(inv_out);
sprintf(inv_out,":mag_dec=%.2fdeg", int2(sec[4]+30)*0.001);
inv_out += strlen(inv_out);
sprintf(inv_out,":freq=%ukHz", uint4(sec[4]+32));
inv_out += strlen(inv_out);
sprintf(inv_out,":pol=%d:opn_mode=%d:reflec=%d", (int) sec[4][36], (int) sec[4][37], (int) sec[4][38]);
inv_out += strlen(inv_out);
sprintf(inv_out,":qc=%d:cluster_filter=%d", (int) sec[4][39], (int) sec[4][40]);
inv_out += strlen(inv_out);
sprintf(inv_out,":angle_elev_constant=%.2f", int2(sec[4]+41)*0.01);
inv_out += strlen(inv_out);
}
nr = GB2_Sec4_size(sec);
nr = (nr % 4) ? -1 : (nr - 60) / 4;
if (mode >= 1) {
sprintf(inv_out,":Ntheta=%d", nr);
inv_out += strlen(inv_out);
i = uint_n(sec[4]+55, 3);
if (i != 0xffffff) {
sprintf(inv_out,":bin_size=%dm", i);
inv_out += strlen(inv_out);
}
if ((sec[4][58] != 255) || (sec[4][59] != 255)) {
sprintf(inv_out,":d_theta=%.1lfdeg", int2(sec[4]+58)*0.1);
inv_out += strlen(inv_out);
}
}
if (mode < 2) {
sprintf(inv_out,":ele(1)=%.2fdeg", int2(sec[4]+60)*0.01);
inv_out += strlen(inv_out);
sprintf(inv_out,":ele(%d)=%.2fdeg", nr/2,int2(sec[4]+60+((nr-1)/2)*4)*0.01);
inv_out += strlen(inv_out);
}
if (mode >= 2) {
sprintf(inv_out,"\n:elevation angle(1..Ntheta)=");
inv_out += strlen(inv_out);
for (i = 0; i < nr; i++) {
sprintf(inv_out,"%.2f ", int2(sec[4]+60+i*4)*0.01);
inv_out += strlen(inv_out);
}
sprintf(inv_out,"\n:pulse repetion freq(1..Ntheta)=");
inv_out += strlen(inv_out);
for (i = 0; i < nr; i++) {
sprintf(inv_out,"%.2f ", int2(sec[4]+62+i*4)*0.01);
inv_out += strlen(inv_out);
}
}
}
return 0;
}
static int do_ave(struct ave_struct *save) {
int i, j, n, ndata, pdt;
float *data;
unsigned char *p, *sec4;
double factor;
sec4 = NULL;
if (save->has_val == 0) return 0;
#ifdef DEBUG
printf(" ave nfields=%d missing=%d\n",save->n_fields,save->n_missing);
#endif
ndata = save->n_sum;
if ((data = (float *) malloc(sizeof(float) * ndata)) == NULL) fatal_error("ave: memory allocation","");
factor = 1.0 / save->n_fields;
for (i = 0; i < ndata; i++) {
if (save->n[i] != save->n_fields) data[i] = UNDEFINED;
else data[i] = factor * save->sum[i];
#ifdef DEBUG
if (i < 10) printf("data[%d]=%lf n[%d]=%d, sum[%d]=%lf\n",
i,data[i],i,save->n[i],i,save->sum[i]);
#endif
}
pdt = GB2_ProdDefTemplateNo(save->first_sec);
// average of a forecast
if (pdt == 0) {
sec4 = (unsigned char *) malloc(58 * sizeof(unsigned char));
if (sec4 == NULL) fatal_error("fcst_ave: memory allocation","");
for (i = 0; i < 34; i++) {
sec4[i] = save->first_sec[4][i];
}
uint_char((unsigned int) 58, sec4); // length
sec4[8] = 8; // pdt
// verification time
save_time(save->year2,save->month2,save->day2,save->hour2,save->minute2,save->second2, sec4+34);
sec4[41] = 1; // 1 time range
uint_char(save->n_missing, sec4+42);
sec4[46] = 0; // average
sec4[47] = 2; // rt=constant, ft++
sec4[48] = save->dt_unit; // total length of stat processing
uint_char(save->dt*(save->n_fields+save->n_missing-1), sec4+49);
sec4[53] = save->dt_unit; // time step
uint_char(save->dt, sec4+54);
}
// average of an ensemble forecast, use pdt 4.11
else if (pdt == 1) {
sec4 = (unsigned char *) malloc(61 * sizeof(unsigned char));
if (sec4 == NULL) fatal_error("fcst_ave: memory allocation","");
for (i = 0; i < 37; i++) {
sec4[i] = save->first_sec[4][i];
}
uint_char((unsigned int) 61, sec4); // length
sec4[8] = 11; // pdt
// verification time
save_time(save->year2,save->month2,save->day2,save->hour2,save->minute2,save->second2, sec4+37);
sec4[44] = 1; // 1 time range
uint_char(save->n_missing, sec4+45);
sec4[49] = 0; // average
sec4[50] = 2; // rt=constant, ft++
sec4[51] = save->dt_unit; // total length of stat processing
uint_char(save->dt*(save->n_fields+save->n_missing-1), sec4+52);
sec4[56] = save->dt_unit; // time step
uint_char(save->dt, sec4+57);
}
// average of an average or accumulation
else if (pdt == 8) {
i = GB2_Sec4_size(save->first_sec);
n = save->first_sec[4][41];
if (i != 46 + 12*n) fatal_error("ave: invalid sec4 size for pdt=8","");
// keep pdt == 8 but make it 12 bytes bigger
sec4 = (unsigned char *) malloc( (i+12) * sizeof(unsigned char));
if (sec4 == NULL) fatal_error("fcst_ave: memory allocation","");
uint_char((unsigned int) i+12, sec4); // new length
for (i = 4; i < 34; i++) { // keep base of pdt
sec4[i] = save->first_sec[4][i];
}
// new verification time
save_time(save->year2,save->month2,save->day2,save->hour2,save->minute2,save->second2, sec4+34);
// number of stat-proc loops is increased by 1
sec4[41] = n + 1;
// copy old stat-proc loops
// for (j = n*12-1; j >= 0; j--) sec4[58+j] = save->first_sec[4][46+j];
for (j = 0; j < n*12; j++) sec4[46+12+j] = save->first_sec[4][46+j];
#ifdef DEBUG
printf("save->n_missing =%d save->n_fields=%d\n",save->n_missing,save->n_fields);
#endif
uint_char(save->n_missing, sec4+42);
sec4[46] = 0; // average
sec4[47] = 2; // fcst++
sec4[48] = save->dt_unit; // total length of stat processing
uint_char(save->dt*(save->n_fields+save->n_missing-1), sec4+49); // missing
sec4[53] = save->dt_unit; // time step
uint_char(save->dt, sec4+54);
}
else {
fatal_error_i("ave with pdt %d is not supported",pdt);
}
// write grib file
p = save->first_sec[4];
save->first_sec[4] = sec4;
grib_wrt(save->first_sec, data, ndata, save->nx, save->ny,
save->use_scale, save->dec_scale, save->bin_scale,
save->wanted_bits, save->max_bits, save->grib_type, save->output);
if (flush_mode) fflush(save->output);
save->first_sec[4] = p;
free(data);
free(sec4);
return 0;
}
