static inline int
inventorizeStream(struct streamMapping *streamMap, int numStreamIDs,
int *sizeStreamMap_, int streamID, int headerIdx)
{
int sizeStreamMap = *sizeStreamMap_;
if (numStreamIDs < sizeStreamMap) ; else
{
streamMap = xrealloc(streamMap,
(size_t)(sizeStreamMap *= 2)
* sizeof (streamMap[0]));
*sizeStreamMap_ = sizeStreamMap;
}
streamMap[numStreamIDs].streamID = streamID;
streamMap[numStreamIDs].firstHeaderIdx = headerIdx;
streamMap[numStreamIDs].lastHeaderIdx = headerIdx;
streamMap[numStreamIDs].numVars = -1;
int filetype = streamInqFiletype(streamID);
streamMap[numStreamIDs].filetype = filetype;
if (filetype == FILETYPE_NC || filetype == FILETYPE_NC2
|| filetype == FILETYPE_NC4)
{
int vlistID = streamInqVlist(streamID);
int nvars = vlistNvars(vlistID);
streamMap[numStreamIDs].numVars = nvars;
streamMap[numStreamIDs].varMap
= xmalloc(sizeof (streamMap[numStreamIDs].varMap[0]) * (size_t)nvars);
for (int i = 0; i < nvars; ++i)
streamMap[numStreamIDs].varMap[i] = -1;
}
return numStreamIDs + 1;
}
void command_init()
{
int gridsize;
int taxisID;
int varID;
gl_vlistID = streamInqVlist(gl_streamID);
taxisID = vlistInqTaxis(gl_vlistID);
UNUSED(taxisID);
gridsize = vlistGridsizeMax(gl_vlistID);
gl_data = (double*) malloc(gridsize*sizeof(double));
gl_nvars = vlistNvars(gl_vlistID);
all_vars = (vars_t*) malloc(gl_nvars*sizeof(vars_t));
for ( varID = 0; varID < gl_nvars; ++varID )
{
all_vars[varID].param = vlistInqVarParam(gl_vlistID, varID);
vlistInqVarName(gl_vlistID, varID, all_vars[varID].name);
vlistInqVarLongname(gl_vlistID, varID, all_vars[varID].longname);
vlistInqVarUnits(gl_vlistID, varID, all_vars[varID].units);
}
}
void *Template2(void *argument)
{
int streamID1, streamID2 = CDI_UNDEFID;
int nrecs;
int tsID, recID, varID, levelID;
int vlistID1, vlistID2;
int gridsize;
int nmiss;
int taxisID1, taxisID2;
double *array = NULL;
cdoInitialize(argument);
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);
gridsize = vlistGridsizeMax(vlistID1);
array = (double*) malloc(gridsize*sizeof(double));
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
streamDefRecord(streamID2, varID, levelID);
streamReadRecord(streamID1, array, &nmiss);
streamWriteRecord(streamID2, array, nmiss);
}
tsID++;
}
streamClose(streamID1);
streamClose(streamID2);
vlistDestroy(vlistID2);
if ( array ) free(array);
cdoFinish();
return (0);
}
/*
* Cdi
* {
*/
Cdi::Cdi(const char *path) {
streamID = streamOpenRead(path);
vlistID = streamInqVlist(streamID);
nvars = vlistNvars(vlistID);
getTaxes();
getZaxes();
getGrids();
getVars();
}
static void
writeGribStream(struct winHeaderEntry *winDict, struct streamMapping *mapping,
double **data_, int *currentDataBufSize, int root,
int nProcsModel)
{
int streamID = mapping->streamID;
int headerIdx, lastHeaderIdx = mapping->lastHeaderIdx;
int vlistID = streamInqVlist(streamID);
if (lastHeaderIdx < 0)
{
/* write zero bytes to trigger synchronization code in fileWrite */
cdiPioFileWrite(streamInqFileID(streamID), NULL, 0,
streamInqCurTimestepID(streamID));
}
else
for (headerIdx = mapping->firstHeaderIdx;
headerIdx <= lastHeaderIdx;
headerIdx += 2)
if (streamID == winDict[headerIdx].id)
{
int varID = winDict[headerIdx].specific.dataRecord.varID;
int size = vlistInqVarSize(vlistID, varID);
int nmiss;
resizeVarGatherBuf(vlistID, varID, data_, currentDataBufSize);
double *data = *data_;
gatherArray(root, nProcsModel, headerIdx,
vlistID, data, &nmiss);
streamWriteVar(streamID, varID, data, nmiss);
if ( ddebug > 2 )
{
char text[1024];
sprintf(text, "streamID=%d, var[%d], size=%d",
streamID, varID, size);
xprintArray(text, data, size, DATATYPE_FLT);
}
}
}
void *Setgatt(void *argument)
{
int SETGATT, SETGATTS;
int operatorID;
int streamID1, streamID2 = CDI_UNDEFID;
int nrecs;
int tsID, recID, varID, levelID;
int vlistID1, vlistID2;
int gridsize;
int nmiss;
char *attname = NULL, *attstring = NULL, *attfile = NULL;
double *array = NULL;
int taxisID1, taxisID2;
cdoInitialize(argument);
SETGATT = cdoOperatorAdd("setgatt", 0, 0, "attribute name and string");
SETGATTS = cdoOperatorAdd("setgatts", 0, 0, NULL);
operatorID = cdoOperatorID();
if ( operatorID == SETGATT )
{
operatorInputArg(cdoOperatorEnter(operatorID));
attname = operatorArgv()[0];
attstring = operatorArgv()[1];
}
else
{
attfile = 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());
if ( operatorID == SETGATT )
{
vlistDefAttTxt(vlistID2, CDI_GLOBAL, attname, (int)strlen(attstring), attstring);
}
else
{
char line[1024];
FILE *fp;
int attlen = 0;
fp = fopen(attfile, "r");
if ( fp == 0 ) cdoAbort("Open failed on %s", attfile);
while ( readline(fp, line, 1024) )
{
attlen = 0;
if ( line[0] == '#' ) continue;
if ( line[0] == '\0' ) continue;
attname = line;
while ( isspace((int) *attname) ) attname++;
if ( attname[0] == '\0' ) continue;
attstring = attname;
while ( *attstring != ' ' && *attstring != '\0' &&
*attstring != '=' && *attstring != '"' ) attstring++;
if ( *attstring == '\0' )
attstring = NULL;
else
{
*attstring = '\0';
attstring++;
while ( isspace((int) *attstring) || (int) *attstring == '=' ||
(int) *attstring == '"' || (int) *attstring == '\'' ) attstring++;
attlen = strlen(attstring);
if ( attstring[attlen-1] == '"' || attstring[attlen-1] == '\'' )
attstring[--attlen] = 0;
}
if ( attstring && attlen)
vlistDefAttTxt(vlistID2, CDI_GLOBAL, attname, attlen, attstring);
}
fclose(fp);
}
streamDefVlist(streamID2, vlistID2);
gridsize = vlistGridsizeMax(vlistID1);
if ( vlistNumber(vlistID1) != CDI_REAL ) gridsize *= 2;
array = (double*) malloc(gridsize*sizeof(double));
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
streamDefRecord(streamID2, varID, levelID);
streamReadRecord(streamID1, array, &nmiss);
streamWriteRecord(streamID2, array, nmiss);
}
tsID++;
}
streamClose(streamID1);
streamClose(streamID2);
if ( array ) free(array);
cdoFinish();
return (0);
}
void *Filedes(void *argument)
{
int GRIDDES, GRIDDES2, ZAXISDES, VCT, VCT2, PARDES, FILEDES, VLIST, SPARTAB, PARTAB, PARTAB2;
int operatorID;
int streamID = 0;
int zaxisID;
int nvars, ngrids, nzaxis;
int type, index;
int vlistID;
cdoInitialize(argument);
GRIDDES = cdoOperatorAdd("griddes", 0, 0, NULL);
GRIDDES2 = cdoOperatorAdd("griddes2", 0, 0, NULL);
ZAXISDES = cdoOperatorAdd("zaxisdes", 0, 0, NULL);
VCT = cdoOperatorAdd("vct", 0, 0, NULL);
VCT2 = cdoOperatorAdd("vct2", 0, 0, NULL);
PARDES = cdoOperatorAdd("pardes", 0, 0, NULL);
FILEDES = cdoOperatorAdd("filedes", 0, 0, NULL);
VLIST = cdoOperatorAdd("vlist", 0, 0, NULL);
SPARTAB = cdoOperatorAdd("spartab", 0, 0, NULL);
PARTAB = cdoOperatorAdd("partab", 0, 0, NULL);
PARTAB2 = cdoOperatorAdd("partab2", 0, 0, NULL);
operatorID = cdoOperatorID();
streamID = streamOpenRead(cdoStreamName(0));
vlistID = streamInqVlist(streamID);
nvars = vlistNvars(vlistID);
ngrids = vlistNgrids(vlistID);
nzaxis = vlistNzaxis(vlistID);
if ( operatorID == GRIDDES || operatorID == GRIDDES2 )
{
int opt = 0;
if ( operatorID == GRIDDES ) opt = 1;
for ( index = 0; index < ngrids; index++ )
gridPrint(vlistGrid(vlistID, index), index+1, opt);
}
else if ( operatorID == ZAXISDES )
{
for ( index = 0; index < nzaxis; index++ )
zaxisPrint(vlistZaxis(vlistID, index), index+1);
}
else if ( operatorID == VCT || operatorID == VCT2 )
{
for ( index = 0; index < nzaxis; index++)
{
zaxisID = vlistZaxis(vlistID, index);
type = zaxisInqType(zaxisID);
if ( type == ZAXIS_HYBRID || type == ZAXIS_HYBRID_HALF )
{
int i, vctsize;
const double *vct;
vctsize = zaxisInqVctSize(zaxisID);
vct = zaxisInqVctPtr(zaxisID);
if ( vctsize%2 == 0 )
{
if ( operatorID == VCT )
{
fprintf(stdout, "# k vct_a(k) [Pa] vct_b(k) []\n");
for ( i = 0; i < vctsize/2; i++ )
fprintf(stdout, "%5d %25.17f %25.17f\n", i, vct[i], vct[vctsize/2+i]);
}
else
{
int nbyte0, nbyte;
fprintf(stdout, "vctsize = %d\n", vctsize);
nbyte0 = fprintf(stdout, "vct = ");
nbyte = nbyte0;
for ( i = 0; i < vctsize; i++ )
{
if ( nbyte > 70 || i == vctsize/2 )
{
fprintf(stdout, "\n%*s", nbyte0, "");
nbyte = nbyte0;
}
nbyte += fprintf(stdout, "%.9g ", vct[i]);
}
fprintf(stdout, "\n");
}
}
else
for ( i = 0; i < vctsize; i++ )
fprintf(stdout, "%5d %25.17f\n", i, vct[i]);
break;
}
}
}
else if ( operatorID == VLIST )
{
vlistPrint(vlistID);
}
else if ( operatorID == PARDES )
{
int varID, code;
char varname[CDI_MAX_NAME], varlongname[CDI_MAX_NAME], varunits[CDI_MAX_NAME];
for ( varID = 0; varID < nvars; varID++ )
{
varname[0] = 0;
varlongname[0] = 0;
varunits[0] = 0;
code = vlistInqVarCode(vlistID, varID);
vlistInqVarName(vlistID, varID, varname);
vlistInqVarLongname(vlistID, varID, varlongname);
vlistInqVarUnits(vlistID, varID, varunits);
fprintf(stdout, "%4d %-12s", code, varname);
if ( strlen(varlongname) )
{
fprintf(stdout, " %s", varlongname);
if ( strlen(varunits) )
fprintf(stdout, " [%s]", varunits);
}
fprintf(stdout, "\n");
}
}
else if ( operatorID == PARTAB || operatorID == SPARTAB || operatorID == PARTAB2 )
{
int option = 1;
if ( operatorID == SPARTAB ) option = 4;
if ( operatorID == PARTAB2 ) option = 2;
partab(stdout, vlistID, option);
}
else if ( operatorID == FILEDES )
{
filedes(streamID);
}
streamClose(streamID);
cdoFinish();
return (0);
}
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 *Merge(void *argument)
{
int streamID1 = -1, streamID2 = -1;
int varID, varID2;
int nrecs = 0;
int recID, levelID, levelID2;
int index;
int vlistID1 = -1, vlistID2;
int lcopy = FALSE;
int gridsize;
int nmiss;
int taxisID1, taxisID2;
//int skip_same_var = FALSE;
double *array = NULL;
cdoInitialize(argument);
if ( UNCHANGED_RECORD ) lcopy = TRUE;
/*
{
char *envstr;
envstr = getenv("SKIP_SAME_VAR");
if ( envstr )
{
int ival;
ival = atoi(envstr);
if ( ival == 1 )
{
skip_same_var = TRUE;
if ( cdoVerbose )
cdoPrint("Set SKIP_SAME_VAR to %d", ival);
}
}
}
*/
int streamCnt = cdoStreamCnt();
int nmerge = streamCnt - 1;
const char *ofilename = cdoStreamName(streamCnt-1)->args;
if ( !cdoSilentMode && !cdoOverwriteMode )
if ( fileExists(ofilename) )
if ( !userFileOverwrite(ofilename) )
cdoAbort("Outputfile %s already exists!", ofilename);
int *streamIDs = (int*) malloc(nmerge*sizeof(int));
int *vlistIDs = (int*) malloc(nmerge*sizeof(int));
int *numrecs = (int*) malloc(nmerge*sizeof(int));
int *numsteps = (int*) malloc(nmerge*sizeof(int));
for ( index = 0; index < nmerge; index++ )
{
streamID1 = streamOpenRead(cdoStreamName(index));
streamIDs[index] = streamID1;
vlistIDs[index] = streamInqVlist(streamID1);
}
vlistID1 = vlistIDs[0];
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistID2 = vlistCreate();
vlistCopy(vlistID2, vlistIDs[0]);
for ( index = 1; index < nmerge; index++ )
{
checkDupEntry(vlistID2, vlistIDs[index], cdoStreamName(index)->args);
/* vlistCat(vlistID2, vlistIDs[index]); */
vlistMerge(vlistID2, vlistIDs[index]);
}
for ( index = 0; index < nmerge; index++ ) numsteps[index] = -1;
int numconst = 0;
for ( index = 0; index < nmerge; index++ )
{
streamID1 = streamIDs[index];
vlistID1 = vlistIDs[index];
numsteps[index] = vlistNtsteps(vlistID1);
if ( numsteps[index] == 0 ) numsteps[index] = 1;
if ( numsteps[index] == 1 ) numconst++;
}
if ( numconst > 0 && numconst < nmerge )
for ( index = 0; index < nmerge; index++ )
{
if ( numsteps[index] == 1 )
{
vlistID1 = vlistIDs[index];
int nvars = vlistNvars(vlistID1);
for ( int varID = 0; varID < nvars; ++varID )
{
varID2 = vlistMergedVar(vlistID1, varID);
vlistDefVarTsteptype(vlistID2, varID2, TSTEP_CONSTANT);
}
}
}
if ( cdoVerbose )
{
for ( index = 0; index < nmerge; index++ ) vlistPrint(vlistIDs[index]);
vlistPrint(vlistID2);
}
streamID2 = streamOpenWrite(cdoStreamName(streamCnt-1), cdoFiletype());
vlistDefTaxis(vlistID2, taxisID2);
streamDefVlist(streamID2, vlistID2);
if ( ! lcopy )
{
gridsize = vlistGridsizeMax(vlistID2);
array = (double*) malloc(gridsize*sizeof(double));
}
int firstindex = 0;
int tsID = 0;
while ( tsID >= 0 )
{
for ( index = 0; index < nmerge; index++ )
{
streamID1 = streamIDs[index];
vlistID1 = vlistIDs[index];
if ( vlistID1 == -1 ) continue;
numrecs[index] = streamInqTimestep(streamID1, tsID);
}
for ( index = 0; index < nmerge; index++ ) if ( numrecs[index] != 0 ) break;
if ( index == nmerge ) break; // EOF on all input streams
if ( tsID == 1 )
{
for ( index = 0; index < nmerge; index++ )
if ( numrecs[index] == 0 && numsteps[index] == 1 ) vlistIDs[index] = -1;
/*
for ( index = 0; index < nmerge; index++ )
if ( vlistIDs[index] != -1 )
{
firstindex = index;
break;
}
*/
}
/*
for ( index = 0; index < nmerge; index++ )
printf("tsID %d %d sID %d vID %d nrecs %d\n", tsID, index, streamIDs[index], vlistIDs[index], numrecs[index]);
*/
if ( numrecs[firstindex] == 0 )
{
for ( index = 1; index < nmerge; index++ )
if ( vlistIDs[index] != -1 && numrecs[index] != 0 )
cdoWarning("Input stream %d has %d timestep%s. Stream %d has more timesteps, skipped!", firstindex+1, tsID, tsID==1?"":"s", index+1);
break;
}
else
{
for ( index = 1; index < nmerge; index++ )
if ( vlistIDs[index] != -1 && numrecs[index] == 0 )
{
cdoWarning("Input stream %d has %d timestep%s. Stream %d has more timesteps, skipped!", index+1, tsID, tsID==1?"":"s", firstindex+1);
break;
}
if ( index < nmerge ) break;
}
for ( index = 0; index < nmerge; index++ )
{
streamID1 = streamIDs[index];
vlistID1 = vlistIDs[index];
nrecs = numrecs[index];
if ( vlistID1 == -1 ) continue;
if ( index == firstindex )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
}
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
varID2 = vlistMergedVar(vlistID1, varID);
levelID2 = vlistMergedLevel(vlistID1, varID, levelID);
if ( cdoVerbose ) cdoPrint("var %d %d %d %d", varID, levelID, varID2, levelID2);
streamDefRecord(streamID2, varID2, levelID2);
if ( lcopy )
{
streamCopyRecord(streamID2, streamID1);
}
else
{
streamReadRecord(streamID1, array, &nmiss);
streamWriteRecord(streamID2, array, nmiss);
}
}
}
tsID++;
}
for ( index = 0; index < nmerge; index++ )
streamClose(streamIDs[index]);
streamClose(streamID2);
vlistDestroy(vlistID2);
if ( streamIDs ) free(streamIDs);
if ( vlistIDs ) free(vlistIDs);
if ( numrecs ) free(numrecs);
if ( numsteps ) free(numsteps);
if ( ! lcopy )
if ( array ) free(array);
cdoFinish();
return (0);
}
void *Invert(void *argument)
{
int INVERTLAT, INVERTLON, INVERTLATDES, INVERTLONDES, INVERTLATDATA, INVERTLONDATA;
int operatorID;
int operfunc1, operfunc2;
int streamID1, streamID2;
int nrecs;
int tsID, recID, varID, levelID;
int gridsize;
int vlistID1, vlistID2;
int gridID1;
int nmiss;
double *array1, *array2;
int taxisID1, taxisID2;
cdoInitialize(argument);
INVERTLAT = cdoOperatorAdd("invertlat", func_all, 0, NULL);
INVERTLON = cdoOperatorAdd("invertlon", func_all, 0, NULL);
INVERTLATDES = cdoOperatorAdd("invertlatdes", func_hrd, 0, NULL);
INVERTLONDES = cdoOperatorAdd("invertlondes", func_hrd, 0, NULL);
INVERTLATDATA = cdoOperatorAdd("invertlatdata", func_fld, 0, NULL);
INVERTLONDATA = cdoOperatorAdd("invertlondata", func_fld, 0, NULL);
operatorID = cdoOperatorID();
operfunc1 = cdoOperatorF1(operatorID);
if ( operatorID == INVERTLAT || operatorID == INVERTLATDES || operatorID == INVERTLATDATA )
operfunc2 = func_lat;
else
operfunc2 = func_lon;
streamID1 = streamOpenRead(cdoStreamName(0));
vlistID1 = streamInqVlist(streamID1);
vlistID2 = vlistDuplicate(vlistID1);
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
if ( operfunc1 == func_all || operfunc1 == func_hrd )
{
if ( operfunc2 == func_lat )
invertLatDes(vlistID2);
else
invertLonDes(vlistID2);
}
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamDefVlist(streamID2, vlistID2);
gridsize = vlistGridsizeMax(vlistID1);
array1 = (double*) malloc(gridsize*sizeof(double));
array2 = (double*) malloc(gridsize*sizeof(double));
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
streamReadRecord(streamID1, array1, &nmiss);
streamDefRecord(streamID2, varID, levelID);
if ( operfunc1 == func_all || operfunc1 == func_fld )
{
gridID1 = vlistInqVarGrid(vlistID1, varID);
if ( operfunc2 == func_lat )
invertLatData(array1, array2, gridID1);
else
invertLonData(array1, array2, gridID1);
streamWriteRecord(streamID2, array2, nmiss);
}
else
{
streamWriteRecord(streamID2, array1, nmiss);
}
}
tsID++;
}
streamClose(streamID2);
streamClose(streamID1);
if ( array1 ) free(array1);
if ( array2 ) free(array2);
cdoFinish();
return (0);
}
void *SSOpar(void *argument)
{
int GEOPOTHEIGHT;
int operatorID;
int streamID1, streamID2;
int vlistID1, vlistID2;
int recID, nrecs;
int i, offset, iv;
int tsID, varID, levelID;
int nvars;
int zaxisID2, zaxisIDh = -1, nzaxis, surfaceID;
int zaxisID;
int nlevel;
int nvct;
int geopID = -1, tempID = -1, humID = -1, psID = -1, lnpsID = -1, presID = -1, clwcID = -1, ciwcID = -1;
int code;
char varname[CDI_MAX_NAME];
double *single2;
int taxisID1, taxisID2;
int lhavevct;
int nhlevf = 0;
double *lev2;
double *vct = NULL;
double *geop = NULL, *ps = NULL, *temp = NULL, *hum = NULL, *lwater = NULL, *iwater = NULL;
double *geopotheight = NULL;
int nmiss, nmissout = 0;
int ltq = FALSE;
double *array = NULL;
double *half_press = NULL;
double minval, maxval;
double missval = 0;
double cconst = 1.E-6;
const char *fname;
cdoInitialize(argument);
GEOPOTHEIGHT = cdoOperatorAdd("geopotheight", 0, 0, NULL);
operatorID = cdoOperatorID();
streamID1 = streamOpenRead(cdoStreamName(0));
vlistID1 = streamInqVlist(streamID1);
int gridID = vlistGrid(vlistID1, 0);
if ( gridInqType(gridID) == GRID_SPECTRAL )
cdoAbort("Spectral data unsupported!");
int gridsize = vlist_check_gridsize(vlistID1);
nzaxis = vlistNzaxis(vlistID1);
lhavevct = FALSE;
if ( cdoVerbose )
cdoPrint("nzaxis: %d", nzaxis);
for ( i = 0; i < nzaxis; i++ )
{
zaxisID = vlistZaxis(vlistID1, i);
nlevel = zaxisInqSize(zaxisID);
if ( zaxisInqType(zaxisID) == ZAXIS_HYBRID )
{
if ( nlevel > 1 )
{
nvct = zaxisInqVctSize(zaxisID);
if ( cdoVerbose )
cdoPrint("i: %d, vct size of zaxisID %d = %d", i, zaxisID, nvct);
if ( nlevel == (nvct/2 - 1) )
{
if ( lhavevct == FALSE )
{
lhavevct = TRUE;
zaxisIDh = zaxisID;
nhlevf = nlevel;
if ( cdoVerbose )
cdoPrint("lhavevct=TRUE zaxisIDh = %d, nhlevf = %d", zaxisIDh, nlevel);
vct = (double*) malloc(nvct*sizeof(double));
zaxisInqVct(zaxisID, vct);
if ( cdoVerbose )
for ( i = 0; i < nvct/2; ++i )
cdoPrint("vct: %5d %25.17f %25.17f", i, vct[i], vct[nvct/2+i]);
}
}
else
{
if ( cdoVerbose )
cdoPrint("nlevel /= (nvct/2 - 1): nlevel = %d", nlevel);
}
}
}
}
if ( zaxisIDh == -1 )
cdoAbort("No 3D variable with hybrid sigma pressure coordinate found!");
nvars = vlistNvars(vlistID1);
for ( varID = 0; varID < nvars; varID++ )
{
gridID = vlistInqVarGrid(vlistID1, varID);
zaxisID = vlistInqVarZaxis(vlistID1, varID);
nlevel = zaxisInqSize(zaxisID);
code = vlistInqVarCode(vlistID1, varID);
/* code = -1; */
if ( code <= 0 )
{
vlistInqVarName(vlistID1, varID, varname);
strtolower(varname);
if ( nlevel == 1 )
{
if ( strcmp(varname, "geosp") == 0 ) code = 129;
else if ( strcmp(varname, "aps") == 0 ) code = 134;
else if ( strcmp(varname, "ps") == 0 ) code = 134;
else if ( strcmp(varname, "lsp") == 0 ) code = 152;
}
if ( nlevel == nhlevf )
{
if ( strcmp(varname, "t") == 0 ) code = 130;
else if ( strcmp(varname, "q") == 0 ) code = 133;
else if ( strcmp(varname, "clwc") == 0 ) code = 246;
else if ( strcmp(varname, "ciwc") == 0 ) code = 247;
}
}
if ( code == 129 ) geopID = varID;
else if ( code == 130 ) tempID = varID;
else if ( code == 133 ) humID = varID;
else if ( code == 134 ) psID = varID;
else if ( code == 152 ) lnpsID = varID;
else if ( code == 246 ) clwcID = varID;
else if ( code == 247 ) ciwcID = varID;
if ( gridInqType(gridID) == GRID_SPECTRAL && zaxisInqType(zaxisID) == ZAXIS_HYBRID )
cdoAbort("Spectral data on model level unsupported!");
if ( gridInqType(gridID) == GRID_SPECTRAL )
cdoAbort("Spectral data unsupported!");
if ( zaxisInqType(zaxisID) == ZAXIS_HYBRID && zaxisIDh != -1 && nlevel == nhlevf )
{
}
else
{
if ( code == 130 ) tempID = -1;
if ( code == 133 ) humID = -1;
if ( code == 246 ) clwcID = -1;
if ( code == 247 ) ciwcID = -1;
}
}
if ( tempID == -1 ) cdoAbort("Temperature not found!");
array = (double*) malloc(gridsize*sizeof(double));
geop = (double*) malloc(gridsize*sizeof(double));
ps = (double*) malloc(gridsize*sizeof(double));
temp = (double*) malloc(gridsize*nhlevf*sizeof(double));
hum = (double*) malloc(gridsize*nhlevf*sizeof(double));
lwater = (double*) malloc(gridsize*nhlevf*sizeof(double));
iwater = (double*) malloc(gridsize*nhlevf*sizeof(double));
half_press = (double*) malloc(gridsize*(nhlevf+1)*sizeof(double));
geopotheight = (double*) malloc(gridsize*(nhlevf+1)*sizeof(double));
if ( zaxisIDh != -1 && geopID == -1 )
{
if ( ltq )
cdoWarning("Orography (surf. geopotential) not found - set to zero!");
memset(geop, 0, gridsize*sizeof(double));
}
presID = lnpsID;
if ( zaxisIDh != -1 && lnpsID == -1 )
{
presID = psID;
if ( psID != -1 )
cdoWarning("LOG surface pressure (lsp) not found - using surface pressure (asp)!");
else
cdoAbort("Surface pressure not found!");
}
vlistID2 = vlistCreate();
varID = vlistDefVar(vlistID2, gridID, zaxisIDh, TSTEP_INSTANT);
vlistDefVarParam(vlistID2, varID, cdiEncodeParam(156, 128, 255));
vlistDefVarName(vlistID2, varID, "geopotheight");
vlistDefVarStdname(vlistID2, varID, "geopotential_height");
vlistDefVarUnits(vlistID2, varID, "m");
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamDefVlist(streamID2, vlistID2);
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
zaxisID = vlistInqVarZaxis(vlistID1, varID);
nlevel = zaxisInqSize(zaxisID);
offset = gridsize*levelID;
streamReadRecord(streamID1, array, &nmiss);
if ( zaxisIDh != -1 )
{
if ( varID == geopID )
{
memcpy(geop, array, gridsize*sizeof(double));
}
else if ( varID == presID )
{
if ( lnpsID != -1 )
for ( i = 0; i < gridsize; ++i ) ps[i] = exp(array[i]);
else if ( psID != -1 )
memcpy(ps, array, gridsize*sizeof(double));
}
else if ( varID == tempID )
memcpy(temp+offset, array, gridsize*sizeof(double));
else if ( varID == humID )
memcpy(hum+offset, array, gridsize*sizeof(double));
else if ( varID == clwcID )
memcpy(lwater+offset, array, gridsize*sizeof(double));
else if ( varID == ciwcID )
memcpy(iwater+offset, array, gridsize*sizeof(double));
}
}
if ( zaxisIDh != -1 )
{
/* check range of ps_prog */
minmaxval(gridsize, ps, NULL, &minval, &maxval);
if ( minval < MIN_PS || maxval > MAX_PS )
cdoWarning("Surface pressure out of range (min=%g max=%g)!", minval, maxval);
/* check range of geop */
minmaxval(gridsize, geop, NULL, &minval, &maxval);
if ( minval < MIN_FIS || maxval > MAX_FIS )
cdoWarning("Orography out of range (min=%g max=%g)!", minval, maxval);
}
varID = tempID;
nlevel = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
for ( levelID = 0; levelID < nlevel; levelID++ )
{
offset = gridsize*levelID;
single2 = temp + offset;
minmaxval(gridsize, single2, NULL, &minval, &maxval);
if ( minval < MIN_T || maxval > MAX_T )
cdoWarning("Input temperature at level %d out of range (min=%g max=%g)!",
levelID+1, minval, maxval);
}
nmissout = 0;
varID = 0;
nlevel = nhlevf;
for ( levelID = 0; levelID < nlevel; levelID++ )
{
streamDefRecord(streamID2, varID, levelID);
streamWriteRecord(streamID2, geopotheight+levelID*gridsize, nmissout);
}
tsID++;
}
streamClose(streamID2);
streamClose(streamID1);
vlistDestroy(vlistID2);
free(ps);
free(geop);
free(temp);
free(geopotheight);
if ( hum ) free(hum);
if ( half_press ) free(half_press);
free(array);
if ( vct ) free(vct);
cdoFinish();
return (0);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs,
const mxArray *prhs[])
{
mxArray *pDataArray;
int i, nVariables = -1;
int nFields;
int T;
mwSize dims[4];
int streamID, vlistID, nVars;
bool useGRIB;
char buf[MEXCDI_STR_LEN];
/* ==================================================================*/
/* Call CDI_VARLIST */
/* ==================================================================*/
cdi_varlist(1, plhs, nrhs, prhs);
streamID = OpenCDIStream(prhs[0]);
useGRIB = streamInqFiletype(streamID) == FILETYPE_GRB;
/* Get the variable list of the dataset */
vlistID = streamInqVlist(streamID);
/* get number of variables */
nVariables = mxGetNumberOfElements(plhs[0]);
/* ==================================================================*/
/* ALLOCATING ALL MEMORY FOR FIELD
/* ==================================================================*/
getTimeSize(NULL, streamID, &T ); /* Notice: T is the same for all variables */
for (i=0; i<nVariables; i++)
{
DEBUG_DISPLAY("allocating %d/%d\n", i+1, nVariables);
/* get size of data to read */
dims[0] = (mwSize)mxGetNumberOfElements(mxGetField(plhs[0], i, FIELD_LON));
dims[1] = (mwSize)mxGetNumberOfElements(mxGetField(plhs[0], i, FIELD_LAT));
dims[2] = (mwSize)mxGetNumberOfElements(mxGetField(plhs[0], i, FIELD_LEVELS));
dims[3] = (mwSize)mxGetNumberOfElements(mxGetField(plhs[0], i, FIELD_DATES));
/* allocate memory for MATLAB matrix*/
allocateField(useGRIB, vlistID, (int)mxGetScalar(mxGetField(plhs[0], i, FIELD_VARID)), streamID, T, dims, &pDataArray);
DEBUG_DISPLAY("setting %d/%d\n", i+1, nVariables);
mxSetField(plhs[0], (mwIndex)i, FIELD_DATA, pDataArray);
}
/* ==================================================================*/
/* CALL CDI_READFIELD FOR EACH VARIABLE */
/* ==================================================================*/
for (i=0; i<nVariables; i++)
{
/* Prepare data for CDI_READFIELD */
mxArray *plhsTmp[1];
const mxArray *prhsTmp[3];
/* Filename, nametable */
prhsTmp[0] = prhs[0];
if (nrhs == 2)
prhsTmp[1] = prhs[1]; /* if nametable */
else
prhsTmp[1] = NULL;
/* Varname: plhs[0] holds thee output from cdi_readmeta */
prhsTmp[2] = mxGetField(plhs[0], i, FIELD_VARCODE);
/* pass previously allocated data as left-hand-side argument to cdi_readfield*/
plhsTmp[0] = mxGetField(plhs[0], i, FIELD_DATA);
/* Call CDI_READFIELD */
read1var(1, plhsTmp, 3, prhsTmp);
}
/* remove the fields used only internally */
mxRemoveField(plhs[0], mxGetFieldNumber(plhs[0], FIELD_VARCODE));
mxRemoveField(plhs[0], mxGetFieldNumber(plhs[0], FIELD_VARID));
streamClose(streamID);
}
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 *Mergetime(void *argument)
{
int streamID1, streamID2 = CDI_UNDEFID;
int tsID2 = 0, recID, varID, levelID;
int vlistID1, vlistID2;
int nfiles, fileID;
int taxisID1, taxisID2 = CDI_UNDEFID;
int lcopy = FALSE;
int gridsize;
int nmiss;
int vdate, vtime;
int last_vdate = -1, last_vtime = -1;
int next_fileID;
int skip_same_time = FALSE;
int process_timestep;
const char *ofilename;
double *array = NULL;
typedef struct
{
int streamID;
int vlistID;
int taxisID;
int tsID;
int vdate;
int vtime;
int nrecs;
} sfile_t;
sfile_t *sf = NULL;
cdoInitialize(argument);
{
char *envstr;
envstr = getenv("SKIP_SAME_TIME");
if ( envstr )
{
int ival;
ival = atoi(envstr);
if ( ival == 1 )
{
skip_same_time = TRUE;
if ( cdoVerbose )
cdoPrint("Set SKIP_SAME_TIME to %d", ival);
}
}
}
if ( UNCHANGED_RECORD ) lcopy = TRUE;
nfiles = cdoStreamCnt() - 1;
sf = (sfile_t*) malloc(nfiles*sizeof(sfile_t));
for ( fileID = 0; fileID < nfiles; fileID++ )
{
if ( cdoVerbose ) cdoPrint("process: %s", cdoStreamName(fileID)->args);
streamID1 = streamOpenRead(cdoStreamName(fileID));
vlistID1 = streamInqVlist(streamID1);
taxisID1 = vlistInqTaxis(vlistID1);
sf[fileID].streamID = streamID1;
sf[fileID].vlistID = vlistID1;
sf[fileID].taxisID = taxisID1;
}
/* check that the contents is always the same */
for ( fileID = 1; fileID < nfiles; fileID++ )
vlistCompare(sf[0].vlistID, sf[fileID].vlistID, CMP_ALL);
/* read the first time step */
for ( fileID = 0; fileID < nfiles; fileID++ )
{
sf[fileID].tsID = 0;
sf[fileID].nrecs = streamInqTimestep(sf[fileID].streamID, sf[fileID].tsID);
if ( sf[fileID].nrecs == 0 )
{
streamClose(sf[fileID].streamID);
sf[fileID].streamID = -1;
}
else
{
sf[fileID].vdate = taxisInqVdate(sf[fileID].taxisID);
sf[fileID].vtime = taxisInqVtime(sf[fileID].taxisID);
}
}
ofilename = cdoStreamName(nfiles)->args;
if ( !cdoSilentMode && !cdoOverwriteMode )
if ( fileExists(ofilename) )
if ( !userFileOverwrite(ofilename) )
cdoAbort("Outputfile %s already exists!", ofilename);
streamID2 = streamOpenWrite(cdoStreamName(nfiles), cdoFiletype());
if ( ! lcopy )
{
gridsize = vlistGridsizeMax(sf[0].vlistID);
array = (double*) malloc(gridsize*sizeof(double));
}
while ( TRUE )
{
process_timestep = TRUE;
next_fileID = -1;
vdate = 0;
vtime = 0;
for ( fileID = 0; fileID < nfiles; fileID++ )
{
if ( sf[fileID].streamID != -1 )
if ( next_fileID == -1 || sf[fileID].vdate < vdate ||
(sf[fileID].vdate == vdate && sf[fileID].vtime < vtime) )
{
next_fileID = fileID;
vdate = sf[fileID].vdate;
vtime = sf[fileID].vtime;
}
}
fileID = next_fileID;
if ( cdoVerbose )
cdoPrint("nextstep = %d vdate = %d vtime = %d", next_fileID, vdate, vtime);
if ( next_fileID == -1 ) break;
if ( skip_same_time )
if ( vdate == last_vdate && vtime == last_vtime )
{
char vdatestr[32], vtimestr[32];
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
cdoPrint("Timestep %4d in stream %d (%s %s) already exists, skipped!",
sf[fileID].tsID+1, sf[fileID].streamID, vdatestr, vtimestr);
process_timestep = FALSE;
}
if ( process_timestep )
{
if ( tsID2 == 0 )
{
vlistID1 = sf[0].vlistID;
vlistID2 = vlistDuplicate(vlistID1);
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
streamDefVlist(streamID2, vlistID2);
}
last_vdate = vdate;
last_vtime = vtime;
taxisCopyTimestep(taxisID2, sf[fileID].taxisID);
streamDefTimestep(streamID2, tsID2);
for ( recID = 0; recID < sf[fileID].nrecs; recID++ )
{
streamInqRecord(sf[fileID].streamID, &varID, &levelID);
streamDefRecord(streamID2, varID, levelID);
if ( lcopy )
{
streamCopyRecord(streamID2, sf[fileID].streamID);
}
else
{
streamReadRecord(sf[fileID].streamID, array, &nmiss);
streamWriteRecord(streamID2, array, nmiss);
}
}
tsID2++;
}
sf[fileID].nrecs = streamInqTimestep(sf[fileID].streamID, ++sf[fileID].tsID);
if ( sf[fileID].nrecs == 0 )
{
streamClose(sf[fileID].streamID);
sf[fileID].streamID = -1;
}
else
{
sf[fileID].vdate = taxisInqVdate(sf[fileID].taxisID);
sf[fileID].vtime = taxisInqVtime(sf[fileID].taxisID);
}
}
streamClose(streamID2);
if ( ! lcopy )
if ( array ) free(array);
if ( sf ) free(sf);
cdoFinish();
return (0);
}
void *Magplot(void *argument)
{
int operatorID;
int varID, recID;
int gridsize;
int gridID;
int nrecs;
int levelID;
int tsID;
int streamID;
int vlistID;
int nmiss;
int nlon, nlat;
int nlev;
int zaxisID, taxisID;
int vdate, vtime;
int nparam = 0;
int i;
char **pnames = NULL;
char varname[CDI_MAX_NAME];
double missval;
double *array = NULL;
double *grid_center_lat = NULL, *grid_center_lon = NULL;
char units[CDI_MAX_NAME];
char vdatestr[32], vtimestr[32], datetimestr[64];
cdoInitialize(argument);
nparam = operatorArgc();
pnames = operatorArgv();
CONTOUR = cdoOperatorAdd("contour", 0, 0, NULL);
SHADED = cdoOperatorAdd("shaded", 0, 0, NULL);
GRFILL = cdoOperatorAdd("grfill", 0, 0, NULL);
operatorID = cdoOperatorID();
if( nparam )
{
if( DBG )
{
for( i = 0; i < nparam; i++ )
fprintf( stderr,"Param %d is %s!\n",i+1, pnames[i] );
}
VerifyPlotParameters( nparam, pnames, operatorID );
}
streamID = streamOpenRead(cdoStreamName(0));
vlistID = streamInqVlist(streamID);
taxisID = vlistInqTaxis(vlistID);
varID = 0;
gridID = vlistInqVarGrid(vlistID, varID);
zaxisID = vlistInqVarZaxis(vlistID, varID);
missval = vlistInqVarMissval(vlistID, varID);
if ( gridInqType(gridID) == GRID_GME ) cdoAbort("GME grid unspported!");
if ( gridInqType(gridID) == GRID_UNSTRUCTURED ) cdoAbort("Unstructured grid unspported!");
if ( gridInqType(gridID) != GRID_CURVILINEAR )
gridID = gridToCurvilinear(gridID, 1);
gridsize = gridInqSize(gridID);
nlon = gridInqXsize(gridID);
nlat = gridInqYsize(gridID);
nlev = zaxisInqSize(zaxisID);
array = (double*) malloc(gridsize*sizeof(double));
grid_center_lat = (double*) malloc(gridsize*sizeof(double));
grid_center_lon = (double*) malloc(gridsize*sizeof(double));
gridInqYvals(gridID, grid_center_lat);
gridInqXvals(gridID, grid_center_lon);
/* Convert lat/lon units if required */
gridInqXunits(gridID, units);
grid_to_degree(units, gridsize, grid_center_lon, "grid center lon");
gridInqYunits(gridID, units);
grid_to_degree(units, gridsize, grid_center_lat, "grid center lat");
tsID = 0;
/* HARDCODED THE FILE NAME .. TO BE SENT AS COMMAND LINE ARGUMENT FOR THE MAGICS OPERATOR */
/*
init_XMLtemplate_parser( Filename );
updatemagics_and_results_nodes( );
*/
init_MAGICS( );
while ( (nrecs = streamInqTimestep(streamID, tsID)) )
{
if( ANIM_FLAG )
{
if( nrecs > 1 )
{
cdoWarning("File has more than one variable! Animation creation not possible!!! \n");
break;
}
if( tsID % STEP_FREQ )
{
tsID++;
continue;
}
}
else
{
if( STEP_FREQ )
{
if( tsID % STEP_FREQ )
{
tsID++;
cdoWarning("NOT PLOTTING STEP %d!!!\n",tsID);
continue;
}
}
else
{
if( tsID )
{
cdoWarning("File variables have values at more than one time step! Images created for first time step!!!");
cdoWarning("To plot steps at a particular interval, set 'step_freq' to the frequency of the steps to be plotted!!!");
cdoWarning("To plot steps at random interval, set 'step_freq' to '1' and select the steps using the selection operators!!!");
break;
}
}
}
vdate = taxisInqVdate(taxisID);
vtime = taxisInqVtime(taxisID);
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
sprintf( datetimestr, "%s %s", vdatestr, vtimestr );
if( DBG )
fprintf( stderr,"Date %s Time %s\n",vdatestr, vtimestr );
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID, &varID, &levelID);
streamReadRecord(streamID, array, &nmiss);
vlistInqVarName(vlistID, varID, varname);
vlistInqVarUnits(vlistID, varID, units);
if ( operatorID == SHADED || operatorID == CONTOUR || operatorID == GRFILL )
{
if( DBG )
{
if( operatorID == SHADED )
fprintf( stderr," Creating SHADED PLOT for %s\n",varname );
else if( operatorID == CONTOUR )
fprintf( stderr," Creating CONTOUR PLOT for %s\n",varname );
else if( operatorID == GRFILL )
fprintf( stderr," Creating GRFILL PLOT for %s\n",varname );
}
if( DBG )
fprintf( stderr,"Plot %d\n",varID );
magplot(cdoStreamName(1)->args, operatorID, varname, units, nlon, nlat, grid_center_lon, grid_center_lat, array, nparam, pnames, datetimestr );
}
else
fprintf(stderr,"operator not implemented\n");
}
if( DBG )
fprintf( stderr,"TimeStep %d\n",tsID );
tsID++;
/*
if( !STEP_FREQ && tsID )
{
cdoWarning("File variables have values at more than one time step! Images created for first time step!!!");
cdoWarning("To plot steps at a particular interval, set 'step_freq' to the frequency of the steps to be plotted!!!");
cdoWarning("To plot steps at random interval, set 'step_freq' to '1' and select the steps using the selection operators!!!");
break;
}
else
{
tsID++;
if( DBG )
fprintf( stderr,"TimeStep %d\n",tsID );
}
*/
}
if( ANIM_FLAG )
{
if( FILE_SPLIT == TRUE )
cdoWarning("File split parameter ignored!!!");
}
quit_MAGICS( );
streamClose(streamID);
if ( array ) free(array);
if ( grid_center_lon ) free(grid_center_lon);
if ( grid_center_lat ) free(grid_center_lat);
/* quit_XMLtemplate_parser( ); */
cdoFinish();
return (0);
}
static void
readFuncCall(struct winHeaderEntry *header)
{
int root = commInqRootGlob ();
int funcID = header->id;
union funcArgs *funcArgs = &(header->specific.funcArgs);
xassert(funcID >= MINFUNCID && funcID <= MAXFUNCID);
switch ( funcID )
{
case STREAMCLOSE:
{
int streamID
= namespaceAdaptKey2(funcArgs->streamChange.streamID);
streamClose(streamID);
xdebug("READ FUNCTION CALL FROM WIN: %s, streamID=%d,"
" closed stream",
funcMap[(-1 - funcID)], streamID);
}
break;
case STREAMOPEN:
{
size_t filenamesz = (size_t)funcArgs->newFile.fnamelen;
xassert ( filenamesz > 0 && filenamesz < MAXDATAFILENAME );
const char *filename
= (const char *)(rxWin[root].buffer + header->offset);
xassert(filename[filenamesz] == '\0');
int filetype = funcArgs->newFile.filetype;
int streamID = streamOpenWrite(filename, filetype);
xassert(streamID != CDI_ELIBNAVAIL);
xdebug("READ FUNCTION CALL FROM WIN: %s, filenamesz=%zu,"
" filename=%s, filetype=%d, OPENED STREAM %d",
funcMap[(-1 - funcID)], filenamesz, filename,
filetype, streamID);
}
break;
case STREAMDEFVLIST:
{
int streamID
= namespaceAdaptKey2(funcArgs->streamChange.streamID);
int vlistID = namespaceAdaptKey2(funcArgs->streamChange.vlistID);
streamDefVlist(streamID, vlistID);
xdebug("READ FUNCTION CALL FROM WIN: %s, streamID=%d,"
" vlistID=%d, called streamDefVlist ().",
funcMap[(-1 - funcID)], streamID, vlistID);
}
break;
case STREAMDEFTIMESTEP:
{
MPI_Comm commCalc = commInqCommCalc ();
int streamID = funcArgs->streamNewTimestep.streamID;
int originNamespace = namespaceResHDecode(streamID).nsp;
streamID = namespaceAdaptKey2(streamID);
int oldTaxisID
= vlistInqTaxis(streamInqVlist(streamID));
int position = header->offset;
int changedTaxisID
= taxisUnpack((char *)rxWin[root].buffer, (int)rxWin[root].size,
&position, originNamespace, &commCalc, 0);
taxis_t *oldTaxisPtr = taxisPtr(oldTaxisID);
taxis_t *changedTaxisPtr = taxisPtr(changedTaxisID);
ptaxisCopy(oldTaxisPtr, changedTaxisPtr);
taxisDestroy(changedTaxisID);
streamDefTimestep(streamID, funcArgs->streamNewTimestep.tsID);
}
break;
default:
xabort ( "REMOTE FUNCTIONCALL NOT IMPLEMENTED!" );
}
}
void *Setrcaname(void *argument)
{
int streamID1, streamID2 = CDI_UNDEFID;
int nrecs;
int tsID, recID, varID, levelID;
int vlistID1, vlistID2;
int taxisID1, taxisID2;
char **rcsnames;
FILE *fp;
char line[MAX_LINE_LEN];
char sname[CDI_MAX_NAME], sdescription[CDI_MAX_NAME], sunits[CDI_MAX_NAME];
int scode, sltype, slevel;
int nvars;
int zaxisID, ltype, code, nlev;
int level;
int lcopy = FALSE;
int gridsize, nmiss;
double *array = NULL;
cdoInitialize(argument);
if ( UNCHANGED_RECORD ) lcopy = TRUE;
operatorInputArg("file name with RCA names");
rcsnames = operatorArgv();
streamID1 = streamOpenRead(cdoStreamName(0));
vlistID1 = streamInqVlist(streamID1);
vlistID2 = vlistDuplicate(vlistID1);
nvars = vlistNvars(vlistID2);
fp = fopen(rcsnames[0], "r");
if ( fp != NULL )
{
while ( readline(fp, line, MAX_LINE_LEN) )
{
sscanf(line, "%d\t%d\t%d\t%s\t%s\t%s", &scode, &sltype, &slevel, sname, sdescription, sunits);
/*
printf("%s\n", line);
printf("%d:%d:%d:%s:%s:%s\n", scode, sltype, slevel, sname, sdescription, sunits);
*/
for ( varID = 0; varID < nvars; varID++ )
{
code = vlistInqVarCode(vlistID2, varID);
zaxisID = vlistInqVarZaxis(vlistID2, varID);
nlev = zaxisInqSize(zaxisID);
ltype = zaxis2ltype(zaxisID);
if ( code == scode )
{
if ( ltype == 105 )
{
if ( nlev != 1 )
{
cdoWarning("Number of levels should be 1 for level type 105!");
cdoWarning("Maybe environment variable SPLIT_LTYPE_105 is not set.");
continue;
}
level = (int) zaxisInqLevel(zaxisID, 0);
if ( sltype == 105 && slevel == level )
{
vlistDefVarName(vlistID2, varID, sname);
vlistDefVarLongname(vlistID2, varID, sdescription);
vlistDefVarUnits(vlistID2, varID, sunits);
break;
}
}
else if ( sltype != 105 )
{
vlistDefVarName(vlistID2, varID, sname);
vlistDefVarLongname(vlistID2, varID, sdescription);
vlistDefVarUnits(vlistID2, varID, sunits);
break;
}
}
}
}
fclose(fp);
}
else
{
perror(rcsnames[0]);
}
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamDefVlist(streamID2, vlistID2);
if ( ! lcopy )
{
gridsize = vlistGridsizeMax(vlistID1);
array = (double*) malloc(gridsize*sizeof(double));
}
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
streamDefRecord(streamID2, varID, levelID);
if ( lcopy )
{
streamCopyRecord(streamID2, streamID1);
}
else
{
streamReadRecord(streamID1, array, &nmiss);
streamWriteRecord(streamID2, array, nmiss);
}
}
tsID++;
}
streamClose(streamID1);
streamClose(streamID2);
vlistDestroy(vlistID2);
if ( ! lcopy )
if ( array ) free(array);
cdoFinish();
return (0);
}
struct cksum_table *
cksum_stream(const char *fname, size_t *table_len)
{
int taxisID, vlistID, streamID;
int nvars, ngrids, nzaxis;
int i;
uint32_t *checksum_state = NULL;
struct
{
int x, y, z;
size_t chars;
} *varSize = NULL;
size_t var_size_max_chars = 0;
double *buf = NULL;
struct cksum_table *file_vars = NULL;
do {
// Open the dataset
streamID = streamOpenRead(fname);
if ( streamID < 0 )
{
fprintf(stderr, "Cannot open data input file %s: %s\n",
fname, cdiStringError(streamID));
nvars = -1;
break;
}
// Get the variable list of the dataset
vlistID = streamInqVlist(streamID);
nvars = vlistNvars(vlistID);
ngrids = vlistNgrids(vlistID);
nzaxis = vlistNzaxis(vlistID);
if (nzaxis < 0 || ngrids < 0)
{
fprintf(stderr, "Error in grid/zaxis count query %d:%d\n",
ngrids, nzaxis);
nvars = -1;
break;
}
checksum_state = xcalloc((size_t)nvars, sizeof (checksum_state[0]));
varSize = xmalloc((size_t)nvars * sizeof (varSize[0]));
for (i = 0; i < nvars; ++i)
{
int grid = vlistInqVarGrid(vlistID, i), gridType;
int zaxis = vlistInqVarZaxis(vlistID, i);
if (grid == CDI_UNDEFID || zaxis == CDI_UNDEFID)
{
fputs("error in axis/grid inquiry\n", stderr);
nvars = -1;
break;
}
if ((varSize[i].z = zaxisInqSize(zaxis)) <= 0)
{
fputs("invalid Z-axis found\n", stderr);
nvars = -1;
break;
}
if ((gridType = gridInqType(grid)) != GRID_LONLAT
&& gridType != GRID_GENERIC)
{
fprintf(stderr, "unexpected non-lonlat grid found: %d\n",
gridType);
nvars = -1;
break;
}
if ((varSize[i].x = gridInqXsize(grid)) < 0)
{
fprintf(stderr, "invalid X-size found: %d\n", varSize[i].x);
nvars = -1;
break;
}
if (varSize[i].x == 0) varSize[i].x = 1;
if ((varSize[i].y = gridInqYsize(grid)) < 0)
{
fprintf(stderr, "invalid Y-size found: %d\n", varSize[i].y);
nvars = -1;
break;
}
if (varSize[i].y == 0) varSize[i].y = 1;
varSize[i].chars = (size_t)varSize[i].x * (size_t)varSize[i].y
* (size_t)varSize[i].z * sizeof (buf[0]);
if (var_size_max_chars < varSize[i].chars)
var_size_max_chars = varSize[i].chars;
}
buf = xmalloc(var_size_max_chars);
if (nvars == -1)
break;
// Get the Time axis from the variable list
taxisID = vlistInqTaxis(vlistID);
int tsID = 0;
// Inquire the time step
while (streamInqTimestep(streamID, tsID))
{
// Get the verification date and time
int vdatetime[2] = { taxisInqVtime(taxisID), taxisInqVdate(taxisID) };
// Read var1 and var2
for (i = 0; i < nvars; ++i)
{
int nmiss;
streamReadVar(streamID, i, buf, &nmiss);
memcrc_r(checksum_state + i, (const unsigned char *)vdatetime, sizeof (vdatetime));
memcrc_r(checksum_state + i, (const unsigned char *)buf,
varSize[i].chars);
}
++tsID;
}
file_vars = xmalloc((size_t)nvars * sizeof (file_vars[0]));
for (i = 0; i < nvars; ++i)
{
file_vars[i].code = vlistInqVarCode(vlistID, i);
file_vars[i].cksum
= memcrc_finish(checksum_state + i,
(off_t)((varSize[i].chars + sizeof (int) * 2) * (size_t)tsID));
}
// Close the input stream
streamClose(streamID);
} while (0);
// free resources
free(checksum_state);
free(varSize);
free(buf);
*table_len = (size_t)nvars;
return file_vars;
}
void *Tinfo(void *argument)
{
int vdate_first = 0, vtime_first = 0;
int vdate0 = 0, vtime0 = 0;
int vdate = 0, vtime = 0;
int fdate = 0, ftime = 0;
int nrecs, ntsteps;
int tsID = 0, ntimeout;
int taxisID;
int streamID;
int vlistID;
int year0, month0, day0;
int year, month, day;
int calendar, unit;
int lforecast = FALSE;
int incperiod0 = 0, incunit0 = 0;
int incperiod = 0, incunit = 0;
int its = 0, igap;
int ngaps = 0;
int ntsm[MAX_GAPS];
int rangetsm[MAX_GAPS][2];
int vdatem[MAX_GAPS][MAX_NTSM];
int vtimem[MAX_GAPS][MAX_NTSM];
juldate_t juldate, juldate0;
double jdelta = 0, jdelta0 = 0;
int arrow = 0;
int i, len;
char vdatestr[32], vtimestr[32];
cdoInitialize(argument);
streamID = streamOpenRead(cdoStreamName(0));
vlistID = streamInqVlist(streamID);
fprintf(stdout, "\n");
taxisID = vlistInqTaxis(vlistID);
ntsteps = vlistNtsteps(vlistID);
if ( ntsteps != 0 )
{
if ( ntsteps == CDI_UNDEFID )
fprintf(stdout, " Time axis : unlimited steps\n");
else
fprintf(stdout, " Time axis : %d step%s\n", ntsteps, ntsteps == 1 ? "" : "s");
if ( taxisID != CDI_UNDEFID )
{
if ( taxisInqType(taxisID) != TAXIS_ABSOLUTE )
{
vdate = taxisInqRdate(taxisID);
vtime = taxisInqRtime(taxisID);
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
fprintf(stdout, " RefTime = %s %s", vdatestr, vtimestr);
unit = taxisInqTunit(taxisID);
if ( unit != CDI_UNDEFID ) fprintf(stdout, " Units = %s", tunit2str(unit));
calendar = taxisInqCalendar(taxisID);
if ( calendar != CDI_UNDEFID ) fprintf(stdout, " Calendar = %s", calendar2str(calendar));
if ( taxisHasBounds(taxisID) )
fprintf(stdout, " Bounds = true");
fprintf(stdout, "\n");
if ( taxisInqType(taxisID) == TAXIS_FORECAST )
{
fdate = taxisInqFdate(taxisID);
ftime = taxisInqFtime(taxisID);
date2str(fdate, vdatestr, sizeof(vdatestr));
time2str(ftime, vtimestr, sizeof(vtimestr));
fprintf(stdout, " Forecast RefTime = %s %s", vdatestr, vtimestr);
unit = taxisInqForecastTunit(taxisID);
if ( unit != CDI_UNDEFID ) fprintf(stdout, " Units = %s", tunit2str(unit));
fprintf(stdout, "\n");
lforecast = TRUE;
}
}
}
calendar = taxisInqCalendar(taxisID);
fprintf(stdout, "\n");
fprintf(stdout, " Verification Time ");
if ( lforecast ) fprintf(stdout, " Forecast Reference Time ");
if ( taxisHasBounds(taxisID) )
fprintf(stdout, " lower bound upper bound");
fprintf(stdout, "\n");
fprintf(stdout, "Timestep YYYY-MM-DD hh:mm:ss Increment");
if ( lforecast ) fprintf(stdout, " YYYY-MM-DD hh:mm:ss Period");
if ( taxisHasBounds(taxisID) )
fprintf(stdout, " YYYY-MM-DD hh:mm:ss YYYY-MM-DD hh:mm:ss Difference");
fprintf(stdout, "\n");
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID, tsID)) )
{
vdate = taxisInqVdate(taxisID);
vtime = taxisInqVtime(taxisID);
cdiDecodeDate(vdate, &year, &month, &day);
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
fprintf(stdout, "%6d %s %s", tsID+1, vdatestr, vtimestr);
if ( tsID )
{
cdiDecodeDate(vdate0, &year0, &month0, &day0);
juldate0 = juldate_encode(calendar, vdate0, vtime0);
juldate = juldate_encode(calendar, vdate, vtime);
jdelta = juldate_to_seconds(juldate_sub(juldate, juldate0));
getTimeInc(jdelta, vdate0, vdate, &incperiod, &incunit);
/* fprintf(stdout, " %g %g %g %d", jdelta, jdelta/3600, fmod(jdelta,3600), incperiod%3600);*/
len = fprintf(stdout, " %3d %s%s", incperiod, tunits[incunit], abs(incperiod)>1?"s":"");
for ( i = 0; i < 11-len; ++i ) fprintf(stdout, " ");
}
else
{
vdate_first = vdate;
vtime_first = vtime;
fprintf(stdout, " --------");
}
if ( lforecast )
{
fdate = taxisInqFdate(taxisID);
ftime = taxisInqFtime(taxisID);
date2str(fdate, vdatestr, sizeof(vdatestr));
time2str(ftime, vtimestr, sizeof(vtimestr));
fprintf(stdout, " %s %s", vdatestr, vtimestr);
double fc_period = taxisInqForecastPeriod(taxisID);
fprintf(stdout, " %7g", fc_period);
}
if ( taxisHasBounds(taxisID) ) printBounds(taxisID, calendar);
if ( tsID > 1 && (incperiod != incperiod0 || incunit != incunit0) )
{
if ( tsID == 2 && (jdelta0 > jdelta) )
{
jdelta0 = jdelta;
incperiod0 = incperiod;
incunit0 = incunit;
its = fill_gap(ngaps, ntsm, rangetsm, vdatem, vtimem,
1, incperiod0, incunit0, vdate_first, vdate, vtime,
calendar, day, juldate0,
juldate_encode(calendar, vdate_first, vtime_first));
arrow = '^';
}
else
{
its = fill_gap(ngaps, ntsm, rangetsm, vdatem, vtimem,
tsID, incperiod0, incunit0, vdate, vdate0, vtime0,
calendar, day0, juldate, juldate0);
arrow = '<';
if ( its == 0 && incperiod < 0 )
{
its = -1;
vdate = vdate0;
vtime = vtime0;
}
}
if ( its > 0 )
{
ngaps++;
if ( cdoVerbose )
fprintf(stdout, " %c--- Gap %d, missing %s%d timestep%s",
arrow, ngaps, its>=LIM_NTSM?"more than ":"", its, its>1?"s":"");
}
else if ( its < 0 )
{
if ( cdoVerbose )
fprintf(stdout, " %c--- Wrong date/time information, negative increment!", arrow);
}
}
if ( tsID == 1 )
{
jdelta0 = jdelta;
incperiod0 = incperiod;
incunit0 = incunit;
}
fprintf(stdout, "\n");
vdate0 = vdate;
vtime0 = vtime;
tsID++;
}
}
streamClose(streamID);
fprintf(stdout, "\n");
date2str(vdate_first, vdatestr, sizeof(vdatestr));
time2str(vtime_first, vtimestr, sizeof(vtimestr));
fprintf(stdout, " Start date : %s %s\n", vdatestr, vtimestr);
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
fprintf(stdout, " End date : %s %s\n", vdatestr, vtimestr);
fprintf(stdout, " Increment : %3d %s%s\n",
incperiod0, tunits[incunit0], incperiod0>1?"s":"");
fprintf(stdout, " Number of timesteps : %d\n", tsID);
fprintf(stdout, " Gaps identified : %d\n", ngaps);
if ( cdoVerbose && ngaps )
{
fprintf(stdout, "\nFound potentially %d gap%s in the time series", ngaps, ngaps>1?"s":"");
if ( ngaps >= MAX_GAPS )
{
ngaps = MAX_GAPS;
fprintf(stdout, ", here are the first %d", ngaps);
}
fprintf(stdout, ":\n");
for ( igap = 0; igap < ngaps; ++igap )
{
fprintf(stdout, " Gap %d between timestep %d and %d, missing %d timestep%s",
igap+1, rangetsm[igap][0], rangetsm[igap][1], ntsm[igap], ntsm[igap]>1?"s":"");
if ( ntsm[igap] >= MAX_NTSM )
{
ntsm[igap] = MAX_NTSM;
fprintf(stdout, ", here are the first %d", ntsm[igap]);
}
fprintf(stdout, ":\n");
ntimeout = 0;
for ( its = 0; its < ntsm[igap]; ++its )
{
if ( ntimeout == 4 )
{
ntimeout = 0;
fprintf(stdout, "\n");
}
vdate = vdatem[igap][its];
vtime = vtimem[igap][its];
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
fprintf(stdout, " %s %s", vdatestr, vtimestr);
ntimeout++;
tsID++;
}
fprintf(stdout, "\n");
}
}
cdoFinish();
return (0);
}
static void readGetBuffers()
{
int nProcsModel = commInqNProcsModel ();
int root = commInqRootGlob ();
#ifdef HAVE_NETCDF4
int myCollRank = commInqRankColl();
MPI_Comm collComm = commInqCommColl();
#endif
xdebug("%s", "START");
struct winHeaderEntry *winDict
= (struct winHeaderEntry *)rxWin[root].buffer;
xassert(winDict[0].id == HEADERSIZEMARKER);
{
int dictSize = rxWin[root].dictSize,
firstNonRPCEntry = dictSize - winDict[0].specific.headerSize.numRPCEntries - 1,
headerIdx,
numFuncCalls = 0;
for (headerIdx = dictSize - 1;
headerIdx > firstNonRPCEntry;
--headerIdx)
{
xassert(winDict[headerIdx].id >= MINFUNCID
&& winDict[headerIdx].id <= MAXFUNCID);
++numFuncCalls;
readFuncCall(winDict + headerIdx);
}
xassert(numFuncCalls == winDict[0].specific.headerSize.numRPCEntries);
}
/* build list of streams, data was transferred for */
{
struct streamMap map = buildStreamMap(winDict);
double *data = NULL;
#ifdef HAVE_NETCDF4
int *varIsWritten = NULL;
#endif
#if defined (HAVE_PARALLEL_NC4)
double *writeBuf = NULL;
#endif
int currentDataBufSize = 0;
for (int streamIdx = 0; streamIdx < map.numEntries; ++streamIdx)
{
int streamID = map.entries[streamIdx].streamID;
int vlistID = streamInqVlist(streamID);
int filetype = map.entries[streamIdx].filetype;
switch (filetype)
{
case FILETYPE_GRB:
case FILETYPE_GRB2:
writeGribStream(winDict, map.entries + streamIdx,
&data, ¤tDataBufSize,
root, nProcsModel);
break;
#ifdef HAVE_NETCDF4
case FILETYPE_NC:
case FILETYPE_NC2:
case FILETYPE_NC4:
#ifdef HAVE_PARALLEL_NC4
/* HAVE_PARALLE_NC4 implies having ScalES-PPM and yaxt */
{
int nvars = map.entries[streamIdx].numVars;
int *varMap = map.entries[streamIdx].varMap;
buildWrittenVars(map.entries + streamIdx, &varIsWritten,
myCollRank, collComm);
for (int varID = 0; varID < nvars; ++varID)
if (varIsWritten[varID])
{
struct PPM_extent varShape[3];
queryVarBounds(varShape, vlistID, varID);
struct xyzDims collGrid = varDimsCollGridMatch(varShape);
xdebug("writing varID %d with dimensions: "
"x=%d, y=%d, z=%d,\n"
"found distribution with dimensions:"
" x=%d, y=%d, z=%d.", varID,
varShape[0].size, varShape[1].size, varShape[2].size,
collGrid.sizes[0], collGrid.sizes[1],
collGrid.sizes[2]);
struct PPM_extent varChunk[3];
myVarPart(varShape, collGrid, varChunk);
int myChunk[3][2];
for (int i = 0; i < 3; ++i)
{
myChunk[i][0] = PPM_extent_start(varChunk[i]);
myChunk[i][1] = PPM_extent_end(varChunk[i]);
}
xdebug("Writing chunk { { %d, %d }, { %d, %d },"
" { %d, %d } }", myChunk[0][0], myChunk[0][1],
myChunk[1][0], myChunk[1][1], myChunk[2][0],
myChunk[2][1]);
Xt_int varSize[3];
for (int i = 0; i < 3; ++i)
varSize[2 - i] = varShape[i].size;
Xt_idxlist preRedistChunk, preWriteChunk;
/* prepare yaxt descriptor for current data
distribution after collect */
int nmiss;
if (varMap[varID] == -1)
{
preRedistChunk = xt_idxempty_new();
xdebug("%s", "I got none\n");
}
else
{
Xt_int preRedistStart[3] = { 0, 0, 0 };
preRedistChunk
= xt_idxsection_new(0, 3, varSize, varSize,
preRedistStart);
resizeVarGatherBuf(vlistID, varID, &data,
¤tDataBufSize);
int headerIdx = varMap[varID];
gatherArray(root, nProcsModel, headerIdx,
vlistID, data, &nmiss);
xdebug("%s", "I got all\n");
}
MPI_Bcast(&nmiss, 1, MPI_INT, varIsWritten[varID] - 1,
collComm);
/* prepare yaxt descriptor for write chunk */
{
Xt_int preWriteChunkStart[3], preWriteChunkSize[3];
for (int i = 0; i < 3; ++i)
{
preWriteChunkStart[2 - i] = varChunk[i].first;
preWriteChunkSize[2 - i] = varChunk[i].size;
}
preWriteChunk = xt_idxsection_new(0, 3, varSize,
preWriteChunkSize,
preWriteChunkStart);
}
/* prepare redistribution */
{
Xt_xmap xmap = xt_xmap_all2all_new(preRedistChunk,
preWriteChunk,
collComm);
Xt_redist redist = xt_redist_p2p_new(xmap, MPI_DOUBLE);
xt_idxlist_delete(preRedistChunk);
xt_idxlist_delete(preWriteChunk);
xt_xmap_delete(xmap);
writeBuf = (double*) xrealloc(writeBuf,
sizeof (double)
* PPM_extents_size(3, varChunk));
xt_redist_s_exchange1(redist, data, writeBuf);
xt_redist_delete(redist);
}
/* write chunk */
streamWriteVarChunk(streamID, varID,
(const int (*)[2])myChunk, writeBuf,
nmiss);
}
}
#else
/* determine process which has stream open (writer) and
* which has data for which variable (var owner)
* three cases need to be distinguished */
{
int nvars = map.entries[streamIdx].numVars;
int *varMap = map.entries[streamIdx].varMap;
buildWrittenVars(map.entries + streamIdx, &varIsWritten,
myCollRank, collComm);
int writerRank;
if ((writerRank = cdiPioSerialOpenFileMap(streamID))
== myCollRank)
{
for (int varID = 0; varID < nvars; ++varID)
if (varIsWritten[varID])
{
int nmiss;
int size = vlistInqVarSize(vlistID, varID);
resizeVarGatherBuf(vlistID, varID, &data,
¤tDataBufSize);
int headerIdx = varMap[varID];
if (varIsWritten[varID] == myCollRank + 1)
{
/* this process has the full array and will
* write it */
xdebug("gathering varID=%d for direct writing",
varID);
gatherArray(root, nProcsModel, headerIdx,
vlistID, data, &nmiss);
}
else
{
/* another process has the array and will
* send it over */
MPI_Status stat;
xdebug("receiving varID=%d for writing from"
" process %d",
varID, varIsWritten[varID] - 1);
xmpiStat(MPI_Recv(&nmiss, 1, MPI_INT,
varIsWritten[varID] - 1,
COLLBUFNMISS,
collComm, &stat), &stat);
xmpiStat(MPI_Recv(data, size, MPI_DOUBLE,
varIsWritten[varID] - 1,
COLLBUFTX,
collComm, &stat), &stat);
}
streamWriteVar(streamID, varID, data, nmiss);
}
}
else
for (int varID = 0; varID < nvars; ++varID)
if (varIsWritten[varID] == myCollRank + 1)
{
/* this process has the full array and another
* will write it */
int nmiss;
int size = vlistInqVarSize(vlistID, varID);
resizeVarGatherBuf(vlistID, varID, &data,
¤tDataBufSize);
int headerIdx = varMap[varID];
gatherArray(root, nProcsModel, headerIdx,
vlistID, data, &nmiss);
MPI_Request req;
MPI_Status stat;
xdebug("sending varID=%d for writing to"
" process %d",
varID, writerRank);
xmpi(MPI_Isend(&nmiss, 1, MPI_INT,
writerRank, COLLBUFNMISS,
collComm, &req));
xmpi(MPI_Send(data, size, MPI_DOUBLE,
writerRank, COLLBUFTX,
collComm));
xmpiStat(MPI_Wait(&req, &stat), &stat);
}
}
#endif
break;
#endif
default:
xabort("unhandled filetype in parallel I/O.");
}
}
#ifdef HAVE_NETCDF4
free(varIsWritten);
#ifdef HAVE_PARALLEL_NC4
free(writeBuf);
#endif
#endif
free(map.entries);
free(data);
}
xdebug("%s", "RETURN");
}
void *Pressure(void *argument)
{
int mode;
enum {ECHAM_MODE, WMO_MODE};
int geop_code = 0, temp_code = 0, ps_code = 0, lsp_code = 0;
int streamID2;
int vlistID2;
int recID, nrecs;
int i, k, offset;
int tsID, varID, levelID;
int nvars;
int zaxisIDp, zaxisIDh = -1, nzaxis;
int ngrids, gridID, zaxisID;
int nhlev = 0, nhlevf = 0, nhlevh = 0, nlevel;
int nvct;
int geopID = -1, tempID = -1, psID = -1, lnpsID = -1, pvarID = -1;
int code, param;
char paramstr[32];
char varname[CDI_MAX_NAME];
double minval, maxval;
double *vct = NULL;
double *ps_prog = NULL, *full_press = NULL, *half_press = NULL, *deltap = NULL;
double *pout = NULL;
double *pdata = NULL;
int taxisID1, taxisID2;
int lhavevct;
int nmiss;
int mono_level;
int instNum, tableNum;
int useTable;
cdoInitialize(argument);
int PRESSURE_FL = cdoOperatorAdd("pressure_fl", 0, 0, NULL);
int PRESSURE_HL = cdoOperatorAdd("pressure_hl", 0, 0, NULL);
int DELTAP = cdoOperatorAdd("deltap", 0, 0, NULL);
int operatorID = cdoOperatorID();
int streamID1 = streamOpenRead(cdoStreamName(0));
int vlistID1 = streamInqVlist(streamID1);
int gridsize = vlist_check_gridsize(vlistID1);
nzaxis = vlistNzaxis(vlistID1);
lhavevct = FALSE;
for ( i = 0; i < nzaxis; i++ )
{
mono_level = FALSE;
mono_level = TRUE;
zaxisID = vlistZaxis(vlistID1, i);
nlevel = zaxisInqSize(zaxisID);
if ( (zaxisInqType(zaxisID) == ZAXIS_HYBRID || zaxisInqType(zaxisID) == ZAXIS_HYBRID_HALF) &&
nlevel > 1 )
{
double *level;
int l;
level = (double*) malloc(nlevel*sizeof(double));
zaxisInqLevels(zaxisID, level);
for ( l = 0; l < nlevel; l++ )
{
if ( (l+1) != (int) (level[l]+0.5) ) break;
}
if ( l == nlevel ) mono_level = TRUE;
free(level);
}
if ( (zaxisInqType(zaxisID) == ZAXIS_HYBRID || zaxisInqType(zaxisID) == ZAXIS_HYBRID_HALF) &&
nlevel > 1 && mono_level )
{
nvct = zaxisInqVctSize(zaxisID);
if ( nlevel == (nvct/2 - 1) )
{
if ( lhavevct == FALSE )
{
lhavevct = TRUE;
zaxisIDh = zaxisID;
nhlev = nlevel;
nhlevf = nhlev;
nhlevh = nhlevf + 1;
vct = (double*) malloc(nvct*sizeof(double));
zaxisInqVct(zaxisID, vct);
}
}
else if ( nlevel == (nvct/2) )
{
if ( lhavevct == FALSE )
{
lhavevct = TRUE;
zaxisIDh = zaxisID;
nhlev = nlevel;
nhlevf = nhlev - 1;
nhlevh = nhlev;
vct = (double*) malloc(nvct*sizeof(double));
zaxisInqVct(zaxisID, vct);
}
}
else if ( nlevel == (nvct - 4 - 1) )
{
if ( lhavevct == FALSE )
{
int vctsize;
int voff = 4;
double *rvct = NULL;
rvct = (double*) malloc(nvct*sizeof(double));
zaxisInqVct(zaxisID,rvct);
if ( (int)(rvct[0]+0.5) == 100000 && rvct[voff] < rvct[voff+1] )
{
lhavevct = TRUE;
zaxisIDh = zaxisID;
nhlev = nlevel;
nhlevf = nhlev;
nhlevh = nhlev + 1;
vctsize = 2*nhlevh;
vct = (double*) malloc(vctsize*sizeof(double));
/* calculate VCT for LM */
for ( i = 0; i < vctsize/2; i++ )
{
if ( rvct[voff+i] >= rvct[voff] && rvct[voff+i] <= rvct[3] )
{
vct[i] = rvct[0]*rvct[voff+i];
vct[vctsize/2+i] = 0;
}
else
{
vct[i] = (rvct[0]*rvct[3]*(1-rvct[voff+i]))/(1-rvct[3]);
vct[vctsize/2+i] = (rvct[voff+i]-rvct[3])/(1-rvct[3]);
}
}
if ( cdoVerbose )
{
for ( i = 0; i < vctsize/2; i++ )
fprintf(stdout, "%5d %25.17f %25.17f\n", i, vct[i], vct[vctsize/2+i]);
}
}
free(rvct);
}
}
}
}
nvars = vlistNvars(vlistID1);
if ( zaxisIDh != -1 && gridsize > 0 )
{
ps_prog = (double*) malloc(gridsize*sizeof(double));
deltap = (double*) malloc(gridsize*nhlevf*sizeof(double));
full_press = (double*) malloc(gridsize*nhlevf*sizeof(double));
half_press = (double*) malloc(gridsize*nhlevh*sizeof(double));
}
else
cdoAbort("No 3D variable with hybrid sigma pressure coordinate found!");
if ( operatorID == PRESSURE_FL || operatorID == DELTAP )
zaxisIDp = zaxisCreate(ZAXIS_HYBRID, nhlevf);
else
zaxisIDp = zaxisCreate(ZAXIS_HYBRID_HALF, nhlevh);
{
double *level;
int l;
level = (double*) malloc(nhlevh*sizeof(double));
for ( l = 0; l < nhlevh; l++ ) level[l] = l+1;
zaxisDefLevels(zaxisIDp, level);
free(level);
}
zaxisDefVct(zaxisIDp, 2*nhlevh, vct);
useTable = FALSE;
for ( varID = 0; varID < nvars; varID++ )
{
tableNum = tableInqNum(vlistInqVarTable(vlistID1, varID));
if ( tableNum > 0 && tableNum != 255 )
{
useTable = TRUE;
break;
}
}
if ( cdoVerbose && useTable ) cdoPrint("Use code tables!");
for ( varID = 0; varID < nvars; varID++ )
{
gridID = vlistInqVarGrid(vlistID1, varID);
zaxisID = vlistInqVarZaxis(vlistID1, varID);
nlevel = zaxisInqSize(zaxisID);
instNum = institutInqCenter(vlistInqVarInstitut(vlistID1, varID));
tableNum = tableInqNum(vlistInqVarTable(vlistID1, varID));
code = vlistInqVarCode(vlistID1, varID);
param = vlistInqVarParam(vlistID1, varID);
cdiParamToString(param, paramstr, sizeof(paramstr));
if ( useTable )
{
if ( tableNum == 2 )
{
mode = WMO_MODE;
geop_code = 6;
temp_code = 11;
ps_code = 1;
}
else if ( tableNum == 128 )
{
mode = ECHAM_MODE;
geop_code = 129;
temp_code = 130;
ps_code = 134;
lsp_code = 152;
}
else
mode = -1;
}
else
{
mode = ECHAM_MODE;
geop_code = 129;
temp_code = 130;
ps_code = 134;
lsp_code = 152;
}
if ( cdoVerbose )
cdoPrint("Mode = %d Center = %d Param = %s", mode, instNum, paramstr);
if ( code <= 0 )
{
vlistInqVarName(vlistID1, varID, varname);
strtolower(varname);
/* ECHAM ECMWF */
if ( strcmp(varname, "geosp") == 0 || strcmp(varname, "z") == 0 ) code = 129;
else if ( strcmp(varname, "st") == 0 || strcmp(varname, "t") == 0 ) code = 130;
else if ( strcmp(varname, "aps") == 0 || strcmp(varname, "sp" ) == 0 ) code = 134;
else if ( strcmp(varname, "ps") == 0 ) code = 134;
else if ( strcmp(varname, "lsp") == 0 || strcmp(varname, "lnsp") == 0 ) code = 152;
/* else if ( strcmp(varname, "geopoth") == 0 ) code = 156; */
}
if ( mode == ECHAM_MODE )
{
if ( code == geop_code && nlevel == 1 ) geopID = varID;
else if ( code == temp_code && nlevel == nhlev ) tempID = varID;
else if ( code == ps_code && nlevel == 1 ) psID = varID;
else if ( code == lsp_code && nlevel == 1 ) lnpsID = varID;
/* else if ( code == 156 ) gheightID = varID; */
}
else if ( mode == WMO_MODE )
{
if ( code == geop_code && nlevel == 1 ) geopID = varID;
else if ( code == temp_code && nlevel == nhlev ) tempID = varID;
else if ( code == ps_code && nlevel == 1 ) psID = varID;
}
}
pvarID = lnpsID;
if ( zaxisIDh != -1 && lnpsID != -1 )
{
gridID = vlistInqVarGrid(vlistID1, lnpsID);
if ( gridInqType(gridID) == GRID_SPECTRAL )
{
lnpsID = -1;
cdoWarning("Spectral LOG(%s) not supported - using %s!", var_stdname(surface_air_pressure), var_stdname(surface_air_pressure));
}
}
if ( zaxisIDh != -1 && lnpsID == -1 )
{
pvarID = psID;
if ( psID == -1 )
cdoAbort("%s not found!", var_stdname(surface_air_pressure));
}
gridID = vlistInqVarGrid(vlistID1, pvarID);
if ( gridInqType(gridID) == GRID_SPECTRAL )
cdoAbort("%s on spectral representation not supported!", var_stdname(surface_air_pressure));
pdata = (double*) malloc(gridsize*sizeof(double));
vlistID2 = vlistCreate();
varID = vlistDefVar(vlistID2, gridID, zaxisIDp, TSTEP_INSTANT);
vlistDefVarCode(vlistID2, varID, 1);
vlistDefVarName(vlistID2, varID, "pressure");
vlistDefVarStdname(vlistID2, varID, "air_pressure");
vlistDefVarUnits(vlistID2, varID, "Pa");
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamDefVlist(streamID2, vlistID2);
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
if ( varID == pvarID )
{
streamReadRecord(streamID1, pdata, &nmiss);
if ( nmiss > 0 ) cdoAbort("Missing valus unsupported!");
}
}
if ( zaxisIDh != -1 )
{
if ( lnpsID != -1 )
for ( i = 0; i < gridsize; i++ ) ps_prog[i] = exp(pdata[i]);
else if ( psID != -1 )
memcpy(ps_prog, pdata, gridsize*sizeof(double));
/* check range of ps_prog */
minmaxval(gridsize, ps_prog, NULL, &minval, &maxval);
if ( minval < MIN_PS || maxval > MAX_PS )
cdoWarning("Surface pressure out of range (min=%g max=%g)!", minval, maxval);
presh(full_press, half_press, vct, ps_prog, nhlevf, gridsize);
}
if ( operatorID == PRESSURE_FL )
{
nlevel = nhlevf;
pout = full_press;
}
else if ( operatorID == DELTAP )
{
nlevel = nhlevf;
for ( k = 0; k < nhlevf; ++k )
for ( i = 0; i < gridsize; ++i )
{
deltap[k*gridsize+i] = half_press[(k+1)*gridsize+i] - half_press[k*gridsize+i];
}
pout = deltap;
}
else
{
nlevel = nhlevh;
pout = half_press;
}
varID = 0;
for ( levelID = 0; levelID < nlevel; levelID++ )
{
streamDefRecord(streamID2, varID, levelID);
offset = levelID*gridsize;
streamWriteRecord(streamID2, pout+offset, 0);
}
tsID++;
}
streamClose(streamID2);
streamClose(streamID1);
if ( pdata ) free(pdata);
if ( ps_prog ) free(ps_prog);
if ( deltap ) free(deltap);
if ( full_press ) free(full_press);
if ( half_press ) free(half_press);
if ( vct ) free(vct);
cdoFinish();
return (0);
}
static size_t
collDefBufferSizes()
{
int *streamIndexList, vlistID, nvars, varID, iorank;
int modelID;
size_t sumGetBufferSizes = 0;
int rankGlob = commInqRankGlob ();
int nProcsModel = commInqNProcsModel ();
int root = commInqRootGlob ();
xassert(rxWin != NULL);
unsigned nstreams = reshCountType ( &streamOps );
streamIndexList = xmalloc((size_t)nstreams * sizeof (streamIndexList[0]));
reshGetResHListOfType ( nstreams, streamIndexList, &streamOps );
for (unsigned streamNo = 0; streamNo < nstreams; streamNo++)
{
// space required for data
vlistID = streamInqVlist ( streamIndexList[streamNo] );
nvars = vlistNvars ( vlistID );
for ( varID = 0; varID < nvars; varID++ )
{
iorank = vlistInqVarIOrank ( vlistID, varID );
xassert ( iorank != CDI_UNDEFID );
if ( iorank == rankGlob )
{
for ( modelID = 0; modelID < nProcsModel; modelID++ )
{
int decoChunk;
{
int varSize = vlistInqVarSize(vlistID, varID);
int nProcsModel = commInqNProcsModel();
decoChunk =
(int)ceilf(cdiPIOpartInflate_
* (float)(varSize + nProcsModel - 1)
/ (float)nProcsModel);
}
xassert ( decoChunk > 0 );
rxWin[modelID].size += (size_t)decoChunk * sizeof (double)
/* re-align chunks to multiple of double size */
+ sizeof (double) - 1
/* one header for data record, one for
* corresponding part descriptor*/
+ 2 * sizeof (struct winHeaderEntry)
/* FIXME: heuristic for size of packed Xt_idxlist */
+ sizeof (Xt_int) * (size_t)decoChunk * 3;
rxWin[modelID].dictSize += 2;
}
}
}
// space required for the 3 function calls streamOpen, streamDefVlist, streamClose
// once per stream and timestep for all collprocs only on the modelproc root
rxWin[root].size += numRPCFuncs * sizeof (struct winHeaderEntry)
/* serialized filename */
+ MAXDATAFILENAME
/* data part of streamDefTimestep */
+ (2 * CDI_MAX_NAME + sizeof (taxis_t));
rxWin[root].dictSize += numRPCFuncs;
}
free ( streamIndexList );
for ( modelID = 0; modelID < nProcsModel; modelID++ )
{
/* account for size header */
rxWin[modelID].dictSize += 1;
rxWin[modelID].size += sizeof (struct winHeaderEntry);
rxWin[modelID].size = roundUpToMultiple(rxWin[modelID].size,
PIO_WIN_ALIGN);
sumGetBufferSizes += (size_t)rxWin[modelID].size;
}
xassert ( sumGetBufferSizes <= MAXWINBUFFERSIZE );
return sumGetBufferSizes;
}
void *Complextorect(void *argument)
{
// int COMPLEXTORECT;
// int operatorID;
int streamID1, streamID2, streamID3;
int tsID, nrecs;
int recID, varID, levelID;
int vlistID1, vlistID2, vlistID3;
int taxisID1, taxisID2, taxisID3;
int i, gridsize;
int datatype;
int nmiss, nvars;
double *array1 = NULL, *array2 = NULL, *array3 = NULL;
cdoInitialize(argument);
// COMPLEXTORECT = cdoOperatorAdd("complextorect", 0, 0, NULL);
// operatorID = cdoOperatorID();
streamID1 = streamOpenRead(cdoStreamName(0));
vlistID1 = streamInqVlist(streamID1);
vlistID2 = vlistDuplicate(vlistID1);
vlistID3 = vlistDuplicate(vlistID1);
nvars = vlistNvars(vlistID2);
for ( varID = 0; varID < nvars; ++varID )
{
datatype = vlistInqVarDatatype(vlistID2, varID);
if ( datatype == DATATYPE_CPX64 )
datatype = DATATYPE_FLT64;
else
datatype = DATATYPE_FLT32;
vlistDefVarDatatype(vlistID2, varID, datatype);
vlistDefVarDatatype(vlistID3, varID, datatype);
}
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
taxisID3 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
vlistDefTaxis(vlistID3, taxisID3);
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamID3 = streamOpenWrite(cdoStreamName(2), cdoFiletype());
streamDefVlist(streamID2, vlistID2);
streamDefVlist(streamID3, vlistID3);
gridsize = vlistGridsizeMax(vlistID1);
array1 = (double*) malloc(2*gridsize*sizeof(double));
array2 = (double*) malloc(gridsize*sizeof(double));
array3 = (double*) malloc(gridsize*sizeof(double));
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
taxisCopyTimestep(taxisID3, taxisID1);
streamDefTimestep(streamID2, tsID);
streamDefTimestep(streamID3, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
streamDefRecord(streamID2, varID, levelID);
streamDefRecord(streamID3, varID, levelID);
gridsize = gridInqSize(vlistInqVarGrid(vlistID1, varID));
streamReadRecord(streamID1, array1, &nmiss);
for ( i = 0; i < gridsize; ++i )
{
array2[i] = array1[2*i];
array3[i] = array1[2*i+1];
}
streamWriteRecord(streamID2, array2, nmiss);
streamWriteRecord(streamID3, array3, nmiss);
}
tsID++;
}
streamClose(streamID3);
streamClose(streamID2);
streamClose(streamID1);
if ( array1 ) free(array1);
if ( array2 ) free(array2);
if ( array3 ) free(array3);
vlistDestroy(vlistID2);
vlistDestroy(vlistID3);
cdoFinish();
return (NULL);
}
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);
}
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 *Sinfo(void *argument)
{
enum {func_generic, func_param, func_name, func_code};
int operatorID;
int operfunc, lensemble;
int indf;
int varID;
int gridsize = 0;
int gridID, zaxisID, code, tabnum, param;
int vdate, vtime;
int nvars, ntsteps;
int levelsize;
int tsteptype, taxisID;
char tmpname[CDI_MAX_NAME];
char varname[CDI_MAX_NAME];
char paramstr[32];
char vdatestr[32], vtimestr[32];
const char *modelptr, *instptr;
int streamID = 0;
int vlistID;
int datatype;
char pstr[4];
cdoInitialize(argument);
cdoOperatorAdd("sinfo", func_generic, 0, NULL);
cdoOperatorAdd("sinfop", func_param, 0, NULL);
cdoOperatorAdd("sinfon", func_name, 0, NULL);
cdoOperatorAdd("sinfoc", func_code, 0, NULL);
cdoOperatorAdd("seinfo", func_generic, 1, NULL);
cdoOperatorAdd("seinfop", func_param, 1, NULL);
cdoOperatorAdd("seinfon", func_name, 1, NULL);
cdoOperatorAdd("seinfoc", func_code, 1, NULL);
operatorID = cdoOperatorID();
operfunc = cdoOperatorF1(operatorID);
lensemble = cdoOperatorF2(operatorID);
for ( indf = 0; indf < cdoStreamCnt(); indf++ )
{
streamID = streamOpenRead(cdoStreamName(indf));
vlistID = streamInqVlist(streamID);
set_text_color(stdout, BRIGHT, BLACK);
fprintf(stdout, " File format");
reset_text_color(stdout);
fprintf(stdout, " : ");
printFiletype(streamID, vlistID);
set_text_color(stdout, BRIGHT, BLACK);
if ( lensemble )
fprintf(stdout, "%6d : Institut Source Ttype Einfo Levels Num Points Num Dtype : ", -(indf+1));
else
fprintf(stdout, "%6d : Institut Source Ttype Levels Num Points Num Dtype : ", -(indf+1));
if ( operfunc == func_name ) fprintf(stdout, "Parameter name");
else if ( operfunc == func_code ) fprintf(stdout, "Table Code");
else fprintf(stdout, "Parameter ID");
if ( cdoVerbose ) fprintf(stdout, " : Extra" );
reset_text_color(stdout);
fprintf(stdout, "\n" );
nvars = vlistNvars(vlistID);
for ( varID = 0; varID < nvars; varID++ )
{
param = vlistInqVarParam(vlistID, varID);
code = vlistInqVarCode(vlistID, varID);
tabnum = tableInqNum(vlistInqVarTable(vlistID, varID));
gridID = vlistInqVarGrid(vlistID, varID);
zaxisID = vlistInqVarZaxis(vlistID, varID);
set_text_color(stdout, BRIGHT, BLACK);
fprintf(stdout, "%6d", varID+1);
reset_text_color(stdout);
set_text_color(stdout, RESET, BLACK);
fprintf(stdout, " : ");
reset_text_color(stdout);
set_text_color(stdout, RESET, BLUE);
/* institute info */
instptr = institutInqNamePtr(vlistInqVarInstitut(vlistID, varID));
strcpy(tmpname, "unknown");
if ( instptr ) strncpy(tmpname, instptr, CDI_MAX_NAME);
limit_string_length(tmpname, CDI_MAX_NAME);
fprintf(stdout, "%-8s ", tmpname);
/* source info */
modelptr = modelInqNamePtr(vlistInqVarModel(vlistID, varID));
strcpy(tmpname, "unknown");
if ( modelptr ) strncpy(tmpname, modelptr, CDI_MAX_NAME);
limit_string_length(tmpname, CDI_MAX_NAME);
fprintf(stdout, "%-8s ", tmpname);
/* tsteptype */
tsteptype = vlistInqVarTsteptype(vlistID, varID);
if ( tsteptype == TSTEP_CONSTANT ) fprintf(stdout, "%-8s ", "constant");
else if ( tsteptype == TSTEP_INSTANT ) fprintf(stdout, "%-8s ", "instant");
else if ( tsteptype == TSTEP_INSTANT2 ) fprintf(stdout, "%-8s ", "instant");
else if ( tsteptype == TSTEP_INSTANT3 ) fprintf(stdout, "%-8s ", "instant");
else if ( tsteptype == TSTEP_MIN ) fprintf(stdout, "%-8s ", "min");
else if ( tsteptype == TSTEP_MAX ) fprintf(stdout, "%-8s ", "max");
else if ( tsteptype == TSTEP_AVG ) fprintf(stdout, "%-8s ", "avg");
else if ( tsteptype == TSTEP_ACCUM ) fprintf(stdout, "%-8s ", "accum");
else if ( tsteptype == TSTEP_RANGE ) fprintf(stdout, "%-8s ", "range");
else if ( tsteptype == TSTEP_DIFF ) fprintf(stdout, "%-8s ", "diff");
else fprintf(stdout, "%-8s ", "unknown");
/* ensemble information */
if ( lensemble )
{
int ensID, ensCount, forecast_type;
if ( vlistInqVarEnsemble(vlistID, varID, &ensID, &ensCount, &forecast_type) )
fprintf(stdout, "%2d/%-2d ", ensID, ensCount);
else
fprintf(stdout, "--/-- ");
}
/* layer info */
levelsize = zaxisInqSize(zaxisID);
fprintf(stdout, "%6d ", levelsize);
fprintf(stdout, "%3d ", vlistZaxisIndex(vlistID, zaxisID) + 1);
/* grid info */
gridsize = gridInqSize(gridID);
fprintf(stdout, "%9d ", gridsize);
fprintf(stdout, "%3d ", vlistGridIndex(vlistID, gridID) + 1);
/* datatype */
datatype = vlistInqVarDatatype(vlistID, varID);
datatype2str(datatype, pstr);
fprintf(stdout, " %-3s", pstr);
if ( vlistInqVarCompType(vlistID, varID) == COMPRESS_NONE )
fprintf(stdout, " ");
else
fprintf(stdout, "z ");
reset_text_color(stdout);
set_text_color(stdout, RESET, BLACK);
fprintf(stdout, ": ");
reset_text_color(stdout);
/* parameter info */
cdiParamToString(param, paramstr, sizeof(paramstr));
if ( operfunc == func_name ) vlistInqVarName(vlistID, varID, varname);
set_text_color(stdout, BRIGHT, GREEN);
if ( operfunc == func_name )
fprintf(stdout, "%-14s", varname);
else if ( operfunc == func_code )
fprintf(stdout, "%4d %4d ", tabnum, code);
else
fprintf(stdout, "%-14s", paramstr);
reset_text_color(stdout);
if ( cdoVerbose )
{
char varextra[CDI_MAX_NAME];
vlistInqVarExtra(vlistID, varID, varextra);
fprintf(stdout, " : %s", varextra );
}
fprintf(stdout, "\n");
}
set_text_color(stdout, BRIGHT, BLACK);
fprintf(stdout, " Grid coordinates");
reset_text_color(stdout);
fprintf(stdout, " :\n");
printGridInfo(vlistID);
set_text_color(stdout, BRIGHT, BLACK);
fprintf(stdout, " Vertical coordinates");
reset_text_color(stdout);
fprintf(stdout, " :\n");
printZaxisInfo(vlistID);
taxisID = vlistInqTaxis(vlistID);
ntsteps = vlistNtsteps(vlistID);
if ( ntsteps != 0 )
{
set_text_color(stdout, BRIGHT, BLACK);
fprintf(stdout, " Time coordinate");
reset_text_color(stdout);
if ( ntsteps == CDI_UNDEFID )
fprintf(stdout, " : unlimited steps\n");
else
fprintf(stdout, " : %d step%s\n", ntsteps, ntsteps == 1 ? "" : "s");
if ( taxisID != CDI_UNDEFID )
{
if ( taxisInqType(taxisID) != TAXIS_ABSOLUTE )
{
vdate = taxisInqRdate(taxisID);
vtime = taxisInqRtime(taxisID);
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
fprintf(stdout, " RefTime = %s %s", vdatestr, vtimestr);
int tunits = taxisInqTunit(taxisID);
if ( tunits != CDI_UNDEFID ) fprintf(stdout, " Units = %s", tunit2str(tunits));
int calendar = taxisInqCalendar(taxisID);
if ( calendar != CDI_UNDEFID ) fprintf(stdout, " Calendar = %s", calendar2str(calendar));
if ( taxisHasBounds(taxisID) )
fprintf(stdout, " Bounds = true");
fprintf(stdout, "\n");
if ( taxisInqType(taxisID) == TAXIS_FORECAST )
{
vdate = taxisInqFdate(taxisID);
vtime = taxisInqFtime(taxisID);
date2str(vdate, vdatestr, sizeof(vdatestr));
time2str(vtime, vtimestr, sizeof(vtimestr));
fprintf(stdout, " ForecastRefTime = %s %s", vdatestr, vtimestr);
fprintf(stdout, "\n");
}
}
}
fprintf(stdout, " YYYY-MM-DD hh:mm:ss YYYY-MM-DD hh:mm:ss YYYY-MM-DD hh:mm:ss YYYY-MM-DD hh:mm:ss\n");
set_text_color(stdout, RESET, MAGENTA);
printTimesteps(streamID, taxisID, cdoVerbose);
reset_text_color(stdout);
fprintf(stdout, "\n");
}
streamClose(streamID);
}
cdoFinish();
return (0);
}
void *Sethalo(void *argument)
{
int SETHALO, TPNHALO;
int operatorID;
int streamID1, streamID2;
int nrecs, nvars;
int tsID, recID, varID, levelID;
int gridsize, gridsize2;
int vlistID1, vlistID2;
int gridID1 = -1, gridID2;
int index, ngrids, gridtype;
int nmiss;
int *vars;
int i;
int lhalo = 0, rhalo = 0;
int ndiffgrids;
double missval;
double *array1 = NULL, *array2 = NULL;
int taxisID1, taxisID2;
cdoInitialize(argument);
SETHALO = cdoOperatorAdd("sethalo", 0, 0, NULL);
TPNHALO = cdoOperatorAdd("tpnhalo", 0, 0, NULL);
operatorID = cdoOperatorID();
streamID1 = streamOpenRead(cdoStreamName(0));
vlistID1 = streamInqVlist(streamID1);
ngrids = vlistNgrids(vlistID1);
ndiffgrids = 0;
for ( index = 1; index < ngrids; index++ )
if ( vlistGrid(vlistID1, 0) != vlistGrid(vlistID1, index))
ndiffgrids++;
for ( index = 0; index < ngrids; index++ )
{
gridID1 = vlistGrid(vlistID1, index);
gridtype = gridInqType(gridID1);
if ( gridtype == GRID_LONLAT || gridtype == GRID_GAUSSIAN ) break;
if ( gridtype == GRID_CURVILINEAR ) break;
if ( gridtype == GRID_GENERIC &&
gridInqXsize(gridID1) > 0 && gridInqYsize(gridID1) > 0 ) break;
}
if ( gridInqType(gridID1) == GRID_GAUSSIAN_REDUCED )
cdoAbort("Gaussian reduced grid found. Use option -R to convert it to a regular grid!");
if ( index == ngrids ) cdoAbort("No regular grid found!");
if ( ndiffgrids > 0 ) cdoAbort("Too many different grids!");
if ( operatorID == SETHALO )
{
operatorInputArg("left and right halo");
gridID2 = genindexgrid(gridID1, &lhalo, &rhalo);
}
else
{
gridID2 = gentpngrid(gridID1);
}
vlistID2 = vlistDuplicate(vlistID1);
taxisID1 = vlistInqTaxis(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
ngrids = vlistNgrids(vlistID1);
for ( index = 0; index < ngrids; index++ )
{
if ( gridID1 == vlistGrid(vlistID1, index) )
{
vlistChangeGridIndex(vlistID2, index, gridID2);
break;
}
}
nvars = vlistNvars(vlistID1);
vars = (int*) malloc(nvars*sizeof(int));
for ( varID = 0; varID < nvars; varID++ )
{
if ( gridID1 == vlistInqVarGrid(vlistID1, varID) )
vars[varID] = TRUE;
else
vars[varID] = FALSE;
}
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamDefVlist(streamID2, vlistID2);
gridsize = gridInqSize(gridID1);
array1 = (double*) malloc(gridsize*sizeof(double));
gridsize2 = gridInqSize(gridID2);
array2 = (double*) malloc(gridsize2*sizeof(double));
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
streamDefTimestep(streamID2, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID1, &varID, &levelID);
if ( vars[varID] )
{
streamReadRecord(streamID1, array1, &nmiss);
if ( operatorID == SETHALO )
halo(array1, gridID1, array2, lhalo, rhalo);
else
tpnhalo(array1, gridID1, array2);
if ( nmiss )
{
nmiss = 0;
missval = vlistInqVarMissval(vlistID1, varID);
for ( i = 0; i < gridsize2; i++ )
if ( DBL_IS_EQUAL(array2[i], missval) ) nmiss++;
}
streamDefRecord(streamID2, varID, levelID);
streamWriteRecord(streamID2, array2, nmiss);
}
}
tsID++;
}
streamClose(streamID2);
streamClose(streamID1);
if ( vars ) free(vars);
if ( array2 ) free(array2);
if ( array1 ) free(array1);
cdoFinish();
return (0);
}
int main()
{
char fname[] = "test.grb";
int filetype = FILETYPE_GRB;
enum {
nlat = 18,
nlon = 2*nlat,
};
double *data = NULL;
int nlevel;
int varID;
int streamID1, streamID2;
int gridID, zaxisID;
int nrecs, nvars;
int tsID;
int levelID;
int vlistID, taxisID;
int nmiss;
size_t datasize = (size_t)nlon * (size_t)nlat;
data = (double *)xmalloc(datasize * sizeof (double));
memset(data, 0, datasize * sizeof (double));
gridID = gridCreate(GRID_GAUSSIAN, (int)datasize);
gridDefXsize(gridID, nlon);
gridDefYsize(gridID, nlat);
zaxisID = zaxisCreate(ZAXIS_SURFACE, 1);
vlistID = vlistCreate();
vlistDefVar(vlistID, gridID, zaxisID, TIME_VARIABLE);
taxisID = taxisCreate(TAXIS_ABSOLUTE);
vlistDefTaxis(vlistID, taxisID);
streamID1 = streamOpenWrite(fname, filetype);
if ( streamID1 < 0 )
{
fprintf(stderr, "Open failed on %s\n", fname);
fprintf(stderr, "%s\n", cdiStringError(streamID1));
return (-1);
}
streamDefVlist(streamID1, vlistID);
(void) streamDefTimestep(streamID1, 0);
streamWriteVar(streamID1, 0, data, 0);
return (0);
vlistID = streamInqVlist(streamID1);
filetype = streamInqFiletype(streamID1);
streamID2 = streamOpenWrite(fname, filetype);
if ( streamID2 < 0 )
{
fprintf(stderr, "Open failed on %s\n", fname);
fprintf(stderr, "%s\n", cdiStringError(streamID2));
return (-1);
}
streamDefVlist(streamID2, vlistID);
nvars = vlistNvars(vlistID);
for ( varID = 0; varID < nvars; varID++ )
{
int gridID = vlistInqVarGrid(vlistID, varID);
int zaxisID = vlistInqVarZaxis(vlistID, varID);
size_t gridsize = (size_t)gridInqSize(gridID);
size_t nlevel = (size_t)zaxisInqSize(zaxisID);
if ( gridsize*nlevel > datasize ) datasize = gridsize*nlevel;
}
data = (double *)xrealloc(data, datasize*sizeof(double));
memset(data, 0, datasize*sizeof(double));
taxisID = vlistInqTaxis(vlistID);
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
/* int vdate = */taxisInqVdate(taxisID);
/* int vtime = */taxisInqVtime(taxisID);
streamDefTimestep(streamID2, tsID);
for ( varID = 0; varID < nvars; varID++ )
{
streamReadVar(streamID1, varID, data, &nmiss);
/* int code = */vlistInqVarCode(vlistID, varID);
gridID = vlistInqVarGrid(vlistID, varID);
zaxisID = vlistInqVarZaxis(vlistID, varID);
/* int gridtype = */gridInqType(gridID);
/* int gridsize = */gridInqSize(gridID);
nlevel = zaxisInqSize(zaxisID);
/* double missval = */vlistInqVarMissval(vlistID, varID);
for ( levelID = 0; levelID < nlevel; levelID++ )
{
/* int level = (int) */ zaxisInqLevel(zaxisID, levelID);
/* int offset = gridsize*levelID; */
}
streamWriteVar(streamID2, varID, data, nmiss);
}
tsID++;
}
free(data);
streamClose(streamID2);
streamClose(streamID1);
return (0);
}
void *Cond(void *argument)
{
int IFTHEN, IFNOTTHEN;
int operatorID;
enum {FILL_NONE, FILL_TS, FILL_REC};
int filltype = FILL_NONE;
int streamID1, streamID2, streamID3;
int gridsize;
int ntsteps1, ntsteps2;
int nrecs, nrecs2, nvars = 0, nlev, recID;
int tsID;
int varID, levelID;
int offset;
int vlistID1, vlistID2, vlistID3;
int nmiss1, nmiss2, nmiss3;
int i;
double missval1 = -9.E33;
double missval2 = -9.E33;
double *array1, *array2, *array3;
int **varnmiss1 = NULL;
double **vardata1 = NULL;
int taxisID2, taxisID3;
cdoInitialize(argument);
IFTHEN = cdoOperatorAdd("ifthen", 0, 0, NULL);
IFNOTTHEN = cdoOperatorAdd("ifnotthen", 0, 0, NULL);
operatorID = cdoOperatorID();
streamID1 = streamOpenRead(cdoStreamName(0));
streamID2 = streamOpenRead(cdoStreamName(1));
vlistID1 = streamInqVlist(streamID1);
vlistID2 = streamInqVlist(streamID2);
vlistID3 = vlistDuplicate(vlistID2);
taxisID2 = vlistInqTaxis(vlistID2);
taxisID3 = taxisDuplicate(taxisID2);
vlistDefTaxis(vlistID3, taxisID3);
ntsteps1 = vlistNtsteps(vlistID1);
ntsteps2 = vlistNtsteps(vlistID2);
if ( ntsteps1 == 0 ) ntsteps1 = 1;
if ( ntsteps2 == 0 ) ntsteps2 = 1;
if ( vlistNrecs(vlistID1) == 1 && vlistNrecs(vlistID2) != 1 )
{
filltype = FILL_REC;
cdoPrint("Filling up stream1 >%s< by copying the first record.", cdoStreamName(0)->args);
}
if ( filltype == FILL_NONE )
vlistCompare(vlistID1, vlistID2, CMP_DIM);
nospec(vlistID1);
nospec(vlistID2);
streamID3 = streamOpenWrite(cdoStreamName(2), cdoFiletype());
streamDefVlist(streamID3, vlistID3);
gridsize = vlistGridsizeMax(vlistID2);
if ( filltype == FILL_REC && gridsize != gridInqSize(vlistGrid(vlistID1, 0)) )
cdoAbort("Stream1 >%s< has wrong gridsize!", cdoStreamName(0)->args);
array1 = (double*) malloc(gridsize*sizeof(double));
array2 = (double*) malloc(gridsize*sizeof(double));
array3 = (double*) malloc(gridsize*sizeof(double));
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 stream1 >%s< by copying the first timestep.", cdoStreamName(0)->args);
nvars = vlistNvars(vlistID1);
vardata1 = (double **) malloc(nvars*sizeof(double *));
varnmiss1 = (int **) malloc(nvars*sizeof(int *));
for ( varID = 0; varID < nvars; varID++ )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistID1, varID));
nlev = zaxisInqSize(vlistInqVarZaxis(vlistID1, varID));
vardata1[varID] = (double*) malloc(nlev*gridsize*sizeof(double));
varnmiss1[varID] = (int*) malloc(nlev*sizeof(int));
}
}
}
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID2, tsID)) )
{
if ( tsID == 0 || filltype == FILL_NONE )
{
nrecs2 = streamInqTimestep(streamID1, tsID);
if ( nrecs2 == 0 )
cdoAbort("Input streams have different number of timesteps!");
}
taxisCopyTimestep(taxisID3, taxisID2);
streamDefTimestep(streamID3, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
streamInqRecord(streamID2, &varID, &levelID);
streamReadRecord(streamID2, array2, &nmiss2);
if ( tsID == 0 || filltype == FILL_NONE )
{
if ( recID == 0 || filltype != FILL_REC )
{
streamInqRecord(streamID1, &varID, &levelID);
streamReadRecord(streamID1, array1, &nmiss1);
}
if ( filltype == FILL_TS )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistID1, varID));
offset = gridsize*levelID;
memcpy(vardata1[varID]+offset, array1, gridsize*sizeof(double));
varnmiss1[varID][levelID] = nmiss1;
}
}
else if ( filltype == FILL_TS )
{
gridsize = gridInqSize(vlistInqVarGrid(vlistID1, varID));
offset = gridsize*levelID;
memcpy(array1, vardata1[varID]+offset, gridsize*sizeof(double));
nmiss1 = varnmiss1[varID][levelID];
}
gridsize = gridInqSize(vlistInqVarGrid(vlistID2, varID));
missval2 = vlistInqVarMissval(vlistID2, varID);
if ( recID == 0 || filltype != FILL_REC )
{
missval1 = vlistInqVarMissval(vlistID1, varID);
}
if ( operatorID == IFTHEN )
{
for ( i = 0; i < gridsize; i++ )
array3[i] = !DBL_IS_EQUAL(array1[i], missval1) && !DBL_IS_EQUAL(array1[i], 0.) ? array2[i] : missval2;
}
else if ( operatorID == IFNOTTHEN )
{
for ( i = 0; i < gridsize; i++ )
array3[i] = !DBL_IS_EQUAL(array1[i], missval1) && DBL_IS_EQUAL(array1[i], 0.) ? array2[i] : missval2;
}
else
{
cdoAbort("Operator not implemented!");
}
nmiss3 = 0;
for ( i = 0; i < gridsize; i++ )
if ( DBL_IS_EQUAL(array3[i], missval2) ) nmiss3++;
streamDefRecord(streamID3, varID, levelID);
streamWriteRecord(streamID3, array3, nmiss3);
}
tsID++;
}
streamClose(streamID3);
streamClose(streamID2);
streamClose(streamID1);
if ( vardata1 )
{
for ( varID = 0; varID < nvars; varID++ )
{
free(vardata1[varID]);
free(varnmiss1[varID]);
}
free(vardata1);
free(varnmiss1);
}
if ( array3 ) free(array3);
if ( array2 ) free(array2);
if ( array1 ) free(array1);
cdoFinish();
return (0);
}
void *Tee(void *argument)
{
int streamID1, streamID2, streamID3;
int nrecs;
int tsID, recID, varID, levelID;
int lcopy = FALSE;
int gridsize;
int vlistID1, vlistID2, vlistID3;
int nmiss;
int taxisID1, taxisID2, taxisID3;
double *array = NULL;
cdoInitialize(argument);
if ( UNCHANGED_RECORD ) lcopy = TRUE;
streamID1 = streamOpenRead(cdoStreamName(0));
vlistID1 = streamInqVlist(streamID1);
taxisID1 = vlistInqTaxis(vlistID1);
streamID2 = streamOpenWrite(cdoStreamName(1), cdoFiletype());
streamID3 = streamOpenWrite(cdoStreamName(2), cdoFiletype());
vlistID2 = vlistDuplicate(vlistID1);
vlistID3 = vlistDuplicate(vlistID1);
taxisID2 = taxisDuplicate(taxisID1);
taxisID3 = taxisDuplicate(taxisID1);
vlistDefTaxis(vlistID2, taxisID2);
vlistDefTaxis(vlistID3, taxisID3);
streamDefVlist(streamID2, vlistID2);
streamDefVlist(streamID3, vlistID3);
gridsize = vlistGridsizeMax(vlistID1);
array = (double*) malloc(gridsize*sizeof(double));
tsID = 0;
while ( (nrecs = streamInqTimestep(streamID1, tsID)) )
{
taxisCopyTimestep(taxisID2, taxisID1);
taxisCopyTimestep(taxisID3, taxisID1);
streamDefTimestep(streamID2, tsID);
streamDefTimestep(streamID3, tsID);
for ( recID = 0; recID < nrecs; recID++ )
{
if ( lcopy )
{
streamInqRecord(streamID1, &varID, &levelID);
streamDefRecord(streamID2, varID, levelID);
streamCopyRecord(streamID2, streamID1);
streamDefRecord(streamID3, varID, levelID);
streamCopyRecord(streamID3, streamID1);
}
else
{
streamInqRecord(streamID1, &varID, &levelID);
streamReadRecord(streamID1, array, &nmiss);
streamDefRecord(streamID2, varID, levelID);
streamWriteRecord(streamID2, array, nmiss);
streamDefRecord(streamID3, varID, levelID);
streamWriteRecord(streamID3, array, nmiss);
}
}
tsID++;
}
streamClose(streamID1);
streamClose(streamID2);
streamClose(streamID3);
if ( array ) free(array);
cdoFinish();
return (0);
}