void account_free(struct account *account)
{
if (!account)
return;
free(account->id);
free(account->name);
free(account->group);
free(account->fullname);
free(account->url);
free(account->username);
free(account->password);
free(account->note);
free(account->name_encrypted);
free(account->group_encrypted);
free(account->username_encrypted);
free(account->password_encrypted);
free(account->note_encrypted);
for (struct field *field = account->field_head, *next_field = NULL; field; field = next_field) {
next_field = field->next;
field_free(field);
}
share_free(account->share);
free(account);
}
bool probe_set_metafield_ext(probe_t * probe, size_t depth, field_t * field)
{
bool ret = true;
field_t * hacked_field;
// TODO: TEMP HACK IPv4 flow id is encoded in src_port
if (strcmp(field->key, "flow_id") != 0) {
fprintf(stderr, "probe_set_metafield_ext: cannot set %s\n", field->key);
return false;
}
// We add 24000 to use port to increase chances to traverse firewalls
if ((hacked_field = I16("src_port", 24000 + field->value.int16))) {
ret = probe_set_field(probe, hacked_field);
field_free(hacked_field);
}
return ret;
/*
metafield = metafield_search(field->key);
if (!metafield) return false; // Metafield not found
// Does the probe verifies one metafield pattern ?
// Does the value conflict with a previously set field ?
*/
}
static bool layer_set_field_and_free(layer_t * layer, field_t * field) {
bool ret = false;
if (field) {
ret = layer_set_field(layer, field);
field_free(field);
}
return ret;
}
static bool probe_set_tag(probe_t * probe, uint16_t tag_probe) {
bool ret = false;
field_t * field;
if ((field = I16("checksum", tag_probe))) {
ret = probe_set_field_ext(probe, 1, field);
field_free(field);
}
return ret;
}
bool probe_set_delay(probe_t * probe, field_t * delay)
{
field_t * field;
if (probe->delay) field_free(probe->delay);
if (!(field = field_dup(delay))) goto ERR_DUP;
probe->delay = field;
return true;
ERR_DUP:
return false;
}
bool probe_extract(const probe_t * probe, const char * name, void * dst) {
field_t * flow_id_field;
// TEMPORARY HACK TO MANAGE flow_id metafield
if (!strcmp(name, "flow_id")) {
if ((flow_id_field = probe_create_metafield(probe, "flow_id")) != NULL) {
memcpy(dst, &flow_id_field->value.int16, sizeof(uint16_t));
field_free(flow_id_field);
return true;
}
return false;
}
return probe_extract_ext(probe, name, 0, dst);
}
static struct field *field_parse(struct chunk *chunk, const unsigned char key[KDF_HASH_LEN])
{
struct field *parsed = new0(struct field, 1);
entry_plain(name);
entry_plain(type);
if (!strcmp(parsed->type, "email") || !strcmp(parsed->type, "tel") || !strcmp(parsed->type, "text") || !strcmp(parsed->type, "password") || !strcmp(parsed->type, "textarea"))
entry_crypt(value);
else
entry_plain(value);
entry_boolean(checked);
return parsed;
error:
field_free(parsed);
return NULL;
}
void jacobi(field solution,
int stencil, int Nx, int Ny, double eps, int max_iter,
int *iterations, double *diff)
{
int x, y, niter;
field v = field_alloc(Ny, Nx);
// kann nicht parallelisiert werden, weil
// - spätere Schleifeniterationen von Daten abhängen, die bei früheren
// Iterationen erst berechnet werden müssen
// - das if break eine parallelisierung nicht erlaubt
// - jacobi(...) ohnehin schon parallelisiert ist und eine weitere
// Verzweigung nicht möglich ist.
for (niter = 1; niter <= max_iter; niter++) {
// omp ist eigentlich ein overkill, wenn memcpy(...) es auch getan hätte.
#pragma omp parallel for private(x)
for (y = 0; y <= Ny + 1; y++) {
for (x = 0; x <= Nx + 1; x++) {
v[y][x] = solution[y][x];
}
}
switch (stencil) {
case 5:
jacobi5(solution, v, Nx, Ny, diff);
break;
case 9:
jacobi9(solution, v, Nx, Ny, diff);
break;
default:
die("unknown stencil");
break;
}
if (*diff < eps) break;
}
*iterations = niter;
field_free(v);
}
bool probe_set_fields(probe_t * probe, field_t * field1, ...) {
va_list args;
field_t * field;
bool ret = true;
va_start(args, field1);
for (field = field1; field; field = va_arg(args, field_t *)) {
// Update the first matching field
if (!probe_set_field(probe, field)) {
// No matching field found, update the first matching metafield
if (!(ret &= probe_set_metafield(probe, field))) {
fprintf(stderr, "probe_set_fields: Cannot set field '%s'\n", field->key);
}
}
field_free(field);
}
va_end(args);
probe_update_fields(probe);
return ret;
}
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);
}
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 check_exported_data(const char * exported_file,
const char * init_file,
field_file_format_type file_type,
const field_config_type * field_config,
const field_type * field,
int nx,
int ny,
int nz) {
FILE * original_stream = NULL;
ecl_kw_type * kw_original = NULL;
FILE * exported_stream = NULL;
ecl_kw_type * kw_exported = NULL;
field_type * exported_field = NULL;
field_config_type * exported_field_config = NULL;
{
if (init_file) {
original_stream = util_fopen( init_file , "r");
kw_original = ecl_kw_fscanf_alloc_grdecl_dynamic( original_stream , field_config_get_key(field_config) , ECL_DOUBLE_TYPE );
}
if (ECL_GRDECL_FILE == file_type) {
exported_stream = util_fopen( exported_file , "r");
kw_exported = ecl_kw_fscanf_alloc_grdecl_dynamic( exported_stream , field_config_get_key(field_config) , ECL_DOUBLE_TYPE );
} else if (RMS_ROFF_FILE == file_type) {
ecl_grid_type * grid = field_config_get_grid(field_config);
exported_field_config = field_config_alloc_empty(field_config_get_key(field_config), grid, NULL, true);
exported_field = field_alloc(exported_field_config);
bool keep_inactive = true;
field_fload_rms(exported_field, exported_file, keep_inactive);
}
}
{
int k, j, i = 0;
for (k=0; k < nz; k++) {
for (j=0; j < ny; j++) {
for (i=0; i < nx; i++) {
bool active = field_config_active_cell(field_config, i, j, k);
double field_value = active ? field_ijk_get_double(field, i, j, k) : 0.0;
int global_index = field_config_global_index(field_config , i , j , k);
double exported_value = 0.0;
if (ECL_GRDECL_FILE == file_type)
exported_value = ecl_kw_iget_as_double(kw_exported, global_index);
else if (RMS_ROFF_FILE == file_type) {
exported_value = field_ijk_get_double(exported_field, i, j, k);
}
double initial_value = init_file ? ecl_kw_iget_as_double(kw_original, global_index) : 0.0;
if (active)
test_assert_double_equal(field_value, exported_value);
else if (init_file)
test_assert_double_equal(initial_value, exported_value);
else if (file_type == RMS_ROFF_FILE)
test_assert_double_equal(RMS_INACTIVE_DOUBLE, exported_value);
else
test_assert_double_equal(0.0, exported_value);
}
}
}
}
if (init_file) {
util_fclose(original_stream);
ecl_kw_free(kw_original);
}
if (ECL_GRDECL_FILE == file_type) {
util_fclose(exported_stream);
ecl_kw_free(kw_exported);
} else
field_free(exported_field);
}
void *Fourier(void *argument)
{
int bit, sign;
int gridsize;
int nrecs;
int gridID, varID, levelID, recID;
int tsID;
int i;
int nts;
int nalloc = 0;
int streamID1, streamID2;
int vlistID1, vlistID2, taxisID1, taxisID2;
int nmiss;
int nvars, nlevel;
int *vdate = NULL, *vtime = NULL;
double missval;
field_t ***vars = NULL;
typedef struct
{
double *real;
double *imag;
double *work_r;
double *work_i;
} memory_t;
memory_t *ompmem = NULL;
cdoInitialize(argument);
operatorInputArg("the sign of the exponent (-1 for normal or 1 for reverse transformation)!");
sign = parameter2int(operatorArgv()[0]);
streamID1 = streamOpenRead(cdoStreamName(0));
vlistID1 = streamInqVlist(streamID1);
vlistID2 = vlistDuplicate(vlistID1);
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamDefVlist(streamID2, vlistID2);
nvars = vlistNvars(vlistID1);
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
if ( tsID >= nalloc )
{
nalloc += NALLOC_INC;
vdate = (int*) realloc(vdate, nalloc*sizeof(int));
vtime = (int*) realloc(vtime, nalloc*sizeof(int));
vars = (field_t ***) realloc(vars, nalloc*sizeof(field_t **));
}
vdate[tsID] = taxisInqVdate(taxisID1);
vtime[tsID] = taxisInqVtime(taxisID1);
vars[tsID] = field_malloc(vlistID1, FIELD_NONE);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
gridID = vlistInqVarGrid(vlistID1, varID);
gridsize = gridInqSize(gridID);
vars[tsID][varID][levelID].ptr = (double*) malloc(2*gridsize*sizeof(double));
streamReadRecord(streamID1, vars[tsID][varID][levelID].ptr, &nmiss);
vars[tsID][varID][levelID].nmiss = nmiss;
}
tsID++;
}
nts = tsID;
for ( bit = nts; !(bit & 1); bit >>= 1 );
ompmem = (memory_t*) malloc(ompNumThreads*sizeof(memory_t));
for ( i = 0; i < ompNumThreads; i++ )
{
ompmem[i].real = (double*) malloc(nts*sizeof(double));
ompmem[i].imag = (double*) malloc(nts*sizeof(double));
if ( bit != 1 )
{
ompmem[i].work_r = (double*) malloc(nts*sizeof(double));
ompmem[i].work_i = (double*) malloc(nts*sizeof(double));
}
}
for ( varID = 0; varID < nvars; varID++ )
{
gridID = vlistInqVarGrid(vlistID1, varID);
missval = vlistInqVarMissval(vlistID1, varID);
gridsize = gridInqSize(gridID);
nlevel = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
for ( levelID = 0; levelID < nlevel; levelID++ )
{
#if defined(_OPENMP)
#pragma omp parallel for default(shared) private(i, tsID)
#endif
for ( i = 0; i < gridsize; i++ )
{
int lmiss = 0;
int ompthID = cdo_omp_get_thread_num();
for ( tsID = 0; tsID < nts; tsID++ )
{
ompmem[ompthID].real[tsID] = vars[tsID][varID][levelID].ptr[2*i];
ompmem[ompthID].imag[tsID] = vars[tsID][varID][levelID].ptr[2*i+1];
if ( DBL_IS_EQUAL(ompmem[ompthID].real[tsID], missval) ||
DBL_IS_EQUAL(ompmem[ompthID].imag[tsID], missval) ) lmiss = 1;
}
if ( lmiss == 0 )
{
if ( bit == 1 ) /* nts is a power of 2 */
fft(ompmem[ompthID].real, ompmem[ompthID].imag, nts, sign);
else
ft_r(ompmem[ompthID].real, ompmem[ompthID].imag, nts, sign, ompmem[ompthID].work_r, ompmem[ompthID].work_i);
for ( tsID = 0; tsID < nts; tsID++ )
{
vars[tsID][varID][levelID].ptr[2*i] = ompmem[ompthID].real[tsID];
vars[tsID][varID][levelID].ptr[2*i+1] = ompmem[ompthID].imag[tsID];
}
}
else
{
for ( tsID = 0; tsID < nts; tsID++ )
{
vars[tsID][varID][levelID].ptr[2*i] = missval;
vars[tsID][varID][levelID].ptr[2*i+1] = missval;
}
}
}
}
}
for ( i = 0; i < ompNumThreads; i++ )
{
free(ompmem[i].real);
free(ompmem[i].imag);
if ( bit != 1 )
{
free(ompmem[i].work_r);
free(ompmem[i].work_i);
}
}
free(ompmem);
for ( tsID = 0; tsID < nts; tsID++ )
{
taxisDefVdate(taxisID2, vdate[tsID]);
taxisDefVtime(taxisID2, vtime[tsID]);
streamDefTimestep(streamID2, tsID);
for ( varID = 0; varID < nvars; varID++ )
{
nlevel = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
for ( levelID = 0; levelID < nlevel; levelID++ )
{
if ( vars[tsID][varID][levelID].ptr )
{
nmiss = vars[tsID][varID][levelID].nmiss;
streamDefRecord(streamID2, varID, levelID);
streamWriteRecord(streamID2, vars[tsID][varID][levelID].ptr, nmiss);
free(vars[tsID][varID][levelID].ptr);
vars[tsID][varID][levelID].ptr = NULL;
}
}
}
field_free(vars[tsID], vlistID1);
}
if ( vars ) free(vars);
if ( vdate ) free(vdate);
if ( vtime ) free(vtime);
streamClose(streamID2);
streamClose(streamID1);
cdoFinish();
return (NULL);
}