1 /* 2 This file is part of CDO. CDO is a collection of Operators to manipulate and analyse Climate model Data. 3 4 Author: Uwe Schulzweida 5 6 */ 7 #ifndef MODULE_DEFINITIONS_H 8 #define MODULE_DEFINITIONS_H /* \cond */ 9 10 // clang-format off 11 12 void *Adisit(void *argument); 13 #define AdisitOperators {"adisit", "adipot"} 14 15 void *Afterburner(void *argument); 16 #define AfterburnerOperators {"after"} 17 18 19 void *Arithc(void *argument); 20 #define ArithcOperators {"addc", "subc", "mulc", "divc", "minc", "maxc", "mod"} 21 22 void *Arithdays(void *argument); 23 #define ArithdaysOperators {"muldpm", "divdpm", "muldpy", "divdpy", "muldoy"} 24 25 void *Arithlat(void *argument); 26 #define ArithlatOperators {"mulcoslat", "divcoslat"} 27 28 void *Cat(void *argument); 29 #define CatOperators {"cat"} 30 31 void *CDItest(void *argument); 32 #define CDItestOperators {"ncopy"} 33 34 void *CDIread(void *argument); 35 #define CDIreadOperators {"cdiread"} 36 37 void *CDIwrite(void *argument); 38 #define CDIwriteOperators {"cdiwrite"} 39 40 void *Change(void *argument); 41 #define ChangeOperators {"chcode", "chtabnum", "chparam", "chname", "chunit", "chlevel", "chlevelc", "chlevelv", "chltype"} 42 43 void *Change_e5slm(void *argument); 44 #define Change_e5slmOperators {"change_e5slm", "change_e5lsm", "change_e5mask"} 45 46 void *Cloudlayer(void *argument); 47 #define CloudlayerOperators {"cloudlayer"} 48 49 void *CMOR(void *argument); 50 #define CMOROperators {"cmor"} 51 52 void *CMOR_lite(void *argument); 53 #define CMORliteOperators {"cmorlite"} 54 55 void *CMOR_table(void *argument); 56 #define CMORtableOperators {"dump_cmor_table", "conv_cmor_table"} 57 58 void *Collgrid(void *argument); 59 #define CollgridOperators {"collgrid"} 60 61 void *Command(void *argument); 62 #define CommandOperators {"command", "com", "cmd"} 63 64 void *Comp(void *argument); 65 #define CompOperators {"eq", "ne", "le", "lt", "ge", "gt"} 66 67 void *Compc(void *argument); 68 #define CompcOperators {"eqc", "nec", "lec", "ltc", "gec", "gtc"} 69 70 void *Complextorect(void *argument); 71 #define ComplextorectOperators {"complextorect", "complextopol"} 72 73 void *Cond(void *argument); 74 #define CondOperators {"ifthen", "ifnotthen"} 75 76 void *Cond2(void *argument); 77 #define Cond2Operators {"ifthenelse"} 78 79 void *Condc(void *argument); 80 #define CondcOperators {"ifthenc", "ifnotthenc"} 81 82 void *Consecstat(void *argument); 83 #define ConsecstatOperators {"consects", "consecsum"} 84 85 void *Copy(void *argument); 86 #define CopyOperators {"copy", "selall", "szip"} 87 88 void *DCW_util(void *argument); 89 #define DCW_utilOperators {"dcw"} 90 91 void *Deltat(void *argument); 92 #define DeltatOperators {"deltat", "timederivative"} 93 94 void *Deltime(void *argument); 95 #define DeltimeOperators {"delday", "del29feb"} 96 97 void *Depth(void *argument); 98 #define DepthOperators {"zsdepth"} 99 100 void *Derivepar(void *argument); 101 #define DeriveparOperators {"gheight", "sealevelpressure"} 102 103 void *Detrend(void *argument); 104 #define DetrendOperators {"detrend"} 105 106 void *Diff(void *argument); 107 #define DiffOperators {"diff", "diffp", "diffn", "diffc"} 108 109 void *Distgrid(void *argument); 110 #define DistgridOperators {"distgrid"} 111 112 void *Duplicate(void *argument); 113 #define DuplicateOperators {"duplicate"} 114 115 void *Enlarge(void *argument); 116 #define EnlargeOperators {"enlarge"} 117 118 void *Enlargegrid(void *argument); 119 #define EnlargegridOperators {"enlargegrid"} 120 121 void *Ensstat(void *argument); 122 #define EnsstatOperators {"ensrange", "ensmin", "ensmax", "enssum", "ensmean", "ensavg", "ensvar", "ensvar1", "ensstd", "ensstd1", "ensskew", "enskurt", "ensmedian", "enspctl"} 123 124 void *Ensstat3(void *argument); 125 #define Ensstat3Operators {"ensrkhistspace", "ensrkhisttime", "ensroc"} 126 127 void *Ensval(void *argument); 128 #define EnsvalOperators {"enscrps", "ensbrs"} 129 130 void *Eofcoeff(void *argument); 131 #define EofcoeffOperators {"eofcoeff"} 132 133 void *Eofcoeff3d(void *argument); 134 #define Eofcoeff3dOperators {"eofcoeff3d"} 135 136 void *EOFs(void *argument); 137 #define EOFsOperators {"eof", "eofspatial", "eoftime"} 138 139 void *EOF3d(void *argument); 140 #define EOF3dOperators {"eof3d","eof3dspatial","eof3dtime"} 141 142 void *EstFreq(void *argument); 143 #define EstFreqOperators {"estfreq"} 144 145 void *Expr(void *argument); 146 #define ExprOperators {"expr", "exprf", "aexpr", "aexprf"} 147 148 void *FC(void *argument); 149 #define FCOperators {"fc2sp", "sp2fc", "fc2gp", "gp2fc", "fourier2grid", "grid2fourier"} 150 151 void *Filedes(void *argument); 152 #define FiledesOperators {"filedes", "griddes", "griddes2", "zaxisdes", "vct", "vct2", "codetab", "vlist", "partab", "partab2", "spartab"} 153 154 void *Fillmiss(void *argument); 155 #define FillmissOperators {"fillmiss", "fillmiss2"} 156 157 void *Filter(void *argument); 158 #define FilterOperators {"bandpass", "highpass", "lowpass"} 159 160 void *Fldrms(void *argument); 161 #define FldrmsOperators {"fldrms"} 162 163 void *Fldstat(void *argument); 164 #define FldstatOperators {"fldrange", "fldmin", "fldmax", "fldsum", "fldint", "fldmean", "fldavg", "fldstd", "fldstd1", "fldvar", "fldvar1", "fldskew", "fldkurt", "fldmedian", "fldpctl"} 165 166 void *Fldstat2(void *argument); 167 #define FldcorOperators {"fldcor"} 168 #define FldcovarOperators {"fldcovar"} 169 170 void *Fourier(void *argument); 171 #define FourierOperators {"fourier"} 172 173 void *Gengrid(void *argument); 174 #define GengridOperators {"gengrid"} 175 176 void *Gradsdes(void *argument); 177 #define GradsdesOperators {"gradsdes", "dumpmap"} 178 179 void *Gridboxstat(void *argument); 180 #define GridboxstatOperators {"gridboxrange", "gridboxmin", "gridboxmax", "gridboxsum", "gridboxmean", "gridboxavg", "gridboxstd", "gridboxstd1", "gridboxvar", "gridboxvar1", "gridboxskew", "gridboxkurt", "gridboxmedian"} 181 182 void *Gridcell(void *argument); 183 #define GridcellOperators {"gridarea", "gridweights", "gridmask", "griddx", "griddy", "gridcellidx"} 184 185 void *Gridsearch(void *argument); 186 #define GridsearchOperators {"testpointsearch", "testcellsearch"} 187 188 void *Harmonic(void *argument); 189 #define HarmonicOperators {"harmonic"} 190 191 void *Histogram(void *argument); 192 #define HistogramOperators {"histcount", "histsum", "histmean", "histfreq"} 193 194 void *Importamsr(void *argument); 195 #define ImportamsrOperators {"import_amsr"} 196 197 void *Importbinary(void *argument); 198 #define ImportbinaryOperators {"import_binary"} 199 200 void *Importcmsaf(void *argument); 201 #define ImportcmsafOperators {"import_cmsaf"} 202 203 void *Importobs(void *argument); 204 #define ImportobsOperators {"import_obs"} 205 206 void *Importfv3grid(void *argument); 207 #define Importfv3gridOperators {"import_fv3grid"} 208 209 void *Info(void *argument); 210 #define InfoOperators {"info", "infop", "infon", "infoc", "vinfon", "xinfon", "map"} 211 212 void *Input(void *argument); 213 #define InputOperators {"input", "inputsrv", "inputext"} 214 215 void *Intgrid(void *argument); 216 #define IntgridOperators {"intgridbil", "intgriddis", "intgridnn", "interpolate", "boxavg", "thinout"} 217 218 void *Intgridtraj(void *argument); 219 #define IntgridtrajOperators {"intgridtraj"} 220 221 void *Intlevel(void *argument); 222 #define IntlevelOperators {"intlevel", "intlevelx"} 223 224 void *Intlevel3d(void *argument); 225 #define Intlevel3dOperators {"intlevel3d", "intlevelx3d"} 226 227 void *Inttime(void *argument); 228 #define InttimeOperators {"inttime"} 229 230 void *Intntime(void *argument); 231 #define IntntimeOperators {"intntime"} 232 233 void *Intyear(void *argument); 234 #define IntyearOperators {"intyear"} 235 236 void *Invert(void *argument); 237 #define InvertOperators {"invertlat", "invertlon", "invertlatdes", "invertlondes", "invertlatdata", "invertlondata"} 238 239 void *Invertlev(void *argument); 240 #define InvertlevOperators {"invertlev"} 241 242 void *Lic(void *argument); 243 #define LicOperators {"lic"} 244 245 void *MapReduce(void *argument); 246 #define MapReduceOperators {"reducegrid"} 247 248 void *Maskbox(void *argument); 249 #define MaskboxOperators {"masklonlatbox", "maskindexbox"} 250 #define MaskregionOperators {"maskregion"} 251 252 void *Mastrfu(void *argument); 253 #define MastrfuOperators {"mastrfu"} 254 255 void *Math(void *argument); 256 #define MathOperators {"abs", "int", "nint", "sqr", "sqrt", "exp", "ln", "log10", "sin", "cos", "tan", "asin", "acos", "atan", "pow", "rand", "reci", "not", "conj", "re", "im", "arg"} 257 258 void *Merge(void *argument); 259 #define MergeOperators {"merge"} 260 261 void *Mergegrid(void *argument); 262 #define MergegridOperators {"mergegrid"} 263 264 void *Mergetime(void *argument); 265 #define MergetimeOperators {"mergetime"} 266 267 void *Merstat(void *argument); 268 #define MerstatOperators {"merrange", "mermin", "mermax", "mersum", "mermean", "meravg", "merstd", "merstd1", "mervar", "mervar1", "merskew", "merkurt", "mermedian", "merpctl"} 269 270 void *Monarith(void *argument); 271 #define MonarithOperators {"monadd", "monsub", "monmul", "mondiv"} 272 273 void *Mrotuv(void *argument); 274 #define MrotuvOperators {"mrotuv"} 275 276 void *Mrotuvb(void *argument); 277 #define MrotuvbOperators {"mrotuvb"} 278 279 void *NCL_wind(void *argument); 280 #define NCL_windOperators {"uv2dv_cfd", "uv2vr_cfd"} 281 282 void *Ninfo(void *argument); 283 #define NinfoOperators {"nyear", "nmon", "ndate", "ntime", "ncode", "npar", "nlevel", "ngridpoints", "ngrids"} 284 285 void *Nmldump(void *argument); 286 #define NmldumpOperators {"nmldump", "kvldump"} 287 288 void *Output(void *argument); 289 #define OutputOperators {"output", "outputint", "outputsrv", "outputext", "outputf", "outputts", "outputfld", "outputarr", "outputxyz"} 290 #define OutputtabOperators {"outputtab"} 291 292 void *Outputgmt(void *argument); 293 #define OutputgmtOperators {"gmtxyz", "gmtcells", "outputcenter2", "outputcentercpt", "outputboundscpt", "outputvector", "outputtri", "outputvrml"} 294 295 void *Pack(void *argument); 296 #define PackOperators {"pack"} 297 298 void *Pardup(void *argument); 299 #define PardupOperators {"pardup", "parmul"} 300 301 void *Pinfo(void *argument); 302 #define PinfoOperators {"pinfo", "pinfov"} 303 304 void *Pressure(void *argument); 305 #define PressureOperators {"pressure_fl", "pressure_hl", "deltap"} 306 307 void *Recttocomplex(void *argument); 308 #define RecttocomplexOperators {"recttocomplex"} 309 310 void *Regres(void *argument); 311 #define RegresOperators {"regres"} 312 313 void *Remap(void *argument); 314 #define RemapOperators {"remap"} 315 #define RemapbilOperators {"remapbil", "genbil"} 316 #define RemapbicOperators {"remapbic", "genbic"} 317 #define RemapnnOperators {"remapnn", "gennn"} 318 #define RemapdisOperators {"remapdis", "gendis"} 319 #define RemapconOperators {"remapcon", "gencon"} 320 #define Remapycon2Operators {"remapycon2test", "genycon2test"} 321 #define RemapsconOperators {"remapscon", "genscon"} 322 #define Remapcon2Operators {"remapcon2", "gencon2"} 323 #define RemaplafOperators {"remaplaf", "genlaf"} 324 #define RemapavgOperators {"remapavgtest"} 325 326 void *Remapweights(void *argument); 327 #define RemapweightsOperators {"verifyweights", "writeremapscrip"} 328 329 void *Remapeta(void *argument); 330 #define RemapetaOperators {"remapeta", "remapeta_s", "remapeta_z"} 331 332 void *Remapstat(void *argument); 333 #define RemapstatOperators {"remaprange", "remapmin", "remapmax", "remapsum", "remapmean", "remapavg", "remapstd", "remapstd1", "remapvar", "remapvar1", "remapskew", "remapkurt", "remapmedian"} 334 335 void *Replace(void *argument); 336 #define ReplaceOperators {"replace"} 337 338 void *Replacevalues(void *argument); 339 #define ReplacevaluesOperators {"setvals", "setrtoc", "setrtoc2"} 340 341 void *Rotuv(void *argument); 342 #define RotuvOperators {"rotuvb"} 343 344 void *Rhopot(void *argument); 345 #define RhopotOperators {"rhopot"} 346 347 void *Runpctl(void *argument); 348 #define RunpctlOperators {"runpctl"} 349 350 void *Runstat(void *argument); 351 #define RunstatOperators {"runrange", "runmin", "runmax", "runsum", "runmean", "runavg", "runstd", "runstd1", "runvar", "runvar1"} 352 353 void *Samplegridicon(void *argument); 354 #define SamplegridiconOperators {"samplegridicon"} 355 356 void *Seascount(void *argument); 357 #define SeascountOperators {"seascount"} 358 359 void *Seaspctl(void *argument); 360 #define SeaspctlOperators {"seaspctl"} 361 362 void *Seasstat(void *argument); 363 #define SeasstatOperators {"seasrange", "seasmin", "seasmax", "seassum", "seasmean", "seasavg", "seasstd", "seasstd1", "seasvar", "seasvar1"} 364 365 void *Seasmonstat(void *argument); 366 #define SeasmonstatOperators {"seasmonmean", "seasmonavg"} 367 368 void *Selbox(void *argument); 369 #define SelboxOperators {"sellonlatbox", "selindexbox"} 370 371 void *Selgridcell(void *argument); 372 #define SelgridcellOperators {"selgridcell", "delgridcell"} 373 374 void *Select(void *argument); 375 #define SelectOperators {"select", "delete"} 376 377 void *Selvar(void *argument); 378 #define SelvarOperators {"selparam", "selcode", "selname", "selstdname", "sellevel", "sellevidx", "selgrid", "selzaxis", "selzaxisname", "seltabnum", "delparam", "delcode", "delname", "selltype"} 379 380 void *Seloperator(void *argument); 381 #define SeloperatorOperators {"seloperator"} 382 383 void *Selrec(void *argument); 384 #define SelrecOperators {"selrec"} 385 386 void *Selregion(void *argument); 387 #define SelregionOperators {"selcircle"} 388 389 void *Selsurface(void *argument); 390 #define SelsurfaceOperators {"isosurface", "bottomvalue", "topvalue"} 391 392 void *Seltime(void *argument); 393 #define SeltimeOperators {"seltimestep", "selyear", "selseason", "selmonth", "selday", "selhour", "seldate", "seltime", "selsmon"} 394 395 void *Selyearidx(void *argument); 396 #define SelyearidxOperators {"selyearidx", "seltimeidx"} 397 398 void *Set(void *argument); 399 #define SetOperators {"setcode", "setparam", "setname", "setunit", "setlevel", "setltype", "settabnum"} 400 401 void *Setattribute(void *argument); 402 #define SetattributeOperators {"setattribute"} 403 404 void *Setbox(void *argument); 405 #define SetboxOperators {"setclonlatbox", "setcindexbox"} 406 407 void *Setgrid(void *argument); 408 #define SetgridOperators {"setgrid", "setgridtype", "setgridarea", "setgridmask", "unsetgridmask", "setgridnumber", "setgriduri", "usegridnumber", "setprojparams"} 409 410 void *Setgridcell(void *argument); 411 #define SetgridcellOperators {"setgridcell"} 412 413 void *Sethalo(void *argument); 414 #define SethaloOperators {"sethalo", "tpnhalo"} 415 416 void *Setmiss(void *argument); 417 #define SetmisstonnOperators {"setmisstonn", "setmisstodis"} 418 419 #define SetmissOperators {"setmissval", "setctomiss", "setmisstoc", "setrtomiss", "setvrange"} 420 void *Setpartab(void *argument); 421 422 #define SetpartabOperators {"setpartabc", "setpartabp", "setpartabn"} 423 #define SetcodetabOperators {"setcodetab"} 424 425 void *Setrcaname(void *argument); 426 #define SetrcanameOperators {"setrcaname"} 427 428 void *Settime(void *argument); 429 #define SettimeOperators {"setyear", "setmon", "setday", "setdate", "settime", "settunits", "settaxis", "settbounds", "setreftime", "setcalendar", "shifttime"} 430 431 void *Setzaxis(void *argument); 432 #define SetzaxisOperators {"setzaxis", "genlevelbounds"} 433 434 void *Shiftxy(void *argument); 435 #define ShiftxyOperators {"shiftx", "shifty"} 436 437 void *Showinfo(void *argument); 438 #define ShowinfoOperators {"showyear", "showmon", "showdate", "showtime", "showtimestamp", "showcode", "showunit", "showparam", "showname", "showstdname", "showlevel", "showltype", "showformat", "showgrid", "showatts", "showattsglob"} 439 440 void *Showattribute(void *argument); 441 #define ShowattributeOperators {"showattribute", "showattsvar"} 442 443 void *Sinfo(void *argument); 444 #define SinfoOperators {"sinfo", "sinfop", "sinfon", "sinfoc", "seinfo", "seinfop", "seinfon", "seinfoc", "xsinfo", "xsinfop", "xsinfon", "xsinfoc"} 445 446 void *Smooth(void *argument); 447 #define SmoothOperators {"smooth", "smooth9"} 448 449 void *Sort(void *argument); 450 #define SortOperators {"sortcode", "sortparam", "sortname", "sortlevel"} 451 452 void *Sorttimestamp(void *argument); 453 #define SorttimestampOperators {"sorttimestamp", "sorttaxis"} 454 455 void *Specinfo(void *argument); 456 #define SpecinfoOperators {"specinfo"} 457 458 void *Spectral(void *argument); 459 #define SpectralOperators {"gp2sp", "gp2spl", "sp2gp", "sp2gpl"} 460 #define SpecconvOperators {"sp2sp", "spcut"} 461 462 void *Spectrum(void *argument); 463 #define SpectrumOperators {"spectrum"} 464 465 void *Split(void *argument); 466 #define SplitOperators {"splitcode", "splitparam", "splitname", "splitlevel", "splitgrid", "splitzaxis", "splittabnum"} 467 468 void *Splitrec(void *argument); 469 #define SplitrecOperators {"splitrec"} 470 471 void *Splitsel(void *argument); 472 #define SplitselOperators {"splitsel"} 473 474 void *Splittime(void *argument); 475 #define SplittimeOperators {"splithour", "splitday", "splitmon", "splitseas"} 476 477 void *Splityear(void *argument); 478 #define SplityearOperators {"splityear", "splityearmon"} 479 480 void *Tee(void *argument); 481 #define TeeOperators {"tee"} 482 483 void *Template1(void *argument); 484 #define Template1Operators {"template1"} 485 486 void *Template2(void *argument); 487 #define Template2Operators {"template2"} 488 489 void *Test(void *argument); 490 #define TestOperators {"test"} 491 492 void *Test2(void *argument); 493 #define Test2Operators {"test2"} 494 495 void *Testdata(void *argument); 496 #define TestdataOperators {"testdata"} 497 498 void *Tests(void *argument); 499 #define TestsOperators {"normal", "studentt", "chisquare", "beta", "fisher"} 500 501 void *Timsort(void *argument); 502 #define TimsortOperators {"timsort"} 503 504 void *Timcount(void *argument); 505 #define TimcountOperators {"timcount"} 506 #define YearcountOperators {"yearcount"} 507 #define MoncountOperators {"moncount"} 508 #define DaycountOperators {"daycount"} 509 #define HourcountOperators {"hourcount"} 510 511 void *Timcumsum(void *argument); 512 #define TimcumsumOperators {"timcumsum"} 513 514 void *Timpctl(void *argument); 515 #define TimpctlOperators {"timpctl"} 516 #define YearpctlOperators {"yearpctl"} 517 #define MonpctlOperators {"monpctl"} 518 #define DaypctlOperators {"daypctl"} 519 #define HourpctlOperators {"hourpctl"} 520 521 void *Timselpctl(void *argument); 522 #define TimselpctlOperators {"timselpctl"} 523 524 void *Timselstat(void *argument); 525 #define TimselstatOperators {"timselrange", "timselmin", "timselmax", "timselsum", "timselmean", "timselavg", "timselvar", "timselvar1", "timselstd", "timselstd1"} 526 527 void *XTimstat(void *argument); 528 #define XTimstatOperators {"xtimmin", "xtimmax", "xtimsum", "xtimmean", "xtimavg", "xtimvar", "xtimvar1", "xtimstd", "xtimstd1", "xyearmin", "xyearmax", "xyearsum","xyearmean", "xyearavg", "xyearvar", "xyearvar1", "xyearstd", "xyearstd1", "xmonmin", "xmonmax", "xmonsum", "xmonmean", "xmonavg", "xmonvar", "xmonvar1", "xmonstd", "xmonstd1"} 529 530 void *Timstat(void *argument); 531 #define TimstatOperators {"timrange", "timmin", "timmax", "timsum", "timmean", "timavg", "timvar", "timvar1", "timstd", "timstd1", "timminidx", "timmaxidx"} 532 #define YearstatOperators {"yearrange", "yearmin", "yearmax", "yearsum", "yearmean", "yearavg", "yearvar", "yearvar1", "yearstd", "yearstd1", "yearminidx", "yearmaxidx"} 533 #define MonstatOperators {"monrange", "monmin", "monmax", "monsum", "monmean", "monavg", "monvar", "monvar1", "monstd", "monstd1"} 534 #define DaystatOperators {"dayrange", "daymin", "daymax", "daysum", "daymean", "dayavg", "dayvar", "dayvar1", "daystd", "daystd1"} 535 #define HourstatOperators {"hourrange", "hourmin", "hourmax", "hoursum", "hourmean", "houravg", "hourvar", "hourvar1", "hourstd", "hourstd1"} 536 537 void *Timstat2(void *argument); 538 #define TimcorOperators {"timcor"} 539 #define TimcovarOperators {"timcovar"} 540 #define TimrmsdOperators {"timrmsd"} 541 542 void *Timstat3(void *argument); 543 #define Timstat3Operators {"meandiff2test", "varquot2test"} 544 545 void *Tinfo(void *argument); 546 #define TinfoOperators {"tinfo"} 547 548 void *Tocomplex(void *argument); 549 #define TocomplexOperators {"retocomplex", "imtocomplex"} 550 551 void *Transpose(void *argument); 552 #define TransposeOperators {"transxy"} 553 554 void *Trend(void *argument); 555 #define TrendOperators {"trend"} 556 557 void *Trendarith(void *argument); 558 #define TrendarithOperators {"addtrend", "subtrend"} 559 560 void *Tstepcount(void *argument); 561 #define TstepcountOperators {"tstepcount"} 562 563 void *Unpack(void *argument); 564 #define UnpackOperators {"unpack"} 565 566 void *Vargen(void *argument); 567 #define VargenOperators {"random", "const", "sincos", "coshill", "testfield", "seq", "topo", "temp", "mask", "stdatm"} 568 569 void *Varrms(void *argument); 570 #define VarrmsOperators {"varrms"} 571 572 void *Varsstat(void *argument); 573 #define VarsstatOperators {"varsrange", "varsmin", "varsmax", "varssum", "varsmean", "varsavg", "varsstd", "varsstd1", "varsvar", "varsvar1"} 574 575 void *Vertintap(void *argument); 576 #define VertintapOperators {"ap2pl", "ap2plx", "ap2pl_lp", "ap2plx_lp", "ap2hl", "ap2hlx"} 577 578 void *Vertintgh(void *argument); 579 #define VertintghOperators {"gh2hl", "gh2hlx"} 580 581 void *Vertintml(void *argument); 582 #define VertintmlOperators {"ml2pl", "ml2hl", "ml2plx", "ml2hlx", "ml2pl_lp", "ml2hl_lp", "ml2plx_lp", "ml2hlx_lp"} 583 584 void *Vertintzs(void *argument); 585 #define VertintzsOperators {"zs2zl", "zs2zlx"} 586 587 void *Vertstat(void *argument); 588 #define VertstatOperators {"vertrange", "vertmin", "vertmax", "vertsum", "vertint", "vertmean", "vertavg", "vertstd", "vertstd1", "vertvar", "vertvar1"} 589 590 void *Vertcum(void *argument); 591 #define VertcumOperators {"vertcum", "vertcumhl"} 592 593 void *Vertwind(void *argument); 594 #define VertwindOperators {"vertwind"} 595 596 void *Verifygrid(void *argument); 597 #define VerifygridOperators {"verifygrid"} 598 599 void *Wind(void *argument); 600 #define WindOperators {"uv2dv", "uv2dvl", "dv2uv", "dv2uvl"} 601 602 #define Wind2Operators {"dv2ps"} 603 void *Writegrid(void *argument); 604 605 #define WritegridOperators {"writegrid"} 606 void *Writerandom(void *argument); 607 608 #define WriterandomOperators {"writerandom"} 609 void *YAR(void *argument); 610 611 void *Yeararith(void *argument); 612 #define YeararithOperators {"yearadd", "yearsub", "yearmul", "yeardiv"} 613 614 void *Yearmonstat(void *argument); 615 #define YearmonstatOperators {"yearmonmean", "yearmonavg"} 616 617 void *Ydayarith(void *argument); 618 #define YdayarithOperators {"ydayadd", "ydaysub", "ydaymul", "ydaydiv"} 619 620 void *Ydaypctl(void *argument); 621 #define YdaypctlOperators {"ydaypctl"} 622 623 void *Ydaystat(void *argument); 624 #define YdaystatOperators {"ydayrange", "ydaymin", "ydaymax", "ydaysum", "ydaymean", "ydayavg", "ydaystd", "ydaystd1", "ydayvar", "ydayvar1"} 625 626 void *Ydrunpctl(void *argument); 627 #define YdrunpctlOperators {"ydrunpctl"} 628 629 void *Ydrunstat(void *argument); 630 #define YdrunstatOperators {"ydrunmin", "ydrunmax", "ydrunsum", "ydrunmean", "ydrunavg", "ydrunstd", "ydrunstd1", "ydrunvar", "ydrunvar1"} 631 632 void *Yhourarith(void *argument); 633 #define YhourarithOperators {"yhouradd", "yhoursub", "yhourmul", "yhourdiv"} 634 635 void *Yhourstat(void *argument); 636 #define YhourstatOperators {"yhourrange", "yhourmin", "yhourmax", "yhoursum", "yhourmean", "yhouravg", "yhourstd", "yhourstd1", "yhourvar", "yhourvar1"} 637 #define DhourstatOperators {"dhourrange", "dhourmin", "dhourmax", "dhoursum", "dhourmean", "dhouravg", "dhourstd", "dhourstd1", "dhourvar", "dhourvar1"} 638 639 void *Ymonarith(void *argument); 640 #define YmonarithOperators {"ymonadd", "ymonsub", "ymonmul", "ymondiv"} 641 #define YseasarithOperators {"yseasadd", "yseassub", "yseasmul", "yseasdiv"} 642 643 void *Ymonpctl(void *argument); 644 #define YmonpctlOperators {"ymonpctl"} 645 646 void *Ymonstat(void *argument); 647 #define YmonstatOperators {"ymonrange", "ymonmin", "ymonmax", "ymonsum", "ymonmean", "ymonavg", "ymonstd", "ymonstd1", "ymonvar", "ymonvar1"} 648 649 void *Yseaspctl(void *argument); 650 #define YseaspctlOperators {"yseaspctl"} 651 652 void *Yseasstat(void *argument); 653 #define YseasstatOperators {"yseasrange", "yseasmin", "yseasmax", "yseassum", "yseasmean", "yseasavg", "yseasstd", "yseasstd1", "yseasvar", "yseasvar1"} 654 655 void *Zonstat(void *argument); 656 #define ZonstatOperators {"zonrange", "zonmin", "zonmax", "zonsum", "zonmean", "zonavg", "zonstd", "zonstd1", "zonvar", "zonvar1", "zonskew", "zonkurt", "zonmedian", "zonpctl"} 657 658 //------------------------------ 659 660 void *EcaCfd(void *argument); 661 #define EcaCfdOperators {"eca_cfd"} 662 void *EcaCsu(void *argument); 663 #define EcaCsuOperators {"eca_csu"} 664 void *EcaCwdi(void *argument); 665 #define EcaCwdiOperators {"eca_cwdi"} 666 void *EcaCwfi(void *argument); 667 #define EcaCwfiOperators {"eca_cwfi", "etccdi_csdi"} 668 void *EcaEtr(void *argument); 669 #define EcaEtrOperators {"eca_etr"} 670 void *EcaFd(void *argument); 671 #define EcaFdOperators {"eca_fd", "etccdi_fd"} 672 void *EcaGsl(void *argument); 673 #define EcaGslOperators {"eca_gsl", "etccdi_gsl"} 674 void *EcaHd(void *argument); 675 #define EcaHdOperators {"eca_hd", "etccdi_hd"} 676 void *EcaHwdi(void *argument); 677 #define EcaHwdiOperators {"eca_hwdi"} 678 void *EcaHwfi(void *argument); 679 #define EcaHwfiOperators {"eca_hwfi", "etccdi_wsdi"} 680 void *EcaId(void *argument); 681 #define EcaIdOperators {"eca_id", "etccdi_id"} 682 void *EcaSu(void *argument); 683 #define EcaSuOperators {"eca_su", "etccdi_su"} 684 void *EcaTr(void *argument); 685 #define EcaTrOperators {"eca_tr", "etccdi_tr"} 686 void *EcaTg10p(void *argument); 687 #define EcaTg10pOperators {"eca_tg10p"} 688 void *EcaTg90p(void *argument); 689 #define EcaTg90pOperators {"eca_tg90p"} 690 void *EcaTn10p(void *argument); 691 #define EcaTn10pOperators {"eca_tn10p"} 692 void *EcaTn90p(void *argument); 693 #define EcaTn90pOperators {"eca_tn90p"} 694 void *EcaTx10p(void *argument); 695 #define EcaTx10pOperators {"eca_tx10p"} 696 void *EcaTx90p(void *argument); 697 #define EcaTx90pOperators {"eca_tx90p"} 698 void *EcaCdd(void *argument); 699 #define EcaCddOperators {"eca_cdd", "etccdi_cdd"} 700 void *EcaCwd(void *argument); 701 #define EcaCwdOperators {"eca_cwd", "etccdi_cwd"} 702 void *EcaRr1(void *argument); 703 #define EcaRr1Operators {"eca_rr1"} 704 void *EcaPd(void *argument); 705 #define EcaPdOperators {"eca_pd", "eca_r10mm", "eca_r20mm", "etccdi_r1mm", "etccdi_r10mm", "etccdi_r20mm"} 706 void *EcaR75p(void *argument); 707 #define EcaR75pOperators {"eca_r75p"} 708 void *EcaR75ptot(void *argument); 709 #define EcaR75ptotOperators {"eca_r75ptot"} 710 void *EcaR90p(void *argument); 711 #define EcaR90pOperators {"eca_r90p"} 712 void *EcaR90ptot(void *argument); 713 #define EcaR90ptotOperators {"eca_r90ptot"} 714 void *EcaR95p(void *argument); 715 #define EcaR95pOperators {"eca_r95p"} 716 void *EcaR95ptot(void *argument); 717 #define EcaR95ptotOperators {"eca_r95ptot"} 718 void *EcaR99p(void *argument); 719 #define EcaR99pOperators {"eca_r99p"} 720 void *EcaR99ptot(void *argument); 721 #define EcaR99ptotOperators {"eca_r99ptot"} 722 void *EcaRx1day(void *argument); 723 #define EcaRx1dayOperators {"eca_rx1day", "etccdi_rx1day", "etccdi_rx1daymon"} 724 void *EcaRx5day(void *argument); 725 #define EcaRx5dayOperators {"eca_rx5day", "etccdi_rx5day", "etccdi_rx5daymon"} 726 void *EcaSdii(void *argument); 727 #define EcaSdiiOperators {"eca_sdii", "etccdi_sdii"} 728 void *EcaEtccdi(void *argument); 729 #define EcaEtccdiOperators {"etccdi_tx90p","etccdi_tx10p","etccdi_tn90p","etccdi_tn10p","etccdi_r95p","etccdi_r99p","etccdi"} 730 731 void *Fdns(void *argument); 732 #define FdnsOperators {"fdns"} 733 734 void *Strwin(void *argument); 735 #define StrwinOperators {"strwin"} 736 void *Strbre(void *argument); 737 #define StrbreOperators {"strbre"} 738 void *Strgal(void *argument); 739 #define StrgalOperators {"strgal"} 740 void *Hurr(void *argument); 741 #define HurrOperators {"hurr"} 742 743 // void *Hi(void *argument); 744 //#define HiOperators {"hi"} 745 void *Wct(void *argument); 746 #define WctOperators {"wct"} 747 748 void *Magplot(void *argument); 749 #define MagplotOperators {"contour", "shaded", "grfill"} 750 void *Magvector(void *argument); 751 #define MagvectorOperators {"vector"} 752 void *Maggraph(void *argument); 753 #define MaggraphOperators {"graph"} 754 755 //------------------------------ 756 // HIRLAM_EXTENSIONS 757 void *Selmulti(void *argument); // "selmulti", "delmulti" 758 #define SelmultiOperators {"selmulti", "delmulti", "changemulti"} 759 void *WindTrans(void *argument); // "uvDestag", "rotuvN", "rotuvNorth", "projuvLatLon" 760 #define WindTransOperators {"uvDestag", "rotuvN", "rotuvNorth", "projuvLatLon"} 761 void *Samplegrid(void *argument); // "samplegrid", "subgrid" 762 #define SamplegridOperators {"samplegrid", "subgrid"} 763 764 // clang-format on 765 /* \endcond */ 766 #endif 767