void
initialize(int argc, char **argv)
{
SET_PROGNAME();
bi_vars_init(); /* load the builtin variables */
bi_funct_init(); /* load the builtin functions */
kw_init(); /* load the keywords */
field_init();
#if USE_BINMODE
{
char *p = getenv("MAWKBINMODE");
if (p)
set_binmode(atoi(p));
}
#endif
process_cmdline(argc, argv);
code_init();
fpe_init();
set_stdio();
#if USE_BINMODE
stdout_init();
#endif
}
void simulator_resetField(FieldInfo field_info)
{
//横幅(nm), 縦幅(nm), 1セルのサイズ(nm), pmlレイヤの数, 波長(nm), 計算ステップ
field_init(field_info);
(*initMethod)(); //Solverの初期化, EPS, Coeffの再設定
gettimeofday(&timer1, NULL);
}
void simulator_init(FieldInfo field_info)
{
//横幅(nm), 縦幅(nm), 1セルのサイズ(nm), pmlレイヤの数, 波長(nm), 計算ステップ
field_init(field_info); //フィールドの初期化
models_initModel(); //モデルの初期化
(*initMethod)(); //Solverの初期化, EPS, Coeffの設定
gettimeofday(&timer1, NULL); //開始時間の取得
}
void field_init_quadratic(field_ptr f, field_ptr fbase) {
field_init(f);
f->field_clear = field_clear_fq;
f->data = fbase;
f->init = fq_init;
f->clear = fq_clear;
f->set_si = fq_set_si;
f->set_mpz = fq_set_mpz;
f->to_mpz = fq_to_mpz;
f->out_str = fq_out_str;
f->snprint = fq_snprint;
f->set_multiz = fq_set_multiz;
f->set_str = fq_set_str;
f->sign = fq_sign;
f->add = fq_add;
f->sub = fq_sub;
f->set = fq_set;
f->mul = fq_mul;
f->mul_mpz = fq_mul_mpz;
f->mul_si = fq_mul_si;
f->square = fq_square;
f->doub = fq_double;
f->neg = fq_neg;
f->cmp = fq_cmp;
f->invert = fq_invert;
f->random = fq_random;
f->from_hash = fq_from_hash;
f->is1 = fq_is1;
f->is0 = fq_is0;
f->set0 = fq_set0;
f->set1 = fq_set1;
f->is_sqr = fq_is_sqr;
f->sqrt = fq_sqrt;
f->to_bytes = fq_to_bytes;
f->from_bytes = fq_from_bytes;
f->out_info = fq_out_info;
f->item_count = fq_item_count;
f->item = fq_item;
f->get_x = fq_get_x;
f->get_y = fq_get_y;
mpz_mul(f->order, fbase->order, fbase->order);
if (fbase->fixed_length_in_bytes < 0) {
f->length_in_bytes = fq_length_in_bytes;
f->fixed_length_in_bytes = -1;
} else {
f->fixed_length_in_bytes = 2 * fbase->fixed_length_in_bytes;
}
}
void pairing_GT_init(pairing_ptr pairing, field_t f) {
field_ptr gt = pairing->GT;
field_init(gt);
gt->data = f;
f->pairing = pairing;
mpz_set(gt->order, pairing->r);
gt->field_clear = mulg_field_clear;
gt->out_info = gt_out_info;
gt->init = mulg_init;
gt->clear = mulg_clear;
gt->set = mulg_set;
gt->cmp = mulg_cmp;
gt->out_str = mulg_out_str;
gt->set_multiz = mulg_set_multiz;
gt->set_str = mulg_set_str;
gt->to_bytes = mulg_to_bytes;
gt->from_bytes = mulg_from_bytes;
gt->length_in_bytes = mulg_length_in_bytes;
gt->fixed_length_in_bytes = f->fixed_length_in_bytes;
gt->to_mpz = mulg_to_mpz;
gt->snprint = mulg_snprint;
gt->item = mulg_item;
gt->item_count = mulg_item_count;
// TODO: set gt->nqr to something?
// set is_sqr, sqrt to something?
// additive notation
gt->set0 = mulg_set1;
gt->add = mulg_mul;
gt->sub = mulg_div;
gt->mul_mpz = mulg_pow_mpz;
gt->neg = mulg_invert;
gt->is0 = mulg_is1;
// multiplicative notation
gt->set1 = mulg_set1;
gt->mul = mulg_mul;
gt->div = mulg_div;
gt->pow_mpz = mulg_pow_mpz;
gt->invert = mulg_invert;
gt->is1 = mulg_is1;
gt->pp_init = mulg_pp_init;
gt->pp_clear = mulg_pp_clear;
gt->pp_pow = mulg_pp_pow;
gt->random = gt_random;
gt->from_hash = gt_from_hash;
}
Game * game_init(struct timeval start_time) {
Game *game = malloc(sizeof(Game));
Field *field = field_init();
Player *player = player_init(field, 10);
Ball *ball = ball_init(field);
game->field = field;
game->player = player;
game->ball = ball;
game->start_time = start_time;
return game;
}
void field_init_tiny_fp(field_ptr f, mpz_t prime) {
pbc_mpui *p;
PBC_ASSERT(mpz_fits_ulong_p(prime), "modulus too big");
field_init(f);
f->init = fp_init;
f->clear = fp_clear;
f->set_si = fp_set_si;
f->set_mpz = fp_set_mpz;
f->out_str = fp_out_str;
f->add = fp_add;
f->sub = fp_sub;
f->set = fp_set;
f->mul = fp_mul;
f->mul_si = fp_mul_si;
f->square = fp_square;
f->doub = fp_double;
f->pow_mpz = fp_pow_mpz;
f->neg = fp_neg;
f->cmp = fp_cmp;
f->sign = fp_sgn_odd;
f->invert = fp_invert;
f->random = fp_random;
f->from_hash = fp_from_hash;
f->is1 = fp_is1;
f->is0 = fp_is0;
f->set0 = fp_set0;
f->set1 = fp_set1;
f->is_sqr = fp_is_sqr;
f->sqrt = element_tonelli;
f->field_clear = fp_field_clear;
f->to_bytes = fp_to_bytes;
f->from_bytes = fp_from_bytes;
f->to_mpz = fp_to_mpz;
p = f->data = pbc_malloc(sizeof(pbc_mpui));
*p = mpz_get_ui(prime);
{
pbc_mpui l = 255;
f->fixed_length_in_bytes = 1;
while (l < *p) {
f->fixed_length_in_bytes++;
l <<= 8;
l += 255;
}
}
mpz_set(f->order, prime);
}
void field_init_eta_T_3(field_t f, field_t base) {
field_init(f);
f->data = (void *) base;
f->init = point_init;
f->clear = point_clear;
f->random = point_random;
f->set = point_set;
f->cmp = point_cmp;
f->invert = f->neg = point_invert;
f->mul = f->add = point_add;
f->set1 = f->set0 = point_set0;
f->is1 = f->is0 = point_is0;
f->mul_mpz = f->pow_mpz;
f->out_str = point_out_str;
f->field_clear = point_field_clear;
f->name = "eta_T_3 point group";
}
void simulator_init(FieldInfo field_info){
//横幅(nm), 縦幅(nm), 1セルのサイズ(nm), pmlレイヤの数, 波長(nm), 計算ステップ
field_init(field_info);
models_init();
/*NO_MODEL. MIE_CYLINDER, SHELF(todo), NONSHELF(todo) */
// models_setModel(model); //次にこれ,モデル(散乱体)を定義
// setSolver(solver); //Solverの設定
(*initMethod)(); //Solverの初期化, EPS, Coeffの設定
/*POINT_LIGHT_IN_CENTER: 中心に点光源 SCATTER: 散乱波*/
//field_setDefaultIncidence(SCATTER); //入射波の設定
gettimeofday(&timer1, NULL);
}
void field_init_fast_fp(field_ptr f, mpz_t prime) {
PBC_ASSERT(!mpz_fits_ulong_p(prime), "modulus too small");
fp_field_data_ptr p;
field_init(f);
f->init = fp_init;
f->clear = fp_clear;
f->set_si = fp_set_si;
f->set_mpz = fp_set_mpz;
f->out_str = fp_out_str;
f->add = fp_add;
f->sub = fp_sub;
f->set = fp_set;
f->mul = fp_mul;
f->mul_si = fp_mul_si;
f->square = fp_square;
f->doub = fp_double;
f->halve = fp_halve;
f->pow_mpz = fp_pow_mpz;
f->neg = fp_neg;
f->cmp = fp_cmp;
f->sign = mpz_odd_p(prime) ? fp_sgn_odd : fp_sgn_even;
f->invert = fp_invert;
f->random = fp_random;
f->from_hash = fp_from_hash;
f->is1 = fp_is1;
f->is0 = fp_is0;
f->set0 = fp_set0;
f->set1 = fp_set1;
f->is_sqr = fp_is_sqr;
f->sqrt = element_tonelli;
f->field_clear = fp_field_clear;
f->to_bytes = fp_to_bytes;
f->from_bytes = fp_from_bytes;
f->to_mpz = fp_to_mpz;
p = f->data = pbc_malloc(sizeof(fp_field_data_t));
p->limbs = mpz_size(prime);
p->bytes = p->limbs * sizeof(mp_limb_t);
p->primelimbs = pbc_malloc(p->bytes);
mpz_export(p->primelimbs, &p->limbs, -1, sizeof(mp_limb_t), 0, 0, prime);
mpz_set(f->order, prime);
f->fixed_length_in_bytes = (mpz_sizeinbase(prime, 2) + 7) / 8;
}
/* initialize the finite field as $GF(3^m)$, whose irreducible polynomial is with the degree of $m$ */
void field_init_gf3m(field_t f, unsigned m, unsigned t) {
params *p = (params *)pbc_malloc(sizeof(*p));
p->len = (m + (W - 1) + 1) / W; /* extra one bit for $_p$ */
p->m = m;
p->t = t;
p->p = (element_ptr)pbc_malloc(sizeof(*(p->p)));
p->p->field = f;
p->p->data = pbc_malloc(2 * sizeof(unsigned long) * p->len);
memset(p->p->data, 0, 2 * sizeof(unsigned long) * p->len);
unsigned long *p1 = (unsigned long *)p->p->data, *p2 = p1 + p->len;
p2[0] = 1; /* _p == x^m+x^t+2 */
unsigned int p_t = p->t;
p1[p_t / W] |= 1ul << (p_t % W);
p1[m / W] |= 1ul << (m % W);
field_init(f);
f->field_clear = field_clear_gf3m;
f->init = gf3m_init;
f->clear = gf3m_clear;
f->set = gf3m_assign;
f->set0 = gf3m_zero;
f->set1 = gf3m_one;
f->is0 = gf3m_is0;
f->is1 = gf3m_is1;
f->add = gf3m_add;
f->sub = gf3m_sub;
f->mul = gf3m_mult;
f->cubic = gf3m_cubic;
f->invert = gf3m_invert;
f->neg = gf3m_neg;
f->random = gf3m_random;
f->cmp = gf3m_cmp;
f->sqrt = gf3m_sqrt;
f->from_bytes = gf3m_from_bytes;
f->to_bytes = gf3m_to_bytes;
f->out_str = gf3m_out_str;
f->fixed_length_in_bytes = 2 * sizeof(unsigned long) * p->len;
f->data = p;
f->name = "GF(3^m)";
mpz_set_ui(f->order, 3);
mpz_pow_ui(f->order, f->order, p->m);
}
void field_init_naive_fp(field_ptr f, mpz_t prime) {
field_init(f);
f->init = zp_init;
f->clear = zp_clear;
f->set_si = zp_set_si;
f->set_mpz = zp_set_mpz;
f->out_str = zp_out_str;
f->snprint = zp_snprint;
f->set_str = zp_set_str;
f->sign = mpz_odd_p(prime) ? zp_sgn_odd : zp_sgn_even;
f->add = zp_add;
f->sub = zp_sub;
f->set = zp_set;
f->square = zp_square;
f->doub = zp_double;
f->halve = zp_halve;
f->mul = zp_mul;
f->mul_mpz = zp_mul_mpz;
f->mul_si = zp_mul_si;
f->pow_mpz = zp_pow_mpz;
f->neg = zp_neg;
f->cmp = zp_cmp;
f->invert = zp_invert;
f->random = zp_random;
f->from_hash = zp_from_hash;
f->is1 = zp_is1;
f->is0 = zp_is0;
f->set0 = zp_set0;
f->set1 = zp_set1;
f->is_sqr = zp_is_sqr;
f->sqrt = element_tonelli;
f->field_clear = zp_field_clear;
f->to_bytes = zp_to_bytes;
f->from_bytes = zp_from_bytes;
f->to_mpz = zp_to_mpz;
f->out_info = zp_out_info;
mpz_set(f->order, prime);
f->data = NULL;
f->fixed_length_in_bytes = (mpz_sizeinbase(prime, 2) + 7) / 8;
}
/* initialize the finite field as $base_field[x]/(x^3 - x - 1)$, whose base field is $b$ */
void field_init_gf33m(field_t f, field_t b) {
field_init(f);
f->data = b;
f->field_clear = field_clear_gf33m;
f->init = gf33m_init;
f->clear = gf33m_clear;
f->set = gf33m_assign;
f->set0 = gf33m_set0;
f->set1 = gf33m_set1;
f->random = gf33m_random;
f->cmp = gf33m_cmp;
f->add = gf33m_add;
f->sub = gf33m_sub;
f->mul = gf33m_mult;
f->cubic = gf33m_cubic;
f->invert = gf33m_invert;
f->item_count = gf33m_item_count;
f->item = gf33m_item;
f->out_str = gf33m_out_str;
mpz_pow_ui(f->order, b->order, 3);
f->name = "GF(3^{3*m})";
}
//============================================
//
//============================================
int main(void)
{
Field f;
field_init(f, "bn254_fp6");
test_feature(f);
test_arithmetic_operation(f);
test_sqrt(f);
//test_frob(f);
test_io(f);
field_clear(f);
fprintf(stderr, "ok\n");
return 0;
}
/**
* initialize the game
*/
void game_init() {
fill(&game, 0, sizeof(game_t));
game.player = game.queue;
field_init(&game.field, 10, 6);
screen_init(&game.block_screen,
FIELD_SIZE_X + game.field.screen.first.x +2,
4,
5,
BLOCK_POINTS *4 +1
);
game_block_reset(&game);
for(int x = 0; x < BLOCK_POINTS; ++x) {
block_next(&game.queue[x]);
}
game.timer = 6 *TICKS_PER_SEC;
game_state = STATE_GAME;
}
void *Arith(void *argument)
{
int operatorID;
int operfunc;
enum {FILL_NONE, FILL_TS, FILL_VAR, FILL_VARTS, FILL_FILE};
int filltype = FILL_NONE;
int streamIDx1, streamIDx2, streamID1, streamID2, streamID3;
int gridsize;
int nrecs, nrecs2, nvars = 0, nlev, recID;
int nlevels2 = 1;
int tsID, tsID2;
int varID, levelID;
int varID2, levelID2;
int offset;
int lfill1, lfill2;
int ntsteps1, ntsteps2;
int vlistIDx1, vlistIDx2, vlistID1, vlistID2, vlistID3;
int taxisIDx1, taxisID1, taxisID2, taxisID3;
field_t *fieldx1, *fieldx2, field1, field2;
int *varnmiss2 = NULL;
int **varnmiss = NULL;
double *vardata2 = NULL;
double **vardata = NULL;
cdoInitialize(argument);
cdoOperatorAdd("add", func_add, 0, NULL);
cdoOperatorAdd("sub", func_sub, 0, NULL);
cdoOperatorAdd("mul", func_mul, 0, NULL);
cdoOperatorAdd("div", func_div, 0, NULL);
cdoOperatorAdd("min", func_min, 0, NULL);
cdoOperatorAdd("max", func_max, 0, NULL);
cdoOperatorAdd("atan2", func_atan2, 0, NULL);
operatorID = cdoOperatorID();
operfunc = cdoOperatorF1(operatorID);
streamID1 = streamOpenRead(cdoStreamName(0));
streamID2 = streamOpenRead(cdoStreamName(1));
streamIDx1 = streamID1;
streamIDx2 = streamID2;
fieldx1 = &field1;
fieldx2 = &field2;
vlistID1 = streamInqVlist(streamID1);
vlistID2 = streamInqVlist(streamID2);
vlistIDx1 = vlistID1;
vlistIDx2 = vlistID2;
if ( cdoVerbose ) vlistPrint(vlistID1);
if ( cdoVerbose ) vlistPrint(vlistID2);
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = vlistInqTaxis(vlistID2);
taxisIDx1 = taxisID1;
ntsteps1 = vlistNtsteps(vlistID1);
ntsteps2 = vlistNtsteps(vlistID2);
if ( ntsteps1 == 0 ) ntsteps1 = 1;
if ( ntsteps2 == 0 ) ntsteps2 = 1;
if ( vlistNvars(vlistID1) == 1 && vlistNvars(vlistID2) == 1 )
{
lfill2 = vlistNrecs(vlistID1) != 1 && vlistNrecs(vlistID2) == 1;
lfill1 = vlistNrecs(vlistID1) == 1 && vlistNrecs(vlistID2) != 1;
}
else
{
lfill2 = vlistNvars(vlistID1) != 1 && vlistNvars(vlistID2) == 1;
lfill1 = vlistNvars(vlistID1) == 1 && vlistNvars(vlistID2) != 1;
}
if ( lfill2 )
{
nlevels2 = vlistCompareX(vlistID1, vlistID2, CMP_DIM);
if ( ntsteps1 != 1 && ntsteps2 == 1 )
{
filltype = FILL_VAR;
cdoPrint("Filling up stream2 >%s< by copying the first variable.", cdoStreamName(1)->args);
}
else
{
filltype = FILL_VARTS;
cdoPrint("Filling up stream2 >%s< by copying the first variable of each timestep.", cdoStreamName(1)->args);
}
}
else if ( lfill1 )
{
nlevels2 = vlistCompareX(vlistID2, vlistID1, CMP_DIM);
if ( ntsteps1 == 1 && ntsteps2 != 1 )
{
filltype = FILL_VAR;
cdoPrint("Filling up stream1 >%s< by copying the first variable.", cdoStreamName(0)->args);
}
else
{
filltype = FILL_VARTS;
cdoPrint("Filling up stream1 >%s< by copying the first variable of each timestep.", cdoStreamName(0)->args);
}
streamIDx1 = streamID2;
streamIDx2 = streamID1;
vlistIDx1 = vlistID2;
vlistIDx2 = vlistID1;
taxisIDx1 = taxisID2;
fieldx1 = &field2;
fieldx2 = &field1;
}
if ( filltype == FILL_NONE ) vlistCompare(vlistID1, vlistID2, CMP_ALL);
gridsize = vlistGridsizeMax(vlistIDx1);
field_init(&field1);
field_init(&field2);
field1.ptr = (double*) malloc(gridsize*sizeof(double));
field2.ptr = (double*) malloc(gridsize*sizeof(double));
if ( filltype == FILL_VAR || filltype == FILL_VARTS )
{
vardata2 = (double*) malloc(gridsize*nlevels2*sizeof(double));
varnmiss2 = (int*) malloc(nlevels2*sizeof(int));
}
if ( cdoVerbose ) cdoPrint("Number of timesteps: file1 %d, file2 %d", ntsteps1, ntsteps2);
if ( filltype == FILL_NONE )
{
if ( ntsteps1 != 1 && ntsteps2 == 1 )
{
filltype = FILL_TS;
cdoPrint("Filling up stream2 >%s< by copying the first timestep.", cdoStreamName(1)->args);
}
else if ( ntsteps1 == 1 && ntsteps2 != 1 )
{
filltype = FILL_TS;
cdoPrint("Filling up stream1 >%s< by copying the first timestep.", cdoStreamName(0)->args);
streamIDx1 = streamID2;
streamIDx2 = streamID1;
vlistIDx1 = vlistID2;
vlistIDx2 = vlistID1;
taxisIDx1 = taxisID2;
fieldx1 = &field2;
fieldx2 = &field1;
}
if ( filltype == FILL_TS )
{
nvars = vlistNvars(vlistIDx2);
vardata = (double **) malloc(nvars*sizeof(double *));
varnmiss = (int **) malloc(nvars*sizeof(int *));
for ( varID = 0; varID < nvars; varID++ )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistIDx2, varID));
nlev = zaxisInqSize(vlistInqVarZaxis(vlistIDx2, varID));
vardata[varID] = (double*) malloc(nlev*gridsize*sizeof(double));
varnmiss[varID] = (int*) malloc(nlev*sizeof(int));
}
}
}
vlistID3 = vlistDuplicate(vlistIDx1);
if ( filltype == FILL_TS && vlistIDx1 != vlistID1 )
{
nvars = vlistNvars(vlistID1);
for ( varID = 0; varID < nvars; varID++ )
vlistDefVarMissval(vlistID3, varID, vlistInqVarMissval(vlistID1, varID));
}
taxisID3 = taxisDuplicate(taxisIDx1);
vlistDefTaxis(vlistID3, taxisID3);
streamID3 = streamOpenWrite(cdoStreamName(2), cdoFiletype());
streamDefVlist(streamID3, vlistID3);
tsID = 0;
tsID2 = 0;
while ( (nrecs = streamInqTimestep(streamIDx1, tsID)) )
{
if ( tsID == 0 || filltype == FILL_NONE || filltype == FILL_FILE || filltype == FILL_VARTS )
{
nrecs2 = streamInqTimestep(streamIDx2, tsID2);
if ( nrecs2 == 0 )
{
if ( filltype == FILL_NONE && streamIDx2 == streamID2 )
{
filltype = FILL_FILE;
cdoPrint("Filling up stream2 >%s< by copying all timesteps.", cdoStreamName(1)->args);
}
if ( filltype == FILL_FILE )
{
tsID2 = 0;
streamClose(streamID2);
streamID2 = streamOpenRead(cdoStreamName(1));
streamIDx2 = streamID2;
vlistID2 = streamInqVlist(streamID2);
vlistIDx2 = vlistID2;
vlistCompare(vlistID1, vlistID2, CMP_DIM);
nrecs2 = streamInqTimestep(streamIDx2, tsID2);
if ( nrecs2 == 0 )
cdoAbort("Empty input stream %s!", cdoStreamName(1)->args);
}
else
cdoAbort("Input streams have different number of timesteps!");
}
}
taxisCopyTimestep(taxisID3, taxisIDx1);
streamDefTimestep(streamID3, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamIDx1, &varID, &levelID);
streamReadRecord(streamIDx1, fieldx1->ptr, &fieldx1->nmiss);
if ( tsID == 0 || filltype == FILL_NONE || filltype == FILL_FILE || filltype == FILL_VARTS )
{
int lstatus = nlevels2 > 1 ? varID == 0 : recID == 0;
if ( lstatus || (filltype != FILL_VAR && filltype != FILL_VARTS) )
{
streamInqRecord(streamIDx2, &varID2, &levelID2);
streamReadRecord(streamIDx2, fieldx2->ptr, &fieldx2->nmiss);
}
if ( filltype == FILL_TS )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistIDx2, varID));
offset = gridsize*levelID;
memcpy(vardata[varID]+offset, fieldx2->ptr, gridsize*sizeof(double));
varnmiss[varID][levelID] = fieldx2->nmiss;
}
else if ( lstatus && (filltype == FILL_VAR || filltype == FILL_VARTS) )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistIDx2, 0));
offset = gridsize*levelID2;
memcpy(vardata2+offset, fieldx2->ptr, gridsize*sizeof(double));
varnmiss2[levelID2] = fieldx2->nmiss;
}
}
else if ( filltype == FILL_TS )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistIDx2, varID2));
offset = gridsize*levelID;
memcpy(fieldx2->ptr, vardata[varID]+offset, gridsize*sizeof(double));
fieldx2->nmiss = varnmiss[varID][levelID];
}
fieldx1->grid = vlistInqVarGrid(vlistIDx1, varID);
fieldx1->missval = vlistInqVarMissval(vlistIDx1, varID);
if ( filltype == FILL_VAR || filltype == FILL_VARTS )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistIDx2, 0));
levelID2 = 0;
if ( nlevels2 > 1 ) levelID2 = levelID;
offset = gridsize*levelID2;
memcpy(fieldx2->ptr, vardata2+offset, gridsize*sizeof(double));
fieldx2->nmiss = varnmiss2[levelID2];
fieldx2->grid = vlistInqVarGrid(vlistIDx2, 0);
fieldx2->missval = vlistInqVarMissval(vlistIDx2, 0);
}
else
{
fieldx2->grid = vlistInqVarGrid(vlistIDx2, varID2);
fieldx2->missval = vlistInqVarMissval(vlistIDx2, varID2);
}
farfun(&field1, field2, operfunc);
streamDefRecord(streamID3, varID, levelID);
streamWriteRecord(streamID3, field1.ptr, field1.nmiss);
}
tsID++;
tsID2++;
}
streamClose(streamID3);
streamClose(streamID2);
streamClose(streamID1);
vlistDestroy(vlistID3);
if ( vardata )
{
for ( varID = 0; varID < nvars; varID++ )
{
free(vardata[varID]);
free(varnmiss[varID]);
}
free(vardata);
free(varnmiss);
}
if ( field1.ptr ) free(field1.ptr);
if ( field2.ptr ) free(field2.ptr);
if ( vardata2 ) free(vardata2);
if ( varnmiss2 ) free(varnmiss2);
cdoFinish();
return (0);
}
void makeit(void)
{
wcsstruct *wcs;
fieldstruct **fields,
*field;
psfstruct **cpsf,
*psf;
setstruct *set, *set2;
contextstruct *context, *fullcontext;
struct tm *tm;
char str[MAXCHAR];
char **incatnames,
*pstr;
float **psfbasiss,
*psfsteps, *psfbasis, *basis,
psfstep, step;
int c,i,p, ncat, ext, next, nmed, nbasis;
/* Install error logging */
error_installfunc(write_error);
incatnames = prefs.incat_name;
ncat = prefs.ncat;
/* Processing start date and time */
thetime = time(NULL);
tm = localtime(&thetime);
sprintf(prefs.sdate_start,"%04d-%02d-%02d",
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
sprintf(prefs.stime_start,"%02d:%02d:%02d",
tm->tm_hour, tm->tm_min, tm->tm_sec);
NFPRINTF(OUTPUT, "");
QPRINTF(OUTPUT,
"----- %s %s started on %s at %s with %d thread%s\n\n",
BANNER,
MYVERSION,
prefs.sdate_start,
prefs.stime_start,
prefs.nthreads,
prefs.nthreads>1? "s":"");
/* End here if no filename has been provided */
if (!ncat)
{
/*-- Processing end date and time */
thetime2 = time(NULL);
tm = localtime(&thetime2);
sprintf(prefs.sdate_end,"%04d-%02d-%02d",
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
sprintf(prefs.stime_end,"%02d:%02d:%02d",
tm->tm_hour, tm->tm_min, tm->tm_sec);
prefs.time_diff = difftime(thetime2, thetime);
/*-- Write XML */
if (prefs.xml_flag)
{
init_xml(0);
write_xml(prefs.xml_name);
end_xml();
}
return;
}
/* Create an array of PSFs (one PSF for each extension) */
QMALLOC(fields, fieldstruct *, ncat);
NFPRINTF(OUTPUT, "");
QPRINTF(OUTPUT, "----- %d input catalogues:\n", ncat);
for (c=0; c<ncat; c++)
{
fields[c] = field_init(incatnames[c]);
QPRINTF(OUTPUT, "%-20.20s: \"%-16.16s\" %3d extension%s %7d detection%s\n",
fields[c]->rcatname, fields[c]->ident,
fields[c]->next, fields[c]->next>1 ? "s":"",
fields[c]->ndet, fields[c]->ndet>1 ? "s":"");
}
QPRINTF(OUTPUT, "\n");
if (prefs.xml_flag)
init_xml(ncat);
makeit_body(fields, &context, &fullcontext, 1);
next = fields[0]->next;
/* Write XML */
if (prefs.xml_flag)
{
NFPRINTF(OUTPUT, "Writing XML file...");
write_xml(prefs.xml_name);
end_xml();
}
/* Save result */
for (c=0; c<ncat; c++)
{
sprintf(str, "Saving PSF model and metadata for %s...",
fields[c]->rtcatname);
NFPRINTF(OUTPUT, str);
/*-- Create a file name with a "PSF" extension */
if (*prefs.psf_dir)
{
if ((pstr = strrchr(incatnames[c], '/')))
pstr++;
else
pstr = incatnames[c];
sprintf(str, "%s/%s", prefs.psf_dir, pstr);
}
else
strcpy(str, incatnames[c]);
if (!(pstr = strrchr(str, '.')))
pstr = str+strlen(str);
sprintf(pstr, "%s", prefs.psf_suffix);
field_psfsave(fields[c], str);
/* Create homogenisation kernels */
if (prefs.homobasis_type != HOMOBASIS_NONE)
{
for (ext=0; ext<next; ext++)
{
if (next>1)
sprintf(str, "Computing homogenisation kernel for %s[%d/%d]...",
fields[c]->rtcatname, ext+1, next);
else
sprintf(str, "Computing homogenisation kernel for %s...",
fields[c]->rtcatname);
NFPRINTF(OUTPUT, str);
if (*prefs.homokernel_dir)
{
if ((pstr = strrchr(incatnames[c], '/')))
pstr++;
else
pstr = incatnames[c];
sprintf(str, "%s/%s", prefs.homokernel_dir, pstr);
}
else
strcpy(str, incatnames[c]);
if (!(pstr = strrchr(str, '.')))
pstr = str+strlen(str);
sprintf(pstr, "%s", prefs.homokernel_suffix);
psf_homo(fields[c]->psf[ext], str, prefs.homopsf_params,
prefs.homobasis_number, prefs.homobasis_scale, ext, next);
}
}
#ifdef HAVE_PLPLOT
/* Plot diagnostic maps for all catalogs */
cplot_ellipticity(fields[c]);
cplot_fwhm(fields[c]);
cplot_moffatresi(fields[c]);
cplot_asymresi(fields[c]);
cplot_counts(fields[c]);
cplot_countfrac(fields[c]);
cplot_modchi2(fields[c]);
cplot_modresi(fields[c]);
#endif
/*-- Update XML */
if (prefs.xml_flag)
update_xml(fields[c]);
}
/* Processing end date and time */
thetime2 = time(NULL);
tm = localtime(&thetime2);
sprintf(prefs.sdate_end,"%04d-%02d-%02d",
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
sprintf(prefs.stime_end,"%02d:%02d:%02d",
tm->tm_hour, tm->tm_min, tm->tm_sec);
prefs.time_diff = difftime(thetime2, thetime);
/* Free memory */
for (c=0; c<ncat; c++)
field_end(fields[c]);
free(fields);
if (context->npc)
context_end(fullcontext);
context_end(context);
return;
}
void field_init_mont_fp(field_ptr f, mpz_t prime) {
PBC_ASSERT(!mpz_fits_ulong_p(prime), "modulus too small");
fptr p;
field_init(f);
f->init = fp_init;
f->clear = fp_clear;
f->set_si = fp_set_si;
f->set_mpz = fp_set_mpz;
f->out_str = fp_out_str;
f->snprint = fp_snprint;
f->set_str = fp_set_str;
f->add = fp_add;
f->sub = fp_sub;
f->set = fp_set;
f->mul = fp_mul;
f->doub = fp_double;
f->halve = fp_halve;
f->pow_mpz = fp_pow_mpz;
f->neg = fp_neg;
f->sign = fp_sgn_odd;
f->cmp = fp_cmp;
f->invert = fp_invert;
f->random = fp_random;
f->from_hash = fp_from_hash;
f->is1 = fp_is1;
f->is0 = fp_is0;
f->set0 = fp_set0;
f->set1 = fp_set1;
f->is_sqr = fp_is_sqr;
f->sqrt = element_tonelli;
f->field_clear = fp_field_clear;
f->to_bytes = fp_to_bytes;
f->from_bytes = fp_from_bytes;
f->to_mpz = fp_to_mpz;
f->out_info = fp_out_info;
// Initialize per-field data specific to this implementation.
f->data = pbc_malloc(sizeof(*p));
p = (fptr)f->data;
p->limbs = mpz_size(prime);
p->bytes = p->limbs * sizeof(mp_limb_t);
p->primelimbs = (mp_limb_t*)pbc_malloc(p->bytes);
mpz_export(p->primelimbs, &p->limbs, -1, sizeof(mp_limb_t), 0, 0, prime);
mpz_set(f->order, prime);
f->fixed_length_in_bytes = (mpz_sizeinbase(prime, 2) + 7) / 8;
// Compute R, R3 and negpinv.
mpz_t z;
mpz_init(z);
p->R = (mp_limb_t*)pbc_malloc(p->bytes);
p->R3 = (mp_limb_t*)pbc_malloc(p->bytes);
mpz_setbit(z, p->bytes * 8);
mpz_mod(z, z, prime);
set_limbs(p->R, z, p->limbs);
mpz_powm_ui(z, z, 3, prime);
set_limbs(p->R3, z, p->limbs);
mpz_set_ui(z, 0);
// Algorithm II.5 in Blake, Seroussi and Smart is better but this suffices
// since we're only doing it once.
mpz_setbit(z, p->bytes * 8);
mpz_invert(z, prime, z);
#ifdef _MSC_VER // for VC++ compatibility
int tmp = mpz_get_ui(z);
p->negpinv = -tmp;
#else
p->negpinv = -mpz_get_ui(z);
#endif
mpz_clear(z);
}
void field_init_curve_ab(field_ptr f, element_ptr a, element_ptr b, mpz_t order, mpz_t cofac) {
/*
if (element_is0(a)) {
c->double_nocheck = cc_double_no_check_ais0;
} else {
c->double_nocheck = cc_double_no_check;
}
*/
curve_data_ptr cdp;
field_init(f);
mpz_set(f->order, order);
f->data = pbc_malloc(sizeof(*cdp));
cdp = (curve_data_ptr)f->data;
cdp->field = a->field;
element_init(cdp->a, cdp->field);
element_init(cdp->b, cdp->field);
element_set(cdp->a, a);
element_set(cdp->b, b);
f->init = curve_init;
f->clear = curve_clear;
f->neg = f->invert = curve_invert;
f->square = f->doub = curve_double;
f->multi_doub = multi_double;
f->add = f->mul = curve_mul;
f->multi_add = multi_add;
f->mul_mpz = element_pow_mpz;
f->cmp = curve_cmp;
f->set0 = f->set1 = curve_set1;
f->is0 = f->is1 = curve_is1;
f->sign = curve_sign;
f->set = curve_set;
f->random = curve_random_pointmul;
//f->random = curve_random_solvefory;
f->from_hash = curve_from_hash;
f->out_str = curve_out_str;
f->snprint = curve_snprint;
f->set_multiz = curve_set_multiz;
f->set_str = curve_set_str;
f->field_clear = field_clear_curve;
if (cdp->field->fixed_length_in_bytes < 0) {
f->length_in_bytes = curve_length_in_bytes;
} else {
f->fixed_length_in_bytes = 2 * cdp->field->fixed_length_in_bytes;
}
f->to_bytes = curve_to_bytes;
f->from_bytes = curve_from_bytes;
f->out_info = curve_out_info;
f->item_count = curve_item_count;
f->item = curve_item;
f->get_x = curve_get_x;
f->get_y = curve_get_y;
if (mpz_odd_p(order)) {
f->is_sqr = odd_curve_is_sqr;
} else {
f->is_sqr = even_curve_is_sqr;
}
element_init(cdp->gen_no_cofac, f);
element_init(cdp->gen, f);
curve_random_no_cofac_solvefory(cdp->gen_no_cofac);
if (cofac) {
cdp->cofac = (mpz_ptr)pbc_malloc(sizeof(mpz_t));
mpz_init(cdp->cofac);
mpz_set(cdp->cofac, cofac);
element_mul_mpz(cdp->gen, cdp->gen_no_cofac, cofac);
} else{
cdp->cofac = NULL;
element_set(cdp->gen, cdp->gen_no_cofac);
}
cdp->quotient_cmp = NULL;
}
void *Ymonpctl(void *argument)
{
int gridsize;
int varID;
int recID;
int gridID;
int vdate, vtime;
int year, month, day;
int nrecs, nrecords;
int levelID;
int tsID;
int otsID;
long nsets[NMONTH];
int streamID1, streamID2, streamID3, streamID4;
int vlistID1, vlistID2, vlistID3, vlistID4, taxisID1, taxisID2, taxisID3, taxisID4;
int nmiss;
int nvars, nlevels;
int *recVarID, *recLevelID;
int vdates1[NMONTH], vtimes1[NMONTH];
int vdates2[NMONTH], vtimes2[NMONTH];
field_t **vars1[NMONTH];
field_t field;
double pn;
HISTOGRAM_SET *hsets[NMONTH];
cdoInitialize(argument);
cdoOperatorAdd("ymonpctl", func_pctl, 0, NULL);
operatorInputArg("percentile number");
pn = parameter2double(operatorArgv()[0]);
if ( !(pn > 0 && pn < 100) )
cdoAbort("Illegal argument: percentile number %g is not in the range 0..100!", pn);
for ( month = 0; month < NMONTH; month++ )
{
vars1[month] = NULL;
hsets[month] = NULL;
nsets[month] = 0;
}
streamID1 = streamOpenRead(cdoStreamName(0));
streamID2 = streamOpenRead(cdoStreamName(1));
streamID3 = streamOpenRead(cdoStreamName(2));
vlistID1 = streamInqVlist(streamID1);
vlistID2 = streamInqVlist(streamID2);
vlistID3 = streamInqVlist(streamID3);
vlistID4 = vlistDuplicate(vlistID1);
vlistCompare(vlistID1, vlistID2, CMP_ALL);
vlistCompare(vlistID1, vlistID3, CMP_ALL);
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = vlistInqTaxis(vlistID2);
taxisID3 = vlistInqTaxis(vlistID3);
/* TODO - check that time axes 2 and 3 are equal */
taxisID4 = taxisDuplicate(taxisID1);
if ( taxisHasBounds(taxisID4) ) taxisDeleteBounds(taxisID4);
vlistDefTaxis(vlistID4, taxisID4);
streamID4 = streamOpenWrite(cdoStreamName(3), cdoFiletype());
streamDefVlist(streamID4, vlistID4);
nvars = vlistNvars(vlistID1);
nrecords = vlistNrecs(vlistID1);
recVarID = (int*) malloc(nrecords*sizeof(int));
recLevelID = (int*) malloc(nrecords*sizeof(int));
gridsize = vlistGridsizeMax(vlistID1);
field_init(&field);
field.ptr = (double*) malloc(gridsize*sizeof(double));
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID2, tsID)) )
{
if ( nrecs != streamInqTimestep(streamID3, tsID) )
cdoAbort("Number of records at time step %d of %s and %s differ!", tsID+1, cdoStreamName(1)->args, cdoStreamName(2)->args);
vdate = taxisInqVdate(taxisID2);
vtime = taxisInqVtime(taxisID2);
if ( vdate != taxisInqVdate(taxisID3) || vtime != taxisInqVtime(taxisID3) )
cdoAbort("Verification dates at time step %d of %s and %s differ!", tsID+1, cdoStreamName(1)->args, cdoStreamName(2)->args);
if ( cdoVerbose ) cdoPrint("process timestep: %d %d %d", tsID+1, vdate, vtime);
cdiDecodeDate(vdate, &year, &month, &day);
if ( month < 0 || month >= NMONTH )
cdoAbort("Month %d out of range!", month);
vdates2[month] = vdate;
vtimes2[month] = vtime;
if ( vars1[month] == NULL )
{
vars1[month] = field_malloc(vlistID1, FIELD_PTR);
hsets[month] = hsetCreate(nvars);
for ( varID = 0; varID < nvars; varID++ )
{
gridID = vlistInqVarGrid(vlistID1, varID);
nlevels = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
hsetCreateVarLevels(hsets[month], varID, nlevels, gridID);
}
}
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID2, &varID, &levelID);
streamReadRecord(streamID2, vars1[month][varID][levelID].ptr, &nmiss);
vars1[month][varID][levelID].nmiss = nmiss;
}
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID3, &varID, &levelID);
streamReadRecord(streamID3, field.ptr, &nmiss);
field.nmiss = nmiss;
field.grid = vars1[month][varID][levelID].grid;
field.missval = vars1[month][varID][levelID].missval;
hsetDefVarLevelBounds(hsets[month], varID, levelID, &vars1[month][varID][levelID], &field);
}
tsID++;
}
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
vdate = taxisInqVdate(taxisID1);
vtime = taxisInqVtime(taxisID1);
if ( cdoVerbose ) cdoPrint("process timestep: %d %d %d", tsID+1, vdate, vtime);
cdiDecodeDate(vdate, &year, &month, &day);
if ( month < 0 || month >= NMONTH )
cdoAbort("Month %d out of range!", month);
vdates1[month] = vdate;
vtimes1[month] = vtime;
if ( vars1[month] == NULL )
cdoAbort("No data for month %d in %s and %s", month, cdoStreamName(1)->args, cdoStreamName(2)->args);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
if ( tsID == 0 )
{
recVarID[recID] = varID;
recLevelID[recID] = levelID;
}
streamReadRecord(streamID1, vars1[month][varID][levelID].ptr, &nmiss);
vars1[month][varID][levelID].nmiss = nmiss;
hsetAddVarLevelValues(hsets[month], varID, levelID, &vars1[month][varID][levelID]);
}
nsets[month]++;
tsID++;
}
otsID = 0;
for ( month = 0; month < NMONTH; month++ )
if ( nsets[month] )
{
if ( vdates1[month] != vdates2[month] )
cdoAbort("Verification dates for month %d of %s, %s and %s are different!", month, cdoStreamName(1)->args, cdoStreamName(2)->args, cdoStreamName(3)->args);
if ( vtimes1[month] != vtimes2[month] )
cdoAbort("Verification times for month %d of %s, %s and %s are different!", month, cdoStreamName(1)->args, cdoStreamName(2)->args, cdoStreamName(3)->args);
for ( varID = 0; varID < nvars; varID++ )
{
if ( vlistInqVarTsteptype(vlistID1, varID) == TSTEP_CONSTANT ) continue;
nlevels = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
for ( levelID = 0; levelID < nlevels; levelID++ )
hsetGetVarLevelPercentiles(&vars1[month][varID][levelID], hsets[month], varID, levelID, pn);
}
taxisDefVdate(taxisID4, vdates1[month]);
taxisDefVtime(taxisID4, vtimes1[month]);
streamDefTimestep(streamID4, otsID);
for ( recID = 0; recID < nrecords; recID++ )
{
varID = recVarID[recID];
levelID = recLevelID[recID];
if ( otsID && vlistInqVarTsteptype(vlistID1, varID) == TSTEP_CONSTANT ) continue;
streamDefRecord(streamID4, varID, levelID);
streamWriteRecord(streamID4, vars1[month][varID][levelID].ptr, vars1[month][varID][levelID].nmiss);
}
otsID++;
}
for ( month = 0; month < NMONTH; month++ )
{
if ( vars1[month] != NULL )
{
field_free(vars1[month], vlistID1);
hsetDestroy(hsets[month]);
}
}
if ( field.ptr ) free(field.ptr);
if ( recVarID ) free(recVarID);
if ( recLevelID ) free(recLevelID);
streamClose(streamID4);
streamClose(streamID3);
streamClose(streamID2);
streamClose(streamID1);
cdoFinish();
return (0);
}
void *Timselpctl(void *argument)
{
int timestat_date = TIMESTAT_MEAN;
int vdate2 = 0, vtime2 = 0;
int vdate3 = 0, vtime3 = 0;
int nrecs = 0;
int gridID, varID, levelID, recID;
int tsID;
int nsets = 0;
int i;
int nmiss;
int nlevels;
field_t **vars1 = NULL;
field_t field;
HISTOGRAM_SET *hset = NULL;
cdoInitialize(argument);
cdoOperatorAdd("timselpctl", func_pctl, 0, NULL);
operatorInputArg("percentile number, nsets <,noffset <,nskip>>");
int nargc = operatorArgc();
if ( nargc < 2 ) cdoAbort("Too few arguments! Need %d found %d.", 2, nargc);
double pn = parameter2double(operatorArgv()[0]);
int ndates = parameter2int(operatorArgv()[1]);
int noffset = 0, nskip = 0;
if ( nargc > 2 ) noffset = parameter2int(operatorArgv()[2]);
if ( nargc > 3 ) nskip = parameter2int(operatorArgv()[3]);
if ( !(pn > 0 && pn < 100) )
cdoAbort("Illegal argument: percentile number %g is not in the range 0..100!", pn);
if ( cdoVerbose ) cdoPrint("nsets = %d, noffset = %d, nskip = %d", ndates, noffset, nskip);
int streamID1 = streamOpenRead(cdoStreamName(0));
int streamID2 = streamOpenRead(cdoStreamName(1));
int streamID3 = streamOpenRead(cdoStreamName(2));
int vlistID1 = streamInqVlist(streamID1);
int vlistID2 = streamInqVlist(streamID2);
int vlistID3 = streamInqVlist(streamID3);
int vlistID4 = vlistDuplicate(vlistID1);
vlistCompare(vlistID1, vlistID2, CMP_ALL);
vlistCompare(vlistID1, vlistID3, CMP_ALL);
int taxisID1 = vlistInqTaxis(vlistID1);
int taxisID2 = vlistInqTaxis(vlistID2);
int taxisID3 = vlistInqTaxis(vlistID3);
/* TODO - check that time axes 2 and 3 are equal */
int taxisID4 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID4, taxisID4);
int streamID4 = streamOpenWrite(cdoStreamName(3), cdoFiletype());
streamDefVlist(streamID4, vlistID4);
int nvars = vlistNvars(vlistID1);
int nrecords = vlistNrecs(vlistID1);
int *recVarID = (int*) malloc(nrecords*sizeof(int));
int *recLevelID = (int*) malloc(nrecords*sizeof(int));
dtlist_type *dtlist = dtlist_new();
dtlist_set_stat(dtlist, timestat_date);
dtlist_set_calendar(dtlist, taxisInqCalendar(taxisID1));
int gridsize = vlistGridsizeMax(vlistID1);
field_init(&field);
field.ptr = (double*) malloc(gridsize * sizeof(double));
vars1 = field_malloc(vlistID1, FIELD_PTR);
hset = hsetCreate(nvars);
for ( varID = 0; varID < nvars; varID++ )
{
gridID = vlistInqVarGrid(vlistID1, varID);
nlevels = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
hsetCreateVarLevels(hset, varID, nlevels, gridID);
}
for ( tsID = 0; tsID < noffset; tsID++ )
{
nrecs = streamInqTimestep(streamID1, tsID);
if ( nrecs == 0 ) break;
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
if ( tsID == 0 )
{
recVarID[recID] = varID;
recLevelID[recID] = levelID;
}
}
}
if ( tsID < noffset )
{
cdoWarning("noffset is larger than number of timesteps!");
goto LABEL_END;
}
int otsID = 0;
while ( TRUE )
{
nrecs = streamInqTimestep(streamID2, otsID);
if ( nrecs != streamInqTimestep(streamID3, otsID) )
cdoAbort("Number of records at time step %d of %s and %s differ!", otsID+1, cdoStreamName(1)->args, cdoStreamName(2)->args);
vdate2 = taxisInqVdate(taxisID2);
vtime2 = taxisInqVtime(taxisID2);
vdate3 = taxisInqVdate(taxisID3);
vtime3 = taxisInqVtime(taxisID3);
if ( vdate2 != vdate3 || vtime2 != vtime3 )
cdoAbort("Verification dates at time step %d of %s and %s differ!", otsID+1, cdoStreamName(1)->args, cdoStreamName(2)->args);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID2, &varID, &levelID);
streamReadRecord(streamID2, vars1[varID][levelID].ptr, &nmiss);
vars1[varID][levelID].nmiss = nmiss;
}
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID3, &varID, &levelID);
streamReadRecord(streamID3, field.ptr, &nmiss);
field.nmiss = nmiss;
field.grid = vars1[varID][levelID].grid;
field.missval = vars1[varID][levelID].missval;
hsetDefVarLevelBounds(hset, varID, levelID, &vars1[varID][levelID], &field);
}
nsets = 0;
if ( nrecs )
for ( nsets = 0; nsets < ndates; nsets++ )
{
nrecs = streamInqTimestep(streamID1, tsID);
if ( nrecs == 0 ) break;
dtlist_taxisInqTimestep(dtlist, taxisID1, nsets);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
if ( tsID == 0 )
{
recVarID[recID] = varID;
recLevelID[recID] = levelID;
}
streamReadRecord(streamID1, vars1[varID][levelID].ptr, &nmiss);
vars1[varID][levelID].nmiss = nmiss;
hsetAddVarLevelValues(hset, varID, levelID, &vars1[varID][levelID]);
}
tsID++;
}
if ( nrecs == 0 && nsets == 0 ) break;
for ( varID = 0; varID < nvars; varID++ )
{
if ( vlistInqVarTsteptype(vlistID1, varID) == TSTEP_CONSTANT ) continue;
nlevels = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
for ( levelID = 0; levelID < nlevels; levelID++ )
hsetGetVarLevelPercentiles(&vars1[varID][levelID], hset, varID, levelID, pn);
}
dtlist_stat_taxisDefTimestep(dtlist, taxisID4, nsets);
streamDefTimestep(streamID4, otsID);
for ( recID = 0; recID < nrecords; recID++ )
{
varID = recVarID[recID];
levelID = recLevelID[recID];
if ( otsID && vlistInqVarTsteptype(vlistID1, varID) == TSTEP_CONSTANT ) continue;
streamDefRecord(streamID4, varID, levelID);
streamWriteRecord(streamID4, vars1[varID][levelID].ptr, vars1[varID][levelID].nmiss);
}
if ( nrecs == 0 ) break;
otsID++;
for ( i = 0; i < nskip; i++ )
{
nrecs = streamInqTimestep(streamID1, tsID);
if ( nrecs == 0 ) break;
tsID++;
}
if ( nrecs == 0 ) break;
}
LABEL_END:
field_free(vars1, vlistID1);
hsetDestroy(hset);
dtlist_delete(dtlist);
if ( field.ptr ) free(field.ptr);
if ( recVarID ) free(recVarID);
if ( recLevelID ) free(recLevelID);
streamClose(streamID4);
streamClose(streamID3);
streamClose(streamID2);
streamClose(streamID1);
cdoFinish();
return (0);
}
