| BLD | -operator- |
|---|---|
| BLD | { getmissing_value? not { null } if } |
| BLD | { arraylevel 1 sub /arraylevel STREAM ! } |
| BLD | { history null ne { history dup elementtype /arraytype eq { aload length 1 add dup 1 add -1 roll exch } { exch 2 } ifelse array astore } if /history exch def } |
| BLD | { array astore [ exch { history null eq fullname null eq or { pop } if } forall ] dup length 0 eq { pop null } { dup 0 get .history true 2 index { .history 2 index stringarrayeq and } forall { pop 0 get sealhistory .history } { pop [ exch { longname history 2 array astore exch pop } forall ] } ifelse } ifelse } |
| BLD | 0.0 |
| BLD | { history null ne { history elementtype /arraytype eq { history dup length 1 sub get elementtype /arraytype ne { /history [ 0 history { dup type /arraytype ne { exch 1 add } { exch pop 0 } ifelse } forall dup 0 eq { pop } { array astore longname exch } ifelse ] def } if } if } if } |
| BLD | null |
| BLD | ({[() |
| BLD | { 1 index 2 add copy pop array astore true exch { safeifGRID nip and } forall { pop { pop } repeat null } { combinefullname } ifelse } |
| BLD | /==alias |
| BLD | { currentobject /scale_factor getknown } |
| BLD | { dup elementtype /arraytype eq { dup length 2 eq { dup 1 get type /arraytype eq { space exch aload length 1 add space exch { dolongname0 exch dolongname0 exch space exch append append } repeat } { dolongnamearray } ifelse } { dolongnamearray } ifelse } { cvx s== } ifelse } |
| BLD | { arraylevel 1 add /arraylevel STREAM ! } |
| BLD | { currentobject /add_offset getknown } |
| BLD | { currentobject /missing_value getknownnotnull } |
| BLD | { dup elementtype /arraytype eq { dup length 0 gt { aload length 1 sub { dolongname0 exch dolongname0 exch space exch append append } repeat dolongname } { pop } ifelse } { cvx s== } ifelse } |
| BLD | { currentobject /dataset known { dataset null eq { null } { dataset dup type /arraytype eq { pop null } { history nip } ifelse } ifelse } { null } ifelse } |
| BLD | null |
| BLD | { rights arraylevel rights length mod 1 getinterval } |
| BLD | { dup /long_name known { fullname type /arraytype eq { fullname dup length 1 sub get name eq { 1 object /fullname [ fullname maybealoadpop pop long_name ] def } if } if } if tofullname } |
| BLD | { lefts arraylevel lefts length mod 1 getinterval } |
| BLD | (}])) |
| BLD | { getadd_offset? { 0.0 eq { /add_offset undef } if } if getscale_factor? { 1.0 eq { /scale_factor undef } if } if currentobject /missing_value getknown { null eq { /missing_value undef } if } if currentobject /units known { units timeunits? nip { currentobject /calendar known not { get_calendar /calendar exch def } if currentobject /modulus known not { get_modulus dup null eq { pop } { /modulus exch def } ifelse } if currentobject /modulus known { /modulo modulus def } if } if } if } |
| BLD | { currentobject /missing_value knownnotnull } |
| BLD | { getscale_factor? not { 1.0 } { exec dup type /stringtype eq { interp } if } ifelse } |
| BLD | { fullname dolongname } |
| BLD | { name cvlit } |
| BLD | 1.0 |
| BLD | { getadd_offset? not { 0.0 } { exec dup type /stringtype eq { interp } if } ifelse } |
| BLD | { dup type /arraytype eq { 1 index type /arraytype eq { 1 index length 1 index length eq { true 0 1 3 index length 1 sub { 3 index 1 index get 3 index 2 index get stringarrayeq nip and } for nip nip } { pop pop false } ifelse } { pop pop false } ifelse } { eq } ifelse } |
| BLD | { pusharraylevel getleft exch aload length 1 add getright exch { dolongname0 exch dolongname0 exch space exch append append } repeat poparraylevel } |
| BLD | { -1 (,) combinefullname } |
| BLD | 0 |
| BLD | (1PG13.6) |
| BLD | { 2 combinehistory } |
| BLD | { ndim 1 eq { dup /buffer get GRIDParent /buffer get eq } { false } ifelse } |
| BLD | { realorintegertype? not { 0.0 } if 1 index totype /gridtype ne { T exch } if 3 /monthlyAverage publicproc: 2 array astore cvx newmonthlyAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { rootmeansqanomover } |
| BLD | { { complementgridarray /rootmeansqanom0 (root mean sq anom) apply1get12scr } /rootmeansqover gridarray1fn } |
| BLD | { 5 /seasonalnonoverlapWSfreq publicproc: { mystream monrange wslength thold minfrac } inputs mystream a: dataflag T monthlyAverage minfrac masklt T monrange 1.0 seasonalAverage :a: -999 replaceNaN thold flaggt [ T ] integral dup T wslength shiftGRID [ T ] regridLB sub wslength wslength flagrange [ T ] differences 1 1 flagrange T sums T (0000 1) VALUES [ T ] differences T (months since 1960-01-01) streamgridunitconvert T monrange 1.0 seasonalAverage monrange (-) search { nip pop } if 0 3 getinterval interp monrange (-) search { nip nip } if 0 3 getinterval interp sub dup 0 ge { 1 add } { 1 add 12 add } ifelse mul :a mul :publicproc nip } |
| BLD | { 1 /STEP0 /STEP allstreams1 } |
| BLD | { 3 index totype /arraytype ne { [ 4 index { pop } { } foralldatasets2 ] 4 1 roll } if 5 1 roll { mydataset variablesproc spatialgrids timegrids } inputs mydataset totype /streamtype eq { mydataset decompress /mydataset exch def } if /gappy-data? gappy-data? def /spatial-mean? spatial-mean? def /temporal-mean? temporal-mean? def nip /mixedarray currentobject /variablesproc get xcheck { mydataset dup totype /streamtype eq { [ exch variablesproc ] } { [ variablesproc ] nip } ifelse } { variablesproc } ifelse def /weights [ mixedarray { timegrids 0 get gridnobyname 0 gt { pop } if } forall ] def /variablesarray [ mixedarray { timegrids 0 get gridnobyname 0 eq { pop } if } forall ] def weights length variablesarray length 1 add eq { weights 0 1 index length 1 sub getinterval { weights dup length 1 sub get mul } forall weights 0 1 index length 1 sub getinterval astore } if variablesarray length 1 gt { (Sorry, svd is not yet ready for multiple variables. Let Benno) print ( know that you are interested, and you can test it when it is ready. ) print error } if /repeatgrids [ variablesarray 0 get spatialgrids aload pop timegrids aload length spatialgrids length add REORDER0 .achunk pop ] def 1 spatialgrids { .npts mul } forall 1 timegrids { .npts mul } forall le { /rgrids spatialgrids def /avgrids timegrids def } { /rgrids timegrids def /avgrids spatialgrids def } ifelse variablesarray 0 get ndim rgrids { gridno imin } forall 1 sub dup 0 gt { RECHUNK .chunk array astore /avchunkgrids exch def } { pop pop /avchunkgrids [ ] def } ifelse /avchunkcheck null 5 object avchunkgrids { name exch def } forall repeatgrids { .name undef } forall def [ avchunkgrids { avchunkcheck 1 index .name known not { pop } if } forall ] /avchunkgrids exch def /avachunkgrids [ avgrids { avchunkcheck name known { pop } if } forall ] def variablesarray 0 get weights length 0 gt { weights 0 get 0 max /valid_min 0 def sqrt mul 1100021758 set_code_last_modified } if avchunkgrids aload pop rgrids aload pop avachunkgrids aload pop avgrids length rgrids length add REORDER0 avchunkgrids length rgrids length add RECHUNK toNaN 1 avchunkgrids { .npts mul } forall 1 rgrids { .npts mul } forall 1 avgrids { .npts mul } forall 2 index idiv 1 4 integerarray astore missing_value null eq { covarnonan0 STREAM TaskParameterBlock 1 get dup 1 add mul 2 div NewIntegerBuffer pop STREAM 11 object /name /cov def /fullname [ /cov variablesarray 0 get .fullname dup type /arraytype ne { 1 array astore } if ] def /units variablesarray 0 get .units dup unitmul def /ISYMM dup TaskParameterBlock 1 get dup 1 add mul 2 div NewIntegerGRID def ISYMM .npts NewDoubleBuffer 1 SetStreamIndex* ISYMM avachunkgrids aload pop repeatgrids aload pop * avachunkgrids { last VALUE } forall avachunkgrids { removeGRID0 } forall /symmetricStorageMode compression: /symmetricchunk rgrids def :compression } { svdcovarcomp0 } ifelse DATASET 11 object /name /svd cvx def variablesarray 0 get /last_modified getknown { /last_modified exch def } if exch eigrs_and_vartot name 4 index ! nrdim 1 sub RECHUNK decompress ev .npts BufferOrder ev low high RANGE name 3 index ! /units TaskStreams 0 get .units def ev low high RANGE name exch def /fullname [ name variablesarray 0 get .fullname ] def rgrids { name exch def } forall avgrids { name exch def } forall eval .ev name exch def } |
| BLD | { mark ingridcachedir 2 index .allnames counttomark namearray astore nip cvnatofilename } |
| BLD | { (wcs) xmlprint } |
| BLD | { (figviewer) htmlprint } |
| BLD | { dup type /objecttype eq { allmyname /SELECT ne { 11 object proclevel 0 get 1 eq { /dataset currentobject parent def } if } if ifSTREAM { ifGRID { dup allgrid anyknowngrid { dup allargs aload pop allroutine } if } { dup allgrid anyknowngrid { dup allgridget allargs aload pop allroutine } { decompress dup allgrid anyknowngrid { dup allgridget allargs aload pop allroutine } if } ifelse } ifelse } { doallstreams } ifelse dup null ne { allmyname /SELECT ne { proclevel 0 get 1 eq { allgrid totype /datasettype eq { /dataset [ dataset allgrid ] def } if /myproc [ allgrid dup totype /datasettype eq { pop } if allargs aload pop allmyname cvx ] def /myprocds 1 index def sealobject } if } if } if } { pop pop } ifelse } |
| BLD | { 3 /WCT: publicproc: wctparams wctS new 100000 store d 111 store fN 16 store gN 0.1 store x 0.182 store r 600 store mu 1.229 store alphaexp 0.4 store betaexp 0.0 store C 36.5 store fu 9.8999996 store gu 1.26 store nu 0.4 store h 1.0 store k 0.4 store v } |
| BLD | FilterSet /streamtype { exch decompress exch 1 index /T known { getmissing_value null eq { pop monthlyAverage0 } { exch dup 0 replaceNaN monthlyAverage0 exch dataflag monthlyAverage0 3 -1 roll normalize } ifelse } { pop } ifelse } def /gridtype { pop name /T eq { monthlyedgesgrid partialgrid monthtimegrid } if } def |
| BLD | { 3 /RANGESTEP0 /RANGESTEP allstreams1 } |
| BLD | { { /rootmeansq0 (root mean sq) apply1get1 } /rootmeansq gridarray1fn } |
| BLD | { null 3 1 roll /dodefasvarsilentnoreuse cvx 4 array astore cvx dup 0 currentobject put dup 1 get exch pdef } |
| BLD | FilterSet /streamtype { 3 -1 roll decompress 3 1 roll 2 index 2 index .name getknown { exec 3 -1 roll pop exch 2 index .getmissing_value null eq { pop dailyAverage0 } { 3 1 roll 1 index 0 replaceNaN 1 index dailyAverage0 3 1 roll exch dataflag exch dailyAverage0 3 -1 roll normalize } ifelse } { pop pop } ifelse } def /gridtype { pop 1 index .name 1 index .name eq { pop dailyedgesgrid partialgrid } { pop } ifelse } def |
| BLD | { 1 copy type /arraytype eq { 2 /stddev publicproc: 2 copy rmsaover } { 3 /stddev publicproc: 3 copy rmsaover exch pop } ifelse 3 2 roll dataflag 3 -1 roll sum dup 1.0 sub div sqrt mul :publicproc } |
| BLD | FilterSet /streamtype { boxAveragedoarg 1 index boxgrids allknown { /boxgrids 2 index [ boxgrids { currentobject exch get } forall ] nip def 0 1 boxgrids length 1 sub { boxgrids 1 index get exch boxargs exch get ChangeGridStep name exch def } for exch boxgrids 1 index totype /gridtype eq { 1 index 1 index 0 get eq { pop .name exec } { pop } ifelse } { exch decompress exch boxargs dup length 1 sub get regridAverage } ifelse nip } { pop } ifelse } def /gridtype { boxAveragedoarg 1 index .name boxgrids anymatch { 0 1 boxgrids length 1 sub { boxgrids 1 index get name eq { boxargs exch get nip ChangeGridStep leave } { pop } ifelse } for } { pop } ifelse } def |
| BLD | { /evaln eval vartot div /name /evaln def /long_name (normalized eigenvalues) def def /sv eval sqrt /name /sv cvx def /long_name (singular values) def /units variablesarray 0 get .units def def evec rgrids timegrids eq { missing_value null eq { sv div /missing_value null def } { sv div } ifelse } { rgrids aload length REORDER0 CopyStream } ifelse variablesarray 0 get weights length 0 gt { weights 0 get 0 max /valid_min 0 def sqrt mul } if avchunkgrids aload pop rgrids aload pop avachunkgrids aload pop avgrids length rgrids length add REORDER0 avchunkgrids length rgrids length add RECHUNK toNaN exch rgrids mulavg DATAAUTO rgrids timegrids eq { weights length 0 gt { weights 0 get 0 max /valid_min 0 def sqrt div } if /name /Ss cvx def /long_name (structures) def correlationcolorscale DATA -4 4 RANGE name exch def /Ts evec sv mul /long_name (time series) def /name /Ts cvx def def } { /name /Ts cvx def /long_name (time series) def name exch def /Ts Ts streamgridarray { name /ev eq { pop } if } forall Ts .ndim 1 sub REORDER def /Ss evec weights length 0 gt { weights 0 get 0 max /valid_min 0 def sqrt div } { CopyStream } ifelse /name /Ss cvx def /long_name (structures) def correlationcolorscale DATA -4 4 RANGE def } ifelse weights length 0 gt { /W weights 0 get 0 max /valid_min 0 def /name /W def /long_name (weights) def def } if /eval undef /evec undef nip } |
| BLD | { array? { 0 } if 1 index totype /streamtype eq { 0 } if 2 index .array? { 5 /mulavg publicproc: } { 4 /mulavg publicproc: [ ] exch } ifelse { strm1 strm2 grids renamegrids minper } inputs strm1 mayberechunkmulavg strm2 mayberechunkmulavg 2xtoNaN8 2 setcommongrids 1 index .npts 1 index .npts ge { reordertomatch } { exch reordertomatch exch } ifelse grids chunkpattern dup 3 1 index 2 get minper mul round cvi put 2 index .missing_value null eq 2 index .missing_value null eq and { 1 index .datatype /realarraytype eq { mulavg0g } { mulavg1g } ifelse STREAM TaskParameterBlock 1 get NewIntegerBuffer pop TaskStreams 0 get dup TaskStreams 1 get grids binarysetSIRecord chunksize NewDoubleBuffer } { 1 index .datatype /realarraytype eq { mulavg0MVg } { mulavg0MVdpg } ifelse STREAM TaskParameterBlock 1 get NewIntegerBuffer pop TaskStreams 0 get dup TaskStreams 1 get grids binarysetSIRecord chunksize NewIntegerBuffer pop TaskStreams 0 get dup TaskStreams 1 get grids binarysetSIRecord chunksize NewDoubleBuffer } ifelse grids { 2 copy gridnobyname nip 0 eq { .name undef } { last VALUE } ifelse } forall grids { 2 copy gridnobyname nip 0 eq { pop } { removeGRID0 } ifelse } forall /units strm1 .units strm2 .units unitmul preferredunitname def renamegrids length 0 gt { 0 1 renamegrids length 1 sub { renamegrids 1 index get exch grids exch get .name renameGRID } for } if 1output :publicproc } |
| BLD | { foralldatasetsCase 5 object exch dup null eq { pop } { /streamtype0 exch def } ifelse exch dup null eq { pop } { /datasettype0 exch def } ifelse /arraytype { pop } def /pendingdatasettype currentobject /arraytype get def /myCases 1 index def /==alias /myCases cvx def mycasedefs 1 object /myCases 3 -1 roll def begin startdataset mycaseexec enddataset end } |
| BLD | { 3 /seastotAvgFill publicproc: { mystream monrange minfrac } inputs mystream T minfrac monthlyAverage a: T (days since 1960-01-01) streamgridunitconvert T differential_mul T :a: .T :a replaceGRID T monrange 1.0 seasonalAverage monrange (-) search { nip pop } if 0 3 getinterval interp monrange (-) search { nip nip } if 0 3 getinterval interp sub dup 0 ge { 1 add } { 1 add 12 add } ifelse mul :publicproc nip } |
| BLD | { streamdefCases 1 index totype get exec } |
| BLD | { 5 /seasonalnonoverlapDSfreq publicproc: { mystream monrange dslength thold minfrac } inputs mystream a: dataflag T monthlyAverage minfrac masklt T monrange 1.0 seasonalAverage :a: -999 replaceNaN 0 thold flagrange [ T ] integral dup T dslength shiftGRID [ T ] regridLB sub dslength dslength flagrange [ T ] differences 1 1 flagrange T sums T (0000 1) VALUES [ T ] differences T (months since 1960-01-01) streamgridunitconvert T monrange 1.0 seasonalAverage monrange (-) search { nip pop } if 0 3 getinterval interp monrange (-) search { nip nip } if 0 3 getinterval interp sub dup 0 ge { 1 add } { 1 add 12 add } ifelse mul :a mul :publicproc nip } |
| BLD | { 10 /onsetDate publicproc: { myprcp Tgrid earlyStart searchDays rainyDay runningDays runningTotal minRainyDays dryDays drySpell } inputs searchDays runningDays lt { (searchDays must be greater or equal than runningDays) leavemessage 1output } if drySpell dryDays lt drySpell ne 0 and { (drySpell must be greater or equal than dryDays, please go back) leavemessage 1output } if myprcp Tgrid 1 index Tgrid earlyStart VALUES Tgrid .name get .gridvalues { searchDays drySpell add { dup 1 add dup last gt { pop } if } repeat } forall VALUES dup dup Tgrid .name get npts /I exch NewIntegerGRID replaceGRID I searchDays drySpell add 1 add splitstreamgrid I /gridtype 0 def pop dup I runningDays 2.0 div cvi -1 mul shiftGRID I first dup runningDays 2.0 div cvi 1 sub add RANGE 0 mul exch 2 { exch [ I ] REORDER } repeat appendstream dup I runningDays 2.0 div cvi shiftGRID I last dup runningDays 2.0 div cvi 1 sub sub exch RANGE 0 mul appendstream dup rainyDay flaggt dup 3 -2 roll I runningDays runningAverage runningDays mul minRainyDays flagge exch I runningDays runningAverage runningDays mul runningTotal flagge mul drySpell 0 ne { 1 index I dryDays runningAverage 0 flaggt I runningDays 2.0 div dryDays 2.0 div add 1 1 index drySpell dryDays sub 1.0 add 1.0 sub add shiftdatashort [ I_lag ] average 1 flagge mul } if runningDays 2 mod 0 eq { 1 index I 0.5 shiftGRID exch [ I ] regridLB nip } { [ I ] regridLB } ifelse I runningDays 1.0 sub 2.0 div dup -1.0 mul exch 1 exch shiftdatashort [ I_lag ] sum 0 flaggt mul 1 masklt 1 index Tgrid .name get 0.0 add /name /datesample def dup Tgrid .name get npts /I exch NewIntegerGRID replaceGRID I searchDays drySpell add 1 add splitstreamgrid I /gridtype 0 def pop exch mul [ I ] minover I2 3 -1 roll T earlyStart VALUES Tgrid .name get 2 array astore { npts } forall 3 -1 roll ne { first secondtolast subgrid } if replaceGRID /pointwidth 1 def /long_name (Onset Date) def /fullname [ /onsetDate myprcp .fullname ] def 1output :publicproc } |
| BLD | { 2 array astore cvx defasvarcachesilent } |
| BLD | { /svdview.html { (svdview) htmlprint } def Ss .npts 12500000 gt { /LargeCalculation dataareIRIonlyPassword } if [ currentobject /W getknown pop vartot sv evaln Ss Ts ] { /dataset 2 index def /myproc undef /fullname [ dataset .fullname name ] def dataset /last_modified getknown { /last_modified exch def } if Ss .npts 12500000 gt { /LargeCalculation dataareIRIonlyPassword } if name exch def } forall } |
| BLD | { nip { streamN mytsgrid px w1 params } inputs w1 params .ft params .w2 params .flat params .att params .ford butt_design streamN px -1 eq not { dup 1.0 w1 div round 1 index mytsgrid .name get step 3 -1 roll mul px 0 eq { pad0 } if px 1 eq { pad1 } if px 2 eq { pad2 } if } if ycoeffs -1.0 mul dup coeffs high low RANGE coeffs 2 index .coeffs replaceGRID xcoeffs gain div 3 { 3 -1 roll 3 index mytsgrid .name get /Ide unitmatrix mytsgrid .name cvntos (_out) 2 array astore concat interp fordvalue -1.0 mul 1 index .step dup 3 -2 roll mul exch 0 shiftdatashort mytsgrid .name cvntos (_out_lag) 2 array astore concat interp coeffs replaceGRID [ coeffs ] mulsum } repeat c: 1.0 :c 4 index mytsgrid .name get beginLoop 0.9 mul endLoop dup dup mytsgrid .name get /myT2 renameGRID .myT2 beginLoop 0.9 div endLoop 1.1 maskge dup dup mytsgrid .name get high low RANGE dup mytsgrid .name get 2 index mytsgrid .name get replaceGRID myT2 high low RANGE myT2 2 index .myT2 replaceGRID replaceNaN dup mytsgrid .name get 1 array astore [ myT2 ] svd a: .Ss :a: .Ts :a: .sv :a sqrt div [ ev ] mulsum 4 -2 roll 2 { exch 2 index dup mytsgrid .name get 1 array astore mulsum myT2 2 index mytsgrid .name cvlit nip renameGRID mytsgrid .name cvntos (_out) 2 array astore concat interp 1 array astore 1 index mytsgrid .name get 1 array astore ginverse } repeat exch 2 index dup mytsgrid .name get 1 array astore mulsum 3 index mytsgrid .name cvntos (_out) 2 array astore concat interp 1 array astore mulsum myT2 /myT3 renameGRID 3 -1 roll dup mytsgrid .name get 1 array astore mulsum myT2 2 index mytsgrid .name cvlit nip renameGRID dup mytsgrid .name get 1 array astore mulsum mytsgrid .name cvntos (_out) 2 array astore concat interp 1 array astore mulsum myT3 0 add myT3 a: .first :a: .first step fordvalue wcvalue div mul add :a maskrange 0 mul add dup dup mytsgrid .name get high low RANGE dup mytsgrid .name get 2 index mytsgrid .name get replaceGRID myT3 high low RANGE myT3 2 index .myT3 replaceGRID replaceNaN dup mytsgrid .name get 1 array astore mulsum myT3 2 index mytsgrid .name cvlit nip renameGRID px -1 eq not { dup mytsgrid .name get 3 -1 roll mytsgrid .name get a: .first :a: .last :a RANGEEDGES } if /name (butt) def /long_name (butterworth) def /fullname [ /butt streamN .fullname ] def /butt add_variable exch /procargs [ procargs aload pop params .ft /filterType cvx params .w2 /freqCut2 cvx params .flat /flatness cvx params .att /attenuation cvx params .ford /forder cvx /:butt_filter cvx ] store exch 1output :publicproc } |
| BLD | { fullnamegen } |
| BLD | { 6 /Water_Balance: publicproc: WBparams WBS new 0.3 store initp 0.5 store rho 1 store InitKc 25 store InitD 1 store VegKc 25 store VegD 1 store MidKc 25 store MidD 1 store LateKc 25 store LateD 1 store EndKc 1 store PlDd (Jan) store PlDm (Unknown) store Crop } |
| BLD | { counttoobject /RANGESPAN0 /RANGESPAN allstreams1 } |
| BLD | { 2 index totype /arraytype eq { 3 index 3 index 2 { 3 index [ exch { .name } forall ] } repeat 4 /svd: publicproc: pop pop pop pop } { 2 index 2 { 2 index [ exch { .name } forall ] } repeat 3 /svd: publicproc: pop pop pop } ifelse svdparams /gappy-data? false def /spatial-mean? false def /temporal-mean? false def } |
| BLD | { (downloadsICASA) htmlprint } |
| BLD | { dataset /last_modified known { /last_modified dataset .last_modified def } if dataset /expires known { /expires dataset .expires def } if inheritdatarestrictions } |
| BLD | { cptv10_sub DoTasks stop } |
| BLD | { cvlit { mygrid myproc } inputs myproc 0 get dup type /stringtype eq { (%) search { nip nip (/) rsearch { pop pop } if } if /myfixedfile exch def } { pop /myfixedfile null def } ifelse /mycachefile currentdefiningdatasetcachevardirname dup null eq { pop pop } { (/) mygrid .name cvntos (.gridinfo) 4array astore concat def } ifelse /mycachefile? 1 index /mycachefile known def myfixedfile dup null eq exch fileexists? or { mycachefile? { systemtime mycachefile filelast_modified sub dup 3600 lt exch 1 gt and last_modified mycachefile filelast_modified lt and } { false } ifelse { mygrid mycachefile readfile dup /expires known { expires systemtime lt mycachefile filelast_modified dup expires lt exch 1800 add systemtime lt or and { pop false } { true } ifelse } { true } ifelse } { false } ifelse not { mygrid myproc cvx removeextrausing0 mycachefile? { mycachefile false cachegridinfo } if } if } { mygrid mycachefile? { mycachefile dup fileexists? { readfile } { pop } ifelse } if } ifelse dup /expires known { /expires expires def } if 1output } |
| BLD | { 1383147742 set_code_last_modified /json WWWinfo exch /mimesuffix exch put mimeheader: true { WWWinfo .sendmimeheader { (Vary: Accept-Encoding ) print } if WWWinfo /Accept-Encoding getknown { (gzip) search { pop pop pop true } { pop false } ifelse } { false } ifelse } { true } ifelse { (Content-Encoding: gzip ) print :mimeheader togzip } { :mimeheader } ifelse dup type /stringtype eq not { currentobject totype /streamtype eq { (iridl:Variable) } { (iridl:Dataset) } ifelse } if { myobject mytargettype } inputs openJSON exch ({ "@context": ) PSprint Types2OutSchema mytargettype get writeJSON (, ) PSprint myobject mytargettype typedConvert continueJSON ( ) PSprint closeJSON flush stop } |
| BLD | { dup { pop } { buffer null eq { CopyStream } if bufferSIRecord SIRecord ne { CopyStream } if cachevardirname VBattachfile pop } foralldatasets2 } |
| BLD | { 1 /erf publicproc: { A } inputs A dup type /objecttype eq not { c: exch :c } if datatype /realarraytype eq { chunksize 1 integerarray astore vserf0 TaskStreams 0 get TaskParameterBlock 0 get NewBuffer defivars /fullname [ /erf A .fullname ] def } { chunksize 1 integerarray astore vderf0 TaskStreams 0 get TaskParameterBlock 0 get NewBuffer defivars /fullname [ /erf A .fullname ] def } ifelse 1output :publicproc } |
| BLD | { mark currentobject totype /streamtype eq { currentobject } { /LAYERS /layers wmsgetknown { null { (,) search { nip counttomark 1 add index exch pget exec } { counttomark 1 add index exch pget exec leave } ifelse } repeat } { /LAYER /layer wmsgetknown { null { (,) search { nip counttomark 1 add index exch pget exec } { counttomark 1 add index exch pget exec leave } ifelse } repeat } if } ifelse } ifelse counttomark 1 ge { currentobject /band known { getXY? pop fig: rgbcolor :fig } { getXY? pop fig: colors :fig } ifelse /REQUEST /request wmsgetknown { (GetLegendGraphic) eq { .auxfig } if } if /plotborder 0 psdef /plotaxislength /WIDTH /width wmsgetknown { interp /HEIGHT /height wmsgetknown { interp imax } if psdef /XOVY /WIDTH /width wmsgetknown { interp } if /HEIGHT /height wmsgetknown { interp } if 1.0 mul div psdef } { pop } ifelse /TRANSPARENT /transparent wmsgetknown { dup (TRUE) eq exch (true) eq or { /transparent true psdef } if } if figgrids 0 get /BBOX /bbox wmsgetknown { 3 { (,) search pop nip interp exch } repeat interp pop nip plotrange } { pop } ifelse figgrids 1 get /BBOX /bbox wmsgetknown { 3 { (,) search pop nip interp exch } repeat interp nip 3 -1 roll pop plotrange } { pop } ifelse figachunk { get_units .timeunits? { /TIME /time wmsgetknown { /ISO8601 readusing dup length 0 eq { defaultvalue } if array? { 0 get } if plotvalue } { defaultvalue plotvalue } ifelse } { name FORMgetknown { interp plotvalue } { defaultvalue plotvalue } ifelse } ifelse } forall /FORMAT FORMgetknown { WMSFORMATS exch get exec } { .gif } ifelse } { /txt mimeheader:set (Nothing to plot ) print } ifelse } |
| BLD | { { /total0 (total) apply1get1_complementgrids } /sum gridarray1fn } |
| BLD | { currentobject /long_name known { mark exch dup type /arraytype eq { aload length 1 lt { null } if } if pop long_name ] } if } |
| BLD | /cptv10 |
| BLD | { counttoobject /RANGEEDGES0 /RANGEEDGES allstreams1 } |
| BLD | { 1 /SLtoT publicproc: decompress S L add /calendar S .get_calendar def /pointwidth L .pointwidth def ndim RECHUNK /T units 0 currentobject getrealization NewGRID /pointwidth 2 index .pointwidth def exch .nptgrids 0 get exch replaceGRID :publicproc } |
| BLD | { 3 /pad0 publicproc: { mystream mygrid pl } inputs mystream dup dup dup mygrid .name get pl -1 mul shiftdata 1 index .chunk array astore REORDER dup dup mygrid .name get 1 array astore average exch 0 mul add dup mygrid .name get 2 index mygrid .name get last exch .step add last RANGEEDGES mygrid .name cvntos (_lag) 2 array astore concat cvn removeGRID exch dup mygrid .name get pl shiftdata 1 index .chunk array astore REORDER dup dup mygrid .name get 1 array astore average exch 0 mul add dup mygrid .name get first 4 index mygrid .name get first exch .step sub RANGEEDGES mygrid .name cvntos (_lag) 2 array astore concat cvn removeGRID 3 -1 roll appendstream exch appendstream /fullname [ /pad0 mystream .fullname ] def :publicproc nip } |
| BLD | { exch dup type /objecttype eq not { 1 index dup type /objecttype eq { 0.0 mul add } { pop c: exch :c } ifelse } { 0 RECHUNK } ifelse exch 2 /poestudnt2 publicproc: { A dof } inputs dof type /objecttype eq { A dof 2 array astore { todouble toNaN8 } forall 1 index 0.0 mul add 1 index .chunksize 1 integerarray astore poestudnt2dof0 } { A todouble toNaN8 chunksize dof 2 integerarray astore poestudnt20 } ifelse TaskStreams 0 get TaskParameterBlock 0 get NewBuffer /fullname [ /poestudnt2 A .fullname ] def 1output :publicproc } |
| BLD | CaseListpops2 /streamtype { pop pop pop true leave } def /pendingdatasettype { mark exch exec counttomark 1 ne { counttomark (broken dataset definition: returns ) exch s== append error } if nip totype /streamtype eq nip { pop true leave } if } def |
| BLD | { 3 /pad2 publicproc: { mystream mygrid pl } inputs mystream dup dup dup mygrid .name get dup .step pl add -1 mul shiftdata 1 index .chunk array astore REORDER dup mygrid .name get 2 index mygrid .name get last exch .step add last RANGEEDGES dup dup dup mygrid .name get last VALUE dup mygrid .name get removeGRID sub 2 mul sub dup mygrid .name get 2 index mygrid .name get last exch .step add 1 index last exch .step sub RANGEEDGES dup dup mygrid .name get 0 add dup mygrid .name get 1 array astore sort_by rank 3 -1 roll mygrid .name get replaceGRID mygrid .name cvntos (_lag) 2 array astore concat cvn removeGRID exch dup mygrid .name get dup .step pl add shiftdata 1 index .chunk array astore REORDER dup mygrid .name get first 4 index mygrid .name get first exch .step sub RANGEEDGES dup dup dup mygrid .name get first VALUE dup mygrid .name get removeGRID sub 2 mul sub dup mygrid .name get dup first exch .step add 4 index mygrid .name get first exch .step sub RANGEEDGES dup dup mygrid .name get 0 add dup mygrid .name get 1 array astore sort_by rank 3 -1 roll mygrid .name get replaceGRID mygrid .name cvntos (_lag) 2 array astore concat cvn removeGRID 3 -1 roll appendstream exch appendstream /fullname [ /pad2 mystream .fullname ] def :publicproc nip } |
| BLD | { counttoobject /VALUES0 /VALUES allstreams1 } |
| BLD | { 1 /erfc publicproc: { A } inputs A dup type /objecttype eq not { c: exch :c } if datatype /realarraytype eq { chunksize 1 integerarray astore vserfc0 TaskStreams 0 get TaskParameterBlock 0 get NewBuffer /fullname [ /erfc A .fullname ] def defivars } { chunksize 1 integerarray astore vderfc0 TaskStreams 0 get TaskParameterBlock 0 get NewBuffer /fullname [ /erfc A .fullname ] def } ifelse 1output :publicproc } |
| BLD | { realorintegertype? not { 0.0 } if 1 index totype /gridtype ne { T exch } if 3 /monthlyAverage publicproc: 2 array astore cvx newmonthlyAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { decompress mark exch nptgrids aload pop counttomark 1 add -2 roll nip } |
| BLD | 0 23 object /MidKcStart { store MidKc } def /MidDays { store MidD } def /PlantDday { store PlDd } def /LateKcStart { store LateKc } def /PlantDmonth { store PlDm } def /WBS WBS def /CropName { store Crop } def /LateDays { store LateD } def /InitCond { store initp } def /InitKcStart { store InitKc } def /calib { store rho } def /InitDays { store InitD } def /VegKcStart { store VegKc } def /LateKcEnd { store EndKc } def /VegDays { store VegD } def |
| BLD | { dodatasetfilters 3 object exch /nonull? exch def exch /streamtype exch def exch /gridtype exch def filtersetexec } |
| BLD | { { complementgridarray { minfnof0 minfnof0dp } (min) apply1get1nocount } /minover gridarray1fn } |
| BLD | 0 23 object /survb { store betaexp } def /feednu { store nu } def /wctS wctS def /spr { store C } def /popu { store d } def /feedh { store h } def /spof { store fN } def /infk { store k } def /spog { store gN } def /infv { store v } def /del { store x } def /rec { store r } def /feedf { store fu } def /nat { store mu } def /surva { store alphaexp } def /feedg { store gu } def |
| BLD | { dup /column_name known { column_name } { dup /long_name known { long_name } { name cvntos } ifelse } ifelse } |
| BLD | { currentobject totype dup /datasettype eq exch /streamtype eq or { currentobject /description getknown { fullname name eq { name deletesuffix } { fullname extendnamearray dolongname } ifelse htmlformulaprint (: ) print printno' } { currentobject getdatasetwithdesc dup /description known { exch 2 copy subnamearray extendnamearray dolongname htmlformulaprint ( from ) print exch longname htmlformulaprint (: ) print .description printno' } { pop longname htmlformulaprint } ifelse } ifelse } if } |
| BLD | { /gz /mimesuffix WWWinfo ! cptv10_sub togzip DoTasks stop } |
| BLD | { (downloadsGrADS) htmlprint } |
| BLD | { /tabopt FORMknown { pop table: /NaNmarker FORMknown { /NaNmarker WWWinfo .FORMinfo .NaNmarker def } if 1 1 WWWinfo .FORMinfo .tabopt .N interp { s== cvn WWWinfo .FORMinfo .tabopt exch get interp } for /eol FORMknown { /eol eols WWWinfo .FORMinfo .eol cvn get def } if :table WWWinfo FORMinfo .tabtype cvn dup /igor.tsv eq 1 index /R.tsv eq or { /mimesuffix /tsv def } { dup /free eq { /mimesuffix /txt def } { /mimesuffix 1 index def } ifelse } ifelse mimeheaderdata nip dup /html eq { ( ) print cvx exec ( ) print } { cvx exec } ifelse flush stop } { (ncoltable) htmlprint } ifelse } |
| BLD | { 3 /shiftGRID publicproc: exch .name cvlit exch 2 array astore cvx shiftGRIDFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { [ Z ] regridLinear exch dup /sp known { 128 64 tsptogau } if exch (mb) unitconvert Z 1000 925 850 700 600 500 400 300 250 200 150 100 70 50 30 20 10 toS /gribleveltype 100 def } |
| BLD | { 3 /pad1 publicproc: { mystream mygrid pl } inputs mystream dup dup dup mygrid .name get dup .step pl add -1 mul shiftdata 1 index .chunk array astore REORDER dup mygrid .name get 2 index mygrid .name get last exch .step add 1 index last exch .step sub RANGEEDGES dup dup mygrid .name get 0 add dup mygrid .name get 1 array astore sort_by rank 3 -1 roll mygrid .name get replaceGRID mygrid .name cvntos (_lag) 2 array astore concat cvn removeGRID exch dup mygrid .name get dup .step pl add shiftdata 1 index .chunk array astore REORDER dup mygrid .name get dup first exch .step add 4 index mygrid .name get first exch .step sub RANGEEDGES dup dup mygrid .name get 0 add dup mygrid .name get 1 array astore sort_by rank 3 -1 roll mygrid .name get replaceGRID mygrid .name cvntos (_lag) 2 array astore concat cvn removeGRID 3 -1 roll appendstream exch appendstream /fullname [ /pad1 mystream .fullname ] def :publicproc nip } |
| BLD | { pushdataset currentdataset dup 10 object /streamcount 0 def exch DATASETbot ==noprintdataset { doifstreamdef } forsome streamcount 0 ne { /streamcount undef } { pop null } ifelse popdataset } |
| BLD | { 2 array astore cvx defasvarcachedecompresssilent } |
| BLD | { 4 /flexseasonalfreqGT publicproc: { mystream daterange thold minfrac } inputs mystream thold flaggt T daterange minfrac seasonalAverage T differential_mul :publicproc nip } |
| BLD | definingtableWords |
| BLD | 0 5 object /stringtype /stringtype def /namearraytype /namearraytype def |
| BLD | { dimension CopyStream x_range CopyStream y_range CopyStream z_range CopyStream reserverealization reserverealization reserverealization reserverealization z CopyStream dup reserverealization (X) cvn x_range units exch 0 exch CopyStream getrealization aload pop 2 copy exch sub dimension CopyStream getrealization 0 get 1 sub div exch NewEvenGRID name exch def (Y) cvn y_range units exch 0 exch CopyStream getrealization aload pop exch 2 copy exch sub dimension CopyStream getrealization 1 get 1 sub div exch NewEvenGRID name exch def 2 SetStreamIndex* X Y * (xysize) cvn undef z_range CopyStream getrealization aload pop /value_max exch def /value_min exch def nip } |
| BLD | { (outline) htmlprint } |
| BLD | FilterSet /streamtype { 3 -1 roll decompress 3 1 roll 2 index 2 index .name getknown { exec 3 -1 roll pop exch 2 index .getmissing_value null eq { pop dekadalAverage0 } { 3 1 roll 1 index 0 replaceNaN 1 index dekadalAverage0 3 1 roll exch dataflag exch dekadalAverage0 3 -1 roll normalize } ifelse } { pop pop } ifelse } def /gridtype { pop 1 index .name 1 index .name eq { pop dekadaledgesgrid partialgrid } { pop } ifelse } def |
| BLD | { definingtable exch } |
| BLD | { dup /description known not { dataset type /objecttype eq { .dataset getdatasetwithdesc } if } if } |
| BLD | FilterSet /streamtype { getmissing_value null eq { pop } { exch 1 index replaceNaN exch /missing_value exch def } ifelse } def /gridtype { pop } def |
| BLD | { { /rootmeansq0 (root mean sq) apply1get1_complementgrids } /rootmeansqover gridarray1fn } |
| BLD | { streamgridarray mark currentobject /expires known { expires dup null eq { pop } if } if counttomark 1 add index { dup /expires known { expires dup null eq { pop pop } { nip } ifelse } { pop } ifelse } forall counttomark 1 sub { imin } repeat counttomark 1 eq { /expires exch def } if currentobject /last_modified known { last_modified dup null eq { pop } if } if counttomark 1 add index { dup /last_modified known { last_modified dup null eq { pop pop } { nip } ifelse } { pop } ifelse } forall counttomark 1 sub { imax } repeat counttomark 1 eq { /last_modified exch def } if pop pop } |
| BLD | { 1 /varimax: publicproc: varimaxS new 9.99999975E-05 store EPS 0.001 store DELTA 5 store MAXIT } |
| BLD | 0 11 object /gappy-data { svdparams /gappy-data? true put } def /spatial-mean { svdparams /spatial-mean? true put } def /temporal-mean { svdparams /temporal-mean? true put } def /gappy-data? false def /temporal-mean? false def /spatial-mean? false def |
| BLD | { (subdatasets) htmlprint } |
| BLD | { 3 /butt_poly_coeffs publicproc: { Real Imag poly_ord } inputs Real dup mul Imag dup mul add sqrt dup 0.0 mul 1.0 add grid: /name /coeffs def 0 1 poly_ord :grid beginLoop 1 index mul endLoop nip Imag Real atan dup 0.0 mul coeffs beginLoop 1 index add endLoop nip dup sin exch cos 2 index mul 3 -2 roll mul 0 ds exch coeffs second last RANGEEDGES /Im add_variable 1 index coeffs second last RANGEEDGES /Re add_variable { Re Im } grouptogrid [ M poles ] [ coeffs ] ginverse M (Re) VALUE /M removeGRID Real dup mul Imag dup mul add sqrt ln [ poles ] sum eexp poly_ord 2 div dup round eq not { -1.0 mul } if dup -1.0 mul 3 -1 roll mul [ poles ] sum exch 3 -1 roll .coeffs 0.0 mul add coeffs first VALUE exch appendstream 1output :publicproc } |
| BLD | { dup type /objecttype eq { 0.0 } if 2 /monthlyAverage publicproc: monthlyAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { mark 3 1 roll subnamearray0 } |
| BLD | { appendprep 0 { appendstreamsilent } /appenddatasetsilent allstreams1 currentfilepattern 0 get -1 ne { /filepattern currentfilepattern 0 get def } if } |
| BLD | { cvlit { mygrid myproc } inputs myproc 0 get dup type /stringtype eq { (%) search { nip nip dup (/) rsearch { pop pop length 1 add 0 exch getinterval } { pop } ifelse } if /myfixedfile exch def } { pop /myfixedfile null def } ifelse mygrid /myfixedfile getknown { /myfixedfile exch def } if /mycachefile currentdefiningdatasetcachevardirname dup null eq { pop pop } { (/) mygrid .name cvntos (.gridinfo) 4array astore concat def } ifelse /mycachefile? 1 index /mycachefile known def myfixedfile null eq { true } { myfixedfile remotefileexists? } ifelse { mycachefile? { systemtime mycachefile filelast_modified sub dup 3600 6 mul lt exch 1 gt and } { false } ifelse { mygrid mycachefile readfile dup /expires known { expires systemtime lt mycachefile filelast_modified dup expires lt exch 1800 add systemtime lt or and { pop false } { true } ifelse } { true } ifelse } { false } ifelse not { mygrid myproc cvx remoteremoveextrausing0 mycachefile? { mycachefile true cachegridinfo } if } if } { mygrid mycachefile? { mycachefile dup fileexists? { readfile } { pop } ifelse } if } ifelse dup /expires known { /expires expires def } if 1output } |
| BLD | { realorintegertype? not { 0.0 } if 1 index totype /gridtype ne { T exch } if 3 /dailyAverage publicproc: 2 array astore cvx dailyAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| name | /==alias |
| BLD | { surface dup /pss known { pss /missing_value null def pop } if dup /zg known { zg /missing_value null def pop } if dup /prl known { prl /units (m/s) cvn def name exch def } if dup /prc known { prc /units (m/s) cvn def name exch def } if dup /prl known 1 index /prc known and { /prcp { prl prc add /long_name (Total Precipitation) def /gribparam 260 def /grib_name /totprcp def } defasvar } if /dpsdx { pss 42 gautotsp partialeast 128 64 tsptogauUV /long_name (Zonal Deriv. of Surface Pres.) def /gribparam 273 def /grib_name /dpsdx def } defasvar /dpsdy { pss 42 gautotsp partialnorth 128 64 tsptogauUV /long_name (Meridional Deriv. of Surface Pres.) def /gribparam 274 def /grib_name /dpsdy def } defasvar /slp { extraP /gribparam 151 def /gribleveltype 102 def /long_name (mean sea level pressure) def } defasvarsilent name exch def hybrid_lev dup datasetdefs: /cterm { dataset .hybrid_lev a: .AC Z -0.5 1.0 0.5 shiftdatashort Z_lag 0.5 VALUE :a: .BC Z -0.5 1.0 0.5 shiftdatashort Z_lag -0.5 VALUE mul :a: .AC Z -0.5 1.0 0.5 shiftdatashort Z_lag -0.5 VALUE :a: .BC Z -0.5 1.0 0.5 shiftdatashort Z_lag 0.5 VALUE mul sub -1 mul :a } defasvar /cterm { AC Z differences BC [ Z ] regridLinear mul BC Z differences AC [ Z ] regridLinear mul sub BC Z differences 0 flaggt mul } defasvar /pterm { cterm P [ Z ] differences div P 500 max Z lnratios mul } defasvar /ps-advection { dataset a: .hybrid_lev .u 128 64 tsptogauUV :a: .surface .dpsdx mul :a: .hybrid_lev .v 128 64 tsptogauUV :a: .surface .dpsdy mul add :a } defasvar /omegahalf { dataset a: .hybrid_lev .ps-advection :a: .hybrid_lev .BC Z differences mul :a: .hybrid_lev .P [ Z ] differences :a: .hybrid_lev .Div 128 64 tsptogau mul :a add -1 mul 3 RECHUNK [ Z ] sums 2 RECHUNK /long_name (vertical pressure velocity subterm) def /gribparam undef /grib_name undef } defasvar :datasetdefs exch DATASETbot null 5 object /ps-advection dup def /pterm dup def /cterm dup def /omegahalf dup def { def } forsome /psi { rvort invlaplacian /long_name (streamfunction) def /gribparam 148 def /grib_name /strm def } defasvar /chi { Div invlaplacian /long_name (velocity potential) def /gribparam 149 def /grib_name /vpot def } defasvar /u { chi nsp 1 sub changetruncation partialeast nsp 1 add changetruncation psi nsp 1 sub changetruncation partialnorth sub /long_name (zonal velocity) def /gribparam 131 def /grib_name /ua def } defasvar /v { chi nsp 1 sub changetruncation partialnorth psi nsp 1 sub changetruncation partialeast nsp 1 add changetruncation add /long_name (meridional velocity) def /gribparam 132 def /grib_name /va def } defasvar /Z rvort .Z def continuedataset: variable: /name /AC def /units /Pa def grids: Z integralgrid :grids values: 0 2000.0 4000.0 6046.1104 8267.9277 10609.514 12851.101 14698.498 15861.125 16116.236 15356.924 13621.46 11101.562 8127.144 5125.1416 2549.9695 783.19501 0 0 0 :values :variable variable: /name /BC def /units /unitless def grids: Z integralgrid :grids values: 0 0 0 3.38993297E-04 0.003357187 0.01307004 0.03407715 0.07064983 0.1259167 0.2011954 0.2955196 0.4054092 0.5249322 0.646108 0.7596984 0.8564376 0.9287469 0.9729852 0.9922815 1.0 :values :variable variable: /name /Rv def /long_name (gas constant for moist air) def /units (J/kg/K) def grids: :grids values: 461.52499 :values :variable variable: /name /Rd def /long_name (gas constant for dry air) def /units (J/kg/K) def grids: :grids values: 287.05966 :values :variable variable: /name /gravity def /long_name (earth's gravity) def /units (m/s2) def grids: :grids values: 9.8066502 :values :variable /omega { dataset a: .hybrid_lev .ps-advection :a: .hybrid_lev .P [ Z ] regridLinear mul :a: .hybrid_lev .BC Z differences 0 RECHUNK :a: .hybrid_lev .pterm add :a: .hybrid_lev .P Z differences div 2 RECHUNK mul toreal :a: .hybrid_lev .omegahalf CopyStream [ Z ] regridLinear add :a /long_name (vertical pressure velocity) def /gribparam 135 def /units (Pa/s) def } defasvar /P { dataset a: hybrid_lev /logpsl known { .hybrid_lev .logpsl 128 64 tsptogau eexp /units /Pa def Z removeGRID } { .surface .pss } ifelse :a: .hybrid_lev .BC mul :a: .hybrid_lev .AC add :a /long_name (pressure) def /gribparam undef /grib_name undef 1006806553 set_last_modified } defasvar /phi { P 500 max Z lnratios Z high low RANGE ta unitclearorigin 128 64 tsptogau mul Rd -1 mul gravity div mul Rd .dataset /hus known { Rv Rd div 1 sub hus dup /sp known { 128 64 tsptogau } if mul 1 add mul } if Rd .dataset .dataset .surface .zg gravity div [ Z ] integrate /long_name (geopotential height) def /gribparam 156 def /grib_name /zg def } defasvar :dataset name exch def continuedataset: dataset: /name /PressureLevel def /description (gaussian grid at standard Pressure Levels -- below surface values marked as missing) def /u { currentobject .dataset .hybrid_lev a: .u :a: .P :a toafterPlvlUV } defasvar /v { dataset .hybrid_lev a: .v :a: .P :a toafterPlvlUV } defasvar /ta { dataset .hybrid_lev a: .ta :a: .P :a toafterPlvl } defasvar /rvort { dataset .hybrid_lev a: .rvort :a: .P :a toafterPlvl } defasvar /psi { dataset .hybrid_lev a: .psi :a: .P :a toafterPlvl } defasvar /phi { dataset .hybrid_lev a: .phi :a: .P Z second last RANGE :a toafterPlvl } defasvar /hus { dataset .hybrid_lev a: .hus :a: .P :a toafterPlvl } defasvar /omega { dataset .hybrid_lev a: .omega :a: .P :a toafterPlvl } defasvar /Div { dataset .hybrid_lev a: .Div :a: .P :a toafterPlvl } defasvar /chi { dataset .hybrid_lev a: .chi :a: .P :a toafterPlvl } defasvar :dataset :dataset /griblist.html { (griblist) htmlprint } def } |
| BLD | { 1284664335 set_code_last_modified dup type /arraytype eq { exch 1 index REORDER exch 0 get gridvalues { 3 copy VALUE 4 1 roll cvsunits 4 -1 roll exch /column_name exch cvn def 3 1 roll } forall pop pop } if dup totype /datasettype eq { mark exch { pop } { nptgrids length 1 gt { pop } { datatype /geometrytype eq { pop } if } ifelse } foralldatasets2 definingtable tableobject 11 object mark } { definingtable tableobject 11 object } ifelse /prtwds [ tablecolmax { { printnamedunits } } repeat ] def } |
| BLD | { nrdim grids { gridno imax } forall nrdim sub { 0 grids { gridno 1 index .nrdim ge { 1 add } if } forall nrdim grids { gridno imax } forall nrdim sub lt { nrdim 1 add RECHUNK } { leave } ifelse } repeat } |
| BLD | { false 1 index DATASETbot ==noprintdataset { ifgridcase caseexec } forsome } |
| BLD | { currentobject totype /datasettype eq { currentobject { pop } { } foralldatasets2 } if } |
| BLD | { 2 index null eq { pop pop } { counttoobject 1 sub index dup type /arraytype eq { length counttoobject 2 sub eq { 0.0 } if counttoobject 1 add } { pop counttoobject 1 eq { 0.0 } if 4 } ifelse /boxAverage publicproc: counttoobject 1 sub index dup type /arraytype eq { length counttoobject 2 sub eq { 0.0 } if counttoobject 1 add } { pop counttoobject 1 eq { 0.0 } if 4 } ifelse 1 sub array astore dup 0 2 copy get dup type /arraytype eq { mark 1 index { .name } forall counttomark 2 add -1 roll astore cvx nip } { .name cvlit } ifelse put cvx boxAveragecase 1 object exch /filterargs exch def datasetexec :publicproc } ifelse } |
| BLD | [ null ] |
| BLD | { dup mark eq { pop counttomark 2 sub /ncol exch def counttomark 1 add -1 roll pop } if dup type /integertype eq { /ncol exch def } if ncol 1 eq { 3 -1 roll nptgrids dup length 0 gt { 0 get exch 4 2 roll /ncol ncol 1 add def } { pop 3 1 roll } ifelse } if nip } |
| BLD | { counttoobject 1 add /average publicproc: dup /keepgrids eq { pop { /mean0 (mean) apply1get1_complementgrids_keepgrids } /average gridarray1fn } { { /mean0 (mean) apply1get1_complementgrids } /average gridarray1fn } ifelse :publicproc } |
| BLD | { currentobject totype dup /datasettype eq exch /streamtype eq or { currentobject /description getknown { fullname name eq { name deletesuffix } { fullname extendnamearray dolongname } ifelse printforxml (: ) print printforxml } { currentobject getdatasetwithdesc dup /description known { exch 2 copy subnamearray extendnamearray dup length 0 gt { dolongname printforxml ( from ) print } { pop } ifelse exch longname printforxml (: ) print .description printforxml } { pop longname printforxml } ifelse } ifelse } if } |
| BLD | { 1 index type /arraytype eq not { { } } if 3 1 roll null 3 1 roll cvx /dodefasvarcachedecompresssilent cvx 5 array astore cvx dup 1 currentobject put dup 2 get exch pdef } |
| name | /==alias |
| BLD | CaseList /objecttype { pop pop } def /htmlprinttype { pop pop } def /gridtype { allgrid totype /datasettype eq { allgrid 2 index torelativename pgetknown { 2 copy ne { allargs aload pop allroutine dup null eq { pop undef } { dup name known { .streamgrids } if name 2 index eq { def } { name exch def undef } ifelse /streamcount streamcount 1 add def } ifelse } { pop pop pop } ifelse } { pop pop } ifelse } { name allgrid eq { dup allargs aload pop allroutine dup null eq { pop undef } { dup name known { .streamgrids } if name 2 index eq { def } { name exch def undef } ifelse /streamcount streamcount 1 add def } ifelse } { pop pop } ifelse } ifelse } def /xmlfiletype { pop pop } def /linktype { pop pop } def /booleantype { pop pop } def /nametype { pop pop } def /messagetype { pop pop } def /figobjecttype { pop pop } def /realtype { pop pop } def /realarraytype { pop pop } def /namearraytype { pop pop } def /shortarraytype { pop pop } def /datasettype { doallstreams dup null eq { pop undef } { /dataset 3 index def def /streamcount streamcount 1 add def } ifelse } def /giffiletype { pop pop } def /integertype { pop pop } def /arraytype { dup xcheck { nip currentdataset exch exec nip name exch doifstreamdef } { pop pop } ifelse } def /streamtype { dup dup allgrid anyknowngrid { dup allgridget allargs aload pop allroutine } { decompress dup allgrid anyknowngrid { dup allgridget allargs aload pop allroutine } if } ifelse exch 1 index eq { 5 object /dataset 3 index def def /streamcount streamcount 1 add def } { dup null eq { pop undef } { /dataset 3 index def def /streamcount streamcount 1 add def } ifelse } ifelse } def /htmlfiletype { pop pop } def /jpegfiletype { pop pop } def /pendingdatasettype { dup xcheck { nip currentdataset exch exec nip name exch doifstreamdef } { pop pop } ifelse } def /stringtype { pop pop } def /imageobjecttype { pop pop } def /figviewtype { dup dup allgrid known { allgrid allargs aload pop allroutine } if exch 1 index eq { 5 object /dataset 3 index def def /streamcount streamcount 1 add def } { dup null eq { pop undef } { /dataset 3 index def def /streamcount streamcount 1 add def } ifelse } ifelse } def /nulltype { pop pop } def /marktype { pop pop } def /operatortype { pop pop } def /geometrytype { pop pop } def /integerarraytype { pop pop } def /doublearraytype { pop pop } def |
| BLD | { rootmeansqover } |
| BLD | { covarcomp0 STREAM TaskParameterBlock 1 get dup 1 add mul 2 div NewIntegerBuffer pop STREAM 11 object /name /cov def /fullname [ /cov variablesarray 0 get .fullname dup type /arraytype ne { 1 array astore } if ] def /ISYMM dup TaskParameterBlock 1 get dup 1 add mul 2 div NewIntegerGRID def ISYMM .npts NewDoubleBuffer 1 SetStreamIndex* ISYMM avachunkgrids aload pop repeatgrids aload pop * /units variablesarray 0 get .units dup unitmul def /missing_value NaN def STREAM TaskParameterBlock 1 get NewIntegerBuffer /name /indices def rgrids length SetStreamIndex* rgrids aload pop avachunkgrids aload pop repeatgrids aload pop * STREAM 1 NewIntegerBuffer /name /nout def 0 SetStreamIndex* avachunkgrids aload pop repeatgrids aload pop * 3 array astore { avachunkgrids { last VALUE } forall avachunkgrids { removeGRID0 } forall } forall 3 -1 roll /ipack compression: 3 -1 roll name exch def 3 -1 roll name exch def /compressedgrid rgrids def /grids rgrids def :compression /symmetricStorageMode compression: /symmetricchunk rgrids def :compression } |
| BLD | { 1 index totype /gridtype eq { 0.0 } if 4 /seasonalAverage publicproc: 3 array astore cvx seasonalAverageFS 1 object exch /filterargs exch def currentobject /filterargs get 1 get type /stringtype eq { currentobject /filterargs get 0 get .name currentobject /filterargs get 1 get 4 2 roll datasetexec 2 index cvx exec 2 index ( - ) search { nip nip } if VALUES nip exch exec dup units monthtimename eq { /pointwidth get_bounds streamgrids pop differences streamgrids nip first VALUE getrealization 0 get def } if nip name exch def } { datasetexec } ifelse :publicproc } |
| BLD | { foralldatasetsCase 5 object exch dup null eq { pop } { /streamtype exch def } ifelse exch dup null eq { pop } { /datasettype0 exch def } ifelse /myCases 1 index def /==alias /myCases cvx def mycasedefs 1 object /myCases 3 -1 roll def begin startdataset mycaseexec enddataset end } |
| BLD | { (downloadsGeoTiff) htmlprint } |
| BLD | { realorintegertype? not { 0.0 } if 1 index totype /gridtype ne { T exch } if 3 /yearlyAverage publicproc: 2 array astore cvx yearlyAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { 3 /seastotZeroFill publicproc: { mystream monrange minfrac } inputs mystream a: dataflag T monthlyAverage minfrac flagge 0 maskle :a: 0 replaceNaN T sums T (0000 1) VALUES [ T ] differences T (months since 1960-01-01) streamgridunitconvert :a mul T monrange 1.0 seasonalAverage monrange (-) search { nip pop } if 0 3 getinterval interp monrange (-) search { nip nip } if 0 3 getinterval interp sub dup 0 ge { 1 add } { 1 add 12 add } ifelse mul :publicproc nip } |
| BLD | { 3 /flexseastotZeroFill publicproc: { mystream daterange minfrac } inputs mystream dup T daterange minfrac seasonalAverage 0 mul exch 0 replaceNaN T daterange 1.0 seasonalAverage add T differential_mul :publicproc nip } |
| BLD | { currentfilepattern 0 -1 put 1 index /filepattern getknown { 1 index /filepattern getknown { 2 copy eq { pop pop } { 1 index totype /streamtype eq { dup totype /streamtype ne { 3 -1 roll nip /filepattern attributetovariable exch .streamgrids .name 1 index exch get filepattern exch addGRIDstream name exch def } { pop pop } ifelse } { pop pop exch /filepattern undef exch /filepattern undef } ifelse } ifelse } { pop } ifelse } if } |
| BLD | { dup type /integertype eq { array astore } if 1 index totype /gridtype eq { aload length REORDER0 } { 0 { aload length REORDER0 } /REORDER allstreams1 } ifelse } |
| BLD | { 5 /flexseasonalnonoverlapWSfreq publicproc: { mystream daterange wslength thold minfrac } inputs mystream a: T daterange minfrac seasonalAverage 0 flagge :a: -999 replaceNaN 0 thold flagnotrange [ T ] integral dup T wslength shiftGRID [ T ] regridLB sub wslength flagge [ T ] differences 1 flagge T :a: T daterange 0 6 getinterval VALUES T wslength 1 sub shiftGRID .T first cvsunits 0 6 getinterval ( - ) daterange 8 16 getinterval 3 array astore concat nip seasonalAverage T differential_mul T 2 index .T replaceGRID :a mul :publicproc nip } |
| BLD | { :table } |
| BLD | { { /meansq0 (mean sq) apply1get1 } /meansq gridarray1fn } |
| BLD | { nip { precip tempavg tempamp myTAW mygrid geolocations params } inputs NEWDATASET /fullname { name } def /name /water_balance def precip dup dup mygrid dup type /arraytype eq { 1 get } if .name get -6 1 0 shiftdatashort mygrid dup type /arraytype eq { 1 get } if .name cvntos (_lag) append interp 0.0 add 0 maskle 2 replaceNaN div mygrid dup type /arraytype eq { 1 get } if .name cvntos (_lag) append interp 1 array astore sum 1 index 12.5 flagge mul { IPA0 6.25 IPA1 6.3000002 IPA2 19.0 IPA3 31.700001 IPA4 44.400002 IPA5 57.099998 IPA6 69.900002 IPA7 } classify grid: /name /PPcoefs def values: 0.0 0.0 0.0 0.858 -0.895 0.0028 -1.14 0.042 0.0026 -2.3399999 0.12 0.0026 -2.3599999 0.19 0.0026 -2.78 0.25 0.0026 -3.1700001 0.32 0.0024 -4.21 0.438 0.0018 :values :grid 0 add /name /PPcoef def PPcoefs /PPn 24 NewIntegerGRID replaceGRID PPn 3 splitstreamgrid PPn2 aprod replaceGRID PPn 1.0 sub 4 -1 roll ln mul eexp mul [ PPn ] sum mul [ aprod ] sum dup dataflag 1 masklt exch 0 max mul geolocations length 5 eq { geolocations dup 0 get exch dup 3 get exch 4 get 3 -1 roll exch geometrydistance nip 3 -1 roll exch /long_name (distance of station from soil masking) def /distance add_variable exch } if geolocations length 3 eq { geolocations dup 0 get exch dup 1 get exch 2 get 3 -2 roll 2 array astore weighted-average } if prcp_0to1000_colors DATA 0 AUTO RANGE /long_name (water run off) def /units /mm def /Runoff add_variable precip geolocations length 3 eq { geolocations dup 0 get exch dup 1 get exch 2 get 3 -2 roll 2 array astore weighted-average } if Runoff -1.0 mul exch add prcp_0to1000_colors DATA 0 AUTO RANGE /units /mm def /long_name (effective precipitation) def /Peffective add_variable mygrid dup type /arraytype eq { 0 get } { 0 add } ifelse 365.25 mod /units /days def pi mul 2.0 mul 365.25 div dup cos 0.033 mul 1.0 add exch 1.39 sub sin 0.409 mul dup tan geolocations dup length 5 eq { 2 get } { 1 get 0.0 add } ifelse dup tand -1.0 mul 3 -1 roll mul acosd pi mul 180.0 div 3 -1 roll dup sin exch cos 3 index cosd mul 2 index sin mul 3 -2 roll 4 -1 roll sind mul mul add mul 0.082 mul 1440.0 mul pi div 0.408 mul 0.0023 mul rainbowcolorscale /long_name (extraterrestrial radiation) def /units (MJ/m2/day) def /RA add_variable tempavg 17.799999 add tempamp sqrt mul geolocations dup length 3 ne { pop RA mul } { dup 0 get exch dup 1 get exch 2 get 3 -2 roll 2 array astore 3 -1 roll RA mul 3 -2 roll weighted-average } ifelse prcp_0to1000_colors DATA 0 AUTO RANGE /units /mm def /long_name (reference evapotranspiration) def /ETref add_variable mygrid dup type /arraytype eq { 0 get /Tt 1 index units 0 3 -1 roll a: mygrid 0 get [ streamgrids ] nip minover getrealization 0 get 366 sub :a: mygrid 0 get [ streamgrids ] nip maxover getrealization 0 get 366 add :a 1 exch NewEvenGRID 0.0 mul 1 add /name /longtime def dup Tt /Ss renameGRID } { 0.0 mul 1 add /name /longtime def dup dup mygrid .name get /Ss renameGRID Ss 366 pad0 } ifelse Ss params .PlDd cvi s== ( ) append params .PlDm append VALUES /I 365 NewIntegerGRID CopyStream dup 1 flagle params .InitKc interp mul 1 index 2 params .InitD interp flagrange params .VegKc interp params .InitKc interp sub params .InitD interp div mul 2 index params .InitD interp 1 add dup params .VegD interp 1 sub add dup 4 -3 roll flagrange params .MidKc interp params .VegKc interp sub params .VegD interp div mul exch 4 index exch 1 add dup params .MidD interp 1 sub add dup 4 -3 roll flagrange params .LateKc interp params .MidKc interp sub params .MidD interp div mul exch 5 index exch 1 add dup params .LateD interp 1 sub add dup 4 -3 roll flagrange params .EndKc interp params .LateKc interp sub params .LateD interp div mul exch 7 -1 roll exch 1 add dup 1 add flagrange 1 params .EndKc interp sub 2.0 div mul add add add add add 0.0 I integrate I second last RANGE I -1 shiftGRID I /units /days def /pointwidth 1.0 def /Ll renameGRID mul [ Ll Ss ] REORDER CopyStream 0 RECHUNK CopyStream dup [ Ll Ss ] /I nchunk NewIntegerGRID replaceGRIDstream Ll Ss add 0.5 sub 0 RECHUNK [ Ll Ss ] /I nchunk NewIntegerGRID replaceGRIDstream use_as_grid mygrid type /arraytype eq { asum Tt .name renameGRID nip dup Tt .name get 1 array astore regridAverage nip /units /unitless def exch Tt sample-along } { asum mygrid dup type /arraytype eq { 1 get } if .name renameGRID nip dup mygrid dup type /arraytype eq { 1 get } if .name get 1 array astore regridAverage nip /units /unitless def } ifelse rainbowcolorscale DATA 0 AUTO RANGE /long_name params .Crop ( crop Cultivar) append def /Kc add_variable Kc ETref mul prcp_0to1000_colors DATA 0 AUTO RANGE /units /mm def /long_name params .Crop ( crop evapotranspiration) append def /ETcrop add_variable dup mygrid dup type /arraytype eq { 1 get } if .name get 0.0 add /name /noname def streamgrids 1 pad0 streamgrids nip second last subgrid myTAW params .initp interp mul ETcrop dup mygrid dup type /arraytype eq { 1 get } if .name get first VALUE mygrid dup type /arraytype eq { 1 get } if .name removeGRID 0.0 mul add [ streamgrids ] REORDER exch beginLoop dup params .rho interp myTAW mul div 1 min ETcrop mul sub Peffective add 0.0 max myTAW min endLoop dup dup mygrid dup type /arraytype eq { 1 get } if .name get first VALUE 0.0 mul 1 index mygrid dup type /arraytype eq { 1 get } if .name get beginLoop ETcrop 0.0 mul add Peffective 0.0 mul add endLoop add dup mygrid dup type /arraytype eq { 1 get } if .name get -1 shiftGRID prcp_0to1000_colors DATA 0 AUTO RANGE /units /mm def /long_name (soil moisture) def /SM add_variable SM dup mygrid dup type /arraytype eq { 1 get } if .name get 1 shiftGRID myTAW params .rho interp mul div 1 min ETcrop mul prcp_0to1000_colors DATA 0 AUTO RANGE /units /mm def /long_name params .Crop ( reduced crop evapotranspiration) append def /ETcrop_red add_variable Peffective ETcrop_red sub SM dup mygrid dup type /arraytype eq { 1 get } if .name get differences dup mygrid dup type /arraytype eq { 1 get } if .name get 0.5 shiftGRID sub prcp_0to1000_colors DATA 0 AUTO RANGE /long_name (water drained) def /units /mm def /Drain add_variable geolocations length 5 eq { geolocations 4 get /the_geom add_variable } if geolocations length 3 eq { geolocations 2 get /the_geom add_variable } if mygrid dup type /arraytype eq { 0 get name add_variable } { pop } ifelse exch /procargs [ procargs aload pop params .initp /InitCond cvx params .rho /calib cvx params .InitKc /InitKcStart params .InitD /InitDays params .VegKc /VegKcStart params .VegD /VegDays params .MidKc /MidKcStart params .MidD /MidDays params .LateKc /LateKcStart params .LateD /LateDays params .EndKc /LateKcEnd params .PlDd /PlantDday params .PlDm /PlantDmonth params .Crop /CropName /:Water_Balance cvx ] store exch 1output :publicproc } |
| BLD | null |
| BLD | varimaxS |
| BLD | { tblS new 0 store interation eol store EOL tblstart store TBLST tblend store TBLEN recstart store RECST recend store RECEN entstart store ENTST entend store ENTEN 1 index /header get store HDRFN nip skipNaN store skipnan NaNmarker dup null eq { pop () } if dup type /stringtype ne { s== } if store markNaN ncol store n1 ncol store n1t IPG store ipg NPPG store nppg 0 store nlabel 1 index /prtwds known { 1 index .prtwds 0 ncol tablecolmax imin getinterval } { [ { printnamedunits } n1 1 sub { dup } repeat ] } ifelse store PRTWDS nip [ n1 2 add 2 roll ] store STRMS n1 tablecolmax gt { STRMS 0 tablecolmax getinterval store STRMS tablecolmax store n1 tablecolmax store n1t } if dup /thetablerecord Ingrid: ! STRMS nip { currentobject dup totype /gridtype eq exch /bounds known and { get_bounds pop } if getmissing_value null ne { datatype gentabunscalable exch known not { toNaN } { bufferwordsize 1 eq { toNaN } if } ifelse } { datatype gentabunscalable exch known not { getscale_factor type /objecttype eq getadd_offset type /objecttype eq or { toNaN } if dup totype /gridtype eq not getscale_factor 1.0 ne getadd_offset 0.0 ne or and { toNaN } if } { bufferwordsize 1 eq { toNaN } if } ifelse } ifelse } forall thetablerecord STRMS nip astore aload length null MATCH thetablerecord STRMS nip astore pop thetablerecord mark STRMS { .datatype } forall counttomark namearray astore nip store TYPES /mylookup null STRMS length object 0 1 STRMS length 1 sub { STRMS 1 index get .name exch 1 add def } for def skipnan type /arraytype eq { mark skipnan { dup type /objecttype eq { .name } if mylookup exch get STRMS 1 index 1 sub get .missing_value null eq { pop } if } forall counttomark integerarray astore nip store skipnan } if skipnan true eq { mark STRMS { datatype /stringtype ne bufferwordsize 1 eq or { .name mylookup exch get STRMS 1 index 1 sub get .missing_value null eq { pop } if } { pop } ifelse } forall counttomark integerarray astore nip store skipnan } if skipnan false eq { 0 integerarray store skipnan } if mark STRMS { bufferwordsize nip } forall counttomark integerarray astore nip store NWS STRMS 0 get .chunksize dup 0 eq { pop 1 } if store n2 STRMS 0 get .nchunk dup 0 eq { pop 1 } if store n3 null STRMS { dup /expires known { .expires dup null eq { pop } { 1 index null eq { nip } { imax } ifelse } ifelse } { pop } ifelse } forall 0 STRMS { /last_modified getknownnotnull { imaxasproc } if } forall exch mimeheadersetlastmodexpires STRMS aload length 1 add -1 roll { null gentab1 gentab2 gentab3 gentab4 gentab5 gentab6 gentab7 gentab8 gentab9 gentab10 gentab11 gentab12 gentab13 gentab14 gentab15 gentab16 gentab17 gentab18 gentab19 gentab20 gentab21 gentab22 gentab23 gentab24 gentab25 } n1 get exec STREAM 23 object /name /entrycount def /datatype /integerarraytype def 1 NewIntegerBuffer 0 SetStreamIndex* TaskStreams 0 get .nchunk dup 1 gt { /I exch NewIntegerGRID } { pop } ifelse * ndim 0 gt { I last VALUE I removeGRID } if } |
| BLD | { 4 /flexseasonalfreqLT publicproc: { mystream daterange thold minfrac } inputs mystream thold flaglt T daterange minfrac seasonalAverage T differential_mul :publicproc nip } |
| BLD | { counttoobject 1 sub index dup type /arraytype eq { length counttoobject 2 sub eq { 0.0 } if counttoobject 1 add } { pop counttoobject 1 eq { 0.0 } if 4 } ifelse /boxAverageSP publicproc: counttoobject 1 sub index dup type /arraytype eq { length counttoobject 2 sub eq { 0.0 } if counttoobject 1 add } { pop counttoobject 1 eq { 0.0 } if 4 } ifelse 1 sub array astore dup 0 2 copy get dup type /arraytype eq { mark 1 index { .name } forall counttomark 2 add -1 roll astore cvx nip } { .name cvlit } ifelse put cvx boxAverageSPcase 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { get_scale_max number? { getscale_factor mul getadd_offset add } if } |
| BLD | { realorintegertype? not { 0.0 } if 1 index totype /gridtype ne { T exch } if 3 /dekadalAverage publicproc: 2 array astore cvx dekadalAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { 0 { 1 index .dataset dup null eq { pop pop } { 1 index .name get replaceGRID } ifelse } /replacewithdatasetGRID allstreams1 } |
| BLD | { 4 /seasonalmeandailyvalueGT publicproc: { mystream monrange thold minfrac } inputs mystream a: dataflag T monthlyAverage minfrac flagge 0 maskle T monrange 1.0 seasonalAverage :a: thold maskle T monrange 0.0 seasonalAverage :a mul :publicproc nip } |
| BLD | { dup /references known not { dataset type /objecttype eq { .dataset getdatasetwithreferences } { pop null } ifelse } if } |
| BLD | FilterSet /streamtype { 4 -1 roll decompress 4 1 roll 3 index 3 index .name getknown { exec 4 -1 roll pop 3 1 roll 3 index .getmissing_value null eq { pop seasonalAverage0 } { 4 1 roll 2 index 0 replaceNaN 2 index 2 index seasonalAverage0 4 1 roll 3 -1 roll dataflag 3 1 roll seasonalAverage0 3 -1 roll normalize } ifelse } { pop pop pop } ifelse } def /gridtype { pop 2 index .name 2 index .name eq { nip dup ( - ) search { pop pop pop true } { pop false } ifelse { seasonaledgesgrid dup } { seasonaledgesgrid dup /monthtime gridunitconvert } ifelse partialgrid } { pop pop } ifelse } def |
| BLD | { 1 /erfinv publicproc: { A } inputs A dup type /objecttype eq not { c: exch :c } if datatype /realarraytype eq { chunksize 1 integerarray astore vserfinv0 TaskStreams 0 get TaskParameterBlock 0 get NewBuffer /fullname [ /erfinv A .fullname ] def defivars } { chunksize 1 integerarray astore vderfinv0 TaskStreams 0 get TaskParameterBlock 0 get NewBuffer /fullname [ /erfinv A .fullname ] def } ifelse 1output :publicproc } |
| BLD | tblS |
| BLD | 0 5 object (CR-LF (DOS/Windows))cvn (CRLF) def (LF (unix))cvn (LF) def (CR (Mac))cvn (CR) def |
| BLD | { null 3 1 roll /donopdefasvarsilent cvx 4 array astore cvx dup 0 currentobject put dup 1 get exch def } |
| BLD | { 1 index type /arraytype eq not { { } } if 3 1 roll currentobject 3 1 roll cvx /dodefasvarcache cvx 5 array astore cvx dup 2 get exch pdef } |
| BLD | { 1 index type /arraytype eq not { { } } if 3 1 roll currentobject 3 1 roll cvx /dodefasvarmetacachevar cvx 5 array astore cvx dup 2 get exch pdef } |
| BLD | 0 11 object |
| BLD | 0 5 object /integerarraytype { bounds2indexI4 } def /realarraytype { bounds2indexR4 } def /doublearraytype { bounds2indexR8 } def |
| BLD | FilterSet /streamtype { 3 -1 roll decompress 3 1 roll 2 index 2 index .name getknown { exec 3 -1 roll pop exch 2 index .getmissing_value null eq { pop yearlyAverage0 } { 3 1 roll 1 index 0 replaceNaN 1 index yearlyAverage0 3 1 roll exch dataflag exch yearlyAverage0 3 -1 roll normalize } ifelse } { pop pop } ifelse } def /gridtype { pop 1 index .name 1 index .name eq { pop yearlyedgesgrid partialgrid } { pop } ifelse } def |
| BLD | { { /rootmeansqanom0 (root mean sq anom) apply1get12scr } /rootmeansqanom gridarray1fn } |
| BLD | { 1 index type /arraytype eq not { { } } if 3 1 roll null 3 1 roll /dodefasvarpartiallysilent cvx 5 array astore cvx dup 1 currentobject put dup 2 get exch pdef } |
| BLD | [ null null ] |
| BLD | { 1 index type /arraytype eq not { { } } if 3 1 roll currentobject 3 1 roll cvx /dodefasvarcacheKeepRestrictions cvx 5 array astore cvx dup 2 get exch pdef } |
| BLD | { dup type /integertype eq { array astore } if 2 /SELECTORDER publicproc: false 1 index { type /stringtype eq { pop true leave } if } forall { exch null 2 index { dup type /stringtype eq { (,) search { nip exch RANGEEDGES } { VALUES } ifelse null } { nip } ifelse } forall pop exch [ exch { dup type /stringtype eq { pop } if } forall ] } if 1 index totype /gridtype eq { aload length REORDER0 } { 0 { aload length SELECTORDER0 } /SELECTORDER allstreams1 } ifelse :publicproc } |
| BLD | { currentobject totype dup /datasettype eq exch /streamtype eq or { currentobject /description getknown { fullname name eq { name deletesuffix } { fullname extendnamearray dolongname } ifelse printno' (: ) print printno' } { currentobject getdatasetwithdesc dup /description known { exch 2 copy subnamearray extendnamearray dup length 0 gt { dolongname printno' ( from ) print } { pop } ifelse exch longname printno' (: ) print .description printno' } { pop longname printno' } ifelse } ifelse } if } |
| BLD | { 2 copy eq { pop pop ] } { dup /myprocds getknown { type /arraytype eq { true } { dataset 1 index .myprocds eq not } ifelse } { true } ifelse { name deletesuffix counttomark 1 roll } if .dataset subnamearray0 } ifelse } |
| BLD | { nip { Temp Prcp mygrid params } inputs NEWDATASET /fullname { name } def /name /wct def Prcp dup mygrid .name get 1 array astore REORDER achunk array astore REORDER dup mygrid .name get -28 1 1 shiftdatashort mygrid .name cvntos (_lag) append interp 1 array astore sum (units) (mm/month) def params .mu mul /name (q) def /long_name (number of emerging mosquitoes) def /units (unitless) def /q add_variable Temp dup mygrid .name get 1 array astore REORDER achunk array astore REORDER (Celsius_scale) unitconvert dup mygrid .name get -28 1 1 shiftdatashort mygrid .name cvntos (_lag) append interp last VALUE mygrid .name cvntos (_lag) append cvn removeGRID dup 0 add params .gu sub params .fu exch div /name (u) def /long_name (period of digestion of blood meal) def /units (days) def /scale_min 0 def /scale_max 20 def 3 -1 roll exch /u add_variable u params .nu add /name (U) def /long_name (total gonotrophic cycle length) def /scale_min 0 def /scale_max 20 def /U add_variable exch params .gN sub params .fN exch div /name (N) def /long_name (length of the sporogonic cycle) def /units (days) def /scale_min 0 def /scale_max 50 def /N add_variable U 1 exch div 1 params .betaexp -1.0 exch div eexp sub params .C mul -1 mul 1 add params .alphaexp -1.0 exch div eexp mul ln mul eexp /name (P) def /long_name (mean probability of daily survival for mosquito population) def /scale_min 0 def /scale_max 1 def /P add_variable N P ln mul eexp params .x params .h mul params .k mul params .v mul mul 1 params .betaexp -1.0 exch div eexp sub params .C mul -1 mul 1 add params .alphaexp -1.0 exch div eexp mul params .x params .h mul params .k mul params .v mul -1 mul 1 add mul -1 mul 1 add div /name (S) def /long_name (sporozoite rate) def /scale_min 0 def /scale_max 0.01 def /S add_variable U params .h exch div /name (a) def /long_name (mosquitoes feeding on humans frequency) def /scale_min 0 def /scale_max 0.2 def /a add_variable S q a mul mul 1 params .d div -1 mul 1 add ln mul eexp -1 mul 1 add /name (R) def /long_name (probability of a human receiving an infectious bite) def /scale_min 0 def /scale_max 0.001 def /R add_variable R params .d mul 3 -1 roll exch /At exch def R params .r -1 mul 1 add mul 1 add params .r add /Bt exch def exch { } { T 1 shiftGRID name add_variable } foralldatasets2 exch At 0 mul dup mygrid .name get first VALUE mygrid .name removeGRID params .d 100.0 div add At mygrid .name get beginLoop At add Bt div endLoop Bt dup mygrid .name get 1 shiftGRID dup mygrid .name get last VALUE At dup mygrid .name get 1 shiftGRID dup mygrid .name get last VALUE 2 index dup mygrid .name get 1 shiftGRID dup mygrid .name get last VALUE add exch div appendstream 1 R sub params .r mul 1 index mul /name (c) def /long_name (number of people recovering) def /scale_min 0 def 4 -1 roll exch /c add_variable params .d 2 index sub R mul /name (F) def /long_name (number of people newly infected) def /scale_min 0 def /F add_variable exch /name (I) def /long_name (number of infected humans) def /scale_min 0 def /I add_variable exch /procargs [ procargs aload pop params .d /popu cvx params .fN /spof cvx params .gN /spog cvx params .x /del cvx params .r /rec cvx params .mu /nat cvx params .alphaexp /surva cvx params .betaexp /survb cvx params .C /spr cvx params .fu /feedf cvx params .gu /feedg cvx params .nu /feednu cvx params .h /feedh cvx params .k /infk cvx params .v /infv cvx /:WCT cvx ] store exch 1output :publicproc } |
| BLD | { getSRS dup null eq not { srtext2crsid } if dup null eq { pop (CRS:1) } if } |
| BLD | { counttoobject array astore { currentobject 1 index get dup type /arraytype eq { /exec cvx /cachevar cvx 3 array astore cvx defasvarsilent } { cachevar pop pop } ifelse } forall } |
| BLD | { (rdf) xmlprint } |
| BLD | { 4 /flexseasonalmeandailyvalueGT publicproc: { mystream daterange thold minfrac } inputs mystream a: T daterange minfrac seasonalAverage 0 flagge :a: thold maskle T daterange 0.0 seasonalAverage :a mul :publicproc nip } |
| BLD | { dup type /objecttype eq { datatype /geometrytype eq { 1 index .spatialgrids } if } if dup type dup /realtype eq exch /integertype eq or not { 0.0 } if 2 index array? exch xcheck not and { 5 /weighted-average publicproc: } { 2 index type /objecttype eq { datatype /geometrytype eq { 3 index 3 -1 roll add:isSophisticatedBy nip exch } if } if 4 /weighted-average publicproc: [ ] exch } ifelse { mydata mywghts mygrids renamegrids mymincntwght } inputs currentobject /mywghts get type /arraytype eq { mydata mywghts nip /mywghts exch def } if /mygwghts mywghts def mywghts .datatype /geometrytype eq { mydata mywghts rasterize mygrids length 4 eq { mygrids 2 get .units /degree_east eq mygrids 3 get .units /degree_north eq and { mygrids 1 get mygrids 3 get add cosd mul } if } if mygrids length 2 eq { streamgridarray 0 get .units /degree_east eq streamgridarray 1 get .units /degree_north eq and { streamgridarray 1 get cosd mul } if } if mydata exch mygrids regridAverage nip /mywghts exch def mydata mygwghts geoboundingbox message? not { BOXEDGES /mydata exch def } { pop pop } ifelse mywghts mygwghts geoboundingbox message? not { BOXEDGES /mywghts exch def } { pop pop } ifelse } if /mynwghts mywghts 1 mygrids { 2 index 1 index gridno exch .nrdim gt { npts exch gridstride mul mul } { pop } ifelse } forall BufferOrder dup mygrids average div def mydata .getmissing_value null eq { mydata mynwghts mygrids mulavg } { mydata 0.0 replaceNaN mynwghts mygrids mulavg mydata dataflag mynwghts mygrids mulavg mymincntwght normalize } ifelse renamegrids length 0 gt { 0 1 renamegrids length 1 sub { renamegrids 1 index get exch mygrids exch get .name renameGRID } for } if 1output :publicproc } |
| BLD | { realorintegertype? not { 0.0 } if 1 index totype /gridtype ne { T exch } if 3 /pentadAverage publicproc: 2 array astore cvx newpentadAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | null |
| BLD | { (downloadsCPT) htmlprint } |
| BLD | 0 5 object |
| BLD | { [ Z ] regridLinear exch dup /sp known { 128 64 tsptogauUV } if exch (mb) unitconvert Z 1000 925 850 700 600 500 400 300 250 200 150 100 70 50 30 20 10 toS /gribleveltype 100 def } |
| BLD | { 0 /extraP publicproc: dataset a: .surface .pss decompress [ X Y ] REORDER todouble :a: .surface .zg decompress [ X Y ] REORDER todouble :a: .hybrid_lev .ta 128 64 tsptogau Z last VALUE [ X Y ] REORDER todouble :a: .hybrid_lev .P [ Z ] regridLinear [ X Y ] REORDER (Pa) unitconvert todouble :a 4 matchachunk chunksize extrapfn0 TaskStreams 3 get chunksize NewDoubleBuffer nrdim SetStreamIndex* X Y TaskStreams 0 get .achunk pop * /name /extraP def /fullname [ fullname aload pop pop name ] def /gridparam undef :publicproc } |
| BLD | { 1 index type /arraytype eq not { { } } if 3 1 roll currentobject 3 1 roll cvx /dodefasvarmetacacheds cvx 5 array astore cvx dup 2 get exch pdef } |
| BLD | { 2 /dominant_class publicproc: { cat_data gridset } inputs cat_data gridset 2 copy { pop complementgridarray 1 index .getmissing_value? { pop /dominantclass0mv } { /dominantclass0 } ifelse (dominant_class) apply1get1_1scr } /dominant_class gridarray1fn 1 index length 1 eq { 1 index 0 get first 1 eq last npts eq grideven and and { pop /CLIST undef } { .gridvalues /CLIST exch def } ifelse } { [ 2 index { .gridvalues } forall ] [ exch { [ exch { cvntos dup type /stringtype ne { s== } if ( ) } forall pop ] concat } forallforall ] /CLIST exch def } ifelse exch 1 exch { .npts mul } forall /valid_max exch def /valid_min 1 def /scale_min valid_min def /scale_max valid_max def /CS scale_min def /CE scale_max def DATA scale_min scale_max RANGE dup /CLIST known { /CLIST CLIST dup type /namearraytype eq { { cvntos } forall CLIST length array astore def } { gridset length 1 ne { { s== } forall CLIST length array astore def } { gridset 0 get exch { cvsunits exch } forall CLIST length dup 3 add exch 2 add -1 mul roll CLIST length array astore def exch .units /CLISTu exch def } ifelse } ifelse /units /ids def } { /units /ids def CE CS sub 10 lt { /CI 1 def } if } ifelse /missing_value 0 def nip 1output :publicproc } |
| BLD | { null 3 1 roll /dodefasvarsilent cvx 4 array astore cvx dup 0 currentobject put dup 1 get exch pdef } |
| BLD | { (inventory) htmlprint } |
| BLD | { continuedataset: dataset: /name /PressureLevel-SF def /long_name (PressureLevel-Smoothed and Filled) def /description (gaussian grid at standard Pressure Levels -- below surface values are filled and then spectrally smoothed which is standard but unwise) def /u { dataset a: .PressureLevel .u [ X Y ] REORDER :a: .hybrid_lev .u Z last VALUE 128 64 tsptogauUV replaceNaN :a 42 gautotspUV 128 64 tsptogauUV } defasvar /v { dataset a: .PressureLevel .v [ X Y ] REORDER :a: .hybrid_lev .v Z last VALUE 128 64 tsptogauUV replaceNaN :a 42 gautotspUV 128 64 tsptogauUV } defasvar /ta { dataset a: .PressureLevel .ta [ X Y ] REORDER extraT :a replaceNaN 42 gautotsp 128 64 tsptogau } defasvar /phi { dataset a: .PressureLevel .phi extraZ :a replaceNaN /missing_value null def 42 gautotsp 128 64 tsptogau } defasvar :dataset :dataset } |
| BLD | { pushallargs pushproc doifstream popproc popallargs } |
| BLD | { 3 /splitstreamgrid publicproc: exch .name cvlit exch 2 array astore cvx splitstreamgridcase 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | [ null ] |
| BLD | { counttoobject /RANGE0 /RANGE allstreams1 } |
| BLD | { 1 index null eq { pop pop } { exch 1 index false defdatasetgridsflag astore pop { 2 copy .name known { pop } { name exch dup /plaindim known { pop pop } { def } ifelse true defdatasetgridsflag astore pop } ifelse } forall dataset null eq { pop pop } { dataset exch name exch store exch defdatasetgridsflag 0 get { defdatasetgrids } { pop pop } ifelse } ifelse } ifelse } |
| BLD | CaseList /pendingdatasettype { exec 1 index caseexec } def /datasettype { notyetwritten } def /nonull false def |
| BLD | { 2 array astore cvx defasvarsilent } |
| BLD | { 4 /seasonalfreqGT publicproc: { mystream monrange thold minfrac } inputs mystream a: dataflag T monthlyAverage minfrac flagge 0 maskle :a: thold maskle dataflag T minfrac monthlyAverage a: T (days since 1960-01-01) streamgridunitconvert T differential_mul T :a: .T :a replaceGRID :a mul T monrange 1.0 seasonalAverage monrange (-) search { nip pop } if 0 3 getinterval interp monrange (-) search { nip nip } if 0 3 getinterval interp sub dup 0 ge { 1 add } { 1 add 12 add } ifelse mul /long_name (count) def :publicproc nip } |
| BLD | { foralldatasetsCase 5 object exch dup null eq { pop } { /streamtype exch def } ifelse exch dup null eq { pop } { /datasettypeexit0 exch def } ifelse exch dup null eq { pop } { /datasettype0 exch def } ifelse /myCases 1 index def /==alias /myCases cvx def mycasedefs 1 object /myCases 3 -1 roll def begin startdataset mycaseexec enddataset end } |
| BLD | { currentobject 3 1 roll cvx /dodefasvar cvx 4 array astore cvx dup 1 get exch pdef } |
| BLD | { 5 /flexseasonalnonoverlapDSfreq publicproc: { mystream daterange dslength thold minfrac } inputs mystream a: T daterange minfrac seasonalAverage 0 flagge :a: -999 replaceNaN 0 thold flagrange [ T ] integral dup T dslength shiftGRID [ T ] regridLB sub dslength flagge [ T ] differences 1 flagge T :a: T daterange 0 6 getinterval VALUES T dslength 1 sub shiftGRID .T first cvsunits 0 6 getinterval ( - ) daterange 8 16 getinterval 3 array astore concat nip seasonalAverage T differential_mul T 2 index .T replaceGRID :a mul :publicproc nip } |
| BLD | { counttoobject /SELECTVALUES0 /SELECT allstreams1 } |
| BLD | { 1 index type /arraytype eq not { { } } if 3 1 roll null 3 1 roll cvx /dodefasvarcachesilent cvx 5 array astore cvx dup 1 currentobject put dup 2 get exch pdef } |
| BLD | { (wms) xmlprint } |
| BLD | { Ss .npts ev .npts idiv store M ev .npts store L Ss sv mul todouble [ ev ] REORDER achunk REORDER ndim RECHUNK dup dataflag [ ev ] sum ev .npts flagge 3 index /W getknown { mul } if todouble 3 -1 roll varimax0 5 object /evaln undef /fullname [ /varimax fullname aload pop ] def proclevel 0 get 1 eq { /procargs TaskParameterBlock [ procargs aload pop EPS /store cvx /EPS cvx DELTA /store cvx /DELTA cvx MAXIT /store cvx /MAXIT cvx /:varimax cvx ] nip store } if :publicproc /Ss TaskStreams 0 get chunksize NewDoubleBuffer ev /evrot units gridtype gridvalues NewGRID nip name exch def /ev undef nrdim SetStreamIndex* streamgrids pop evrot * /long_name (rotated structures) def /name /Ss def /dataset 3 index def /fullname [ dataset .fullname aload pop name ] def def /W TaskStreams 1 get /name /W def /long_name (weights) def /dataset 3 index def /fullname [ dataset .fullname aload pop name ] def def /H TaskStreams 0 get TaskParameterBlock .M NewDoubleBuffer nrdim 1 sub SetStreamIndex* TaskStreams 0 get .streamgrids pop * /ev undef /name /H def /long_name (communalities) def /dataset 3 index def /fullname [ dataset .fullname aload pop name ] def def /S STREAM TaskParameterBlock .L NewDoubleBuffer 1 SetStreamIndex* Ss .evrot * /name /S def /long_name (energy) def /dataset 3 index def /fullname [ dataset .fullname aload pop name ] def def /AT STREAM TaskParameterBlock .L dup mul NewDoubleBuffer 2 SetStreamIndex* TaskStreams 0 get .ev Ss .evrot * /name /AT def /long_name (varimax rotation) def /dataset 3 index def /fullname [ dataset .fullname aload pop name ] def def /Ts Ts sv div streamgridarray { name /ev eq { pop } if } forall Ts .ndim 1 sub REORDER AT ev mulsum /dataset 3 index def /name /Ts def /fullname [ dataset .fullname aload pop name ] def def /sv undef } |
| BLD | { false 1 index DATASETbot ==noprintdataset { ifvarcase caseexec } forsome } |
| BLD | tableobject |
| BLD | { counttoobject dup 1 eq { pop ev exch 1 exch RANGE } { pop ev 3 1 roll RANGE } ifelse varimax: :varimax } |
| BLD | { currentobject 3 1 roll cvx /dodefasvarKeepRestrictions cvx 4 array astore cvx dup 1 get exch pdef } |
| BLD | { { /meansq0 (mean sq) apply1get1_complementgrids } /meansqover gridarray1fn } |
| BLD | { exch removeextrausingDS 1 index last dup subgrid name exch def last 3 index exec dup totype /arraytype eq { codedstringtostream nip } if nip dup totype /streamtype eq { getrealization } if nip nip } |
| BLD | { 2 /poestudnt publicproc: { A dof } inputs dof type /objecttype eq { A dof 2 array astore { todouble toNaN8 } forall 1 index 0.0 mul add 1 index .chunksize 1 integerarray astore poestudntdof0 } { A todouble toNaN8 chunksize dof 2 integerarray astore poestudnt0 } ifelse TaskStreams 0 get TaskParameterBlock 0 get NewBuffer /fullname [ /poestudnt A .fullname ] def 1output :publicproc } |
| BLD | { WWWinfo .url-q (") rsearch pop pop pop redirectto } |
| BLD | { 1347990070 set_code_last_modified 2 index totype /arraytype eq not { 1 index xcheck { [ ] exch } { { getcptvars } 3 1 roll } ifelse } if { mydataset varproc sgrids tgrids } inputs /==alias /cptargs def /cptargs 1 index def /auxdata [ ] def tgrids length 0 gt { tgrids 0 get totype /streamtype eq { /time tgrids 0 get def /tgrids time .streamgridarray def } { /time tgrids 0 get def } ifelse } if mydataset totype /streamtype eq { /mydata [ mydataset ] def } { mydataset [ varproc dup type /arraytype eq { counttomark 2 idiv { REORDER counttomark 1 roll } repeat } if ] nip /mydata exch def } ifelse code_last_modified mydata { getlast_modified? { nip imax } { pop } ifelse } forall mimeheadersetlastmod sgrids length 0 gt { mydata { sgrids REORDER sgrids length 1 gt { sgrids 1 get units /degree_north eq { high low RANGE } { pop } ifelse } if } forall mydata astore pop } if 0 mydata { .ndim imax } forall 3 lt /stationdata? exch def stationdata? { /auxdata [ mydata { units /degree_east eq { /name /X def } if units /degree_north eq { /name /Y def } if ndim 1 gt { pop } if } forall ] def /mydata [ mydata { ndim 1 le { pop } if } forall ] def mydata length 0 eq { /mydata auxdata def /auxdata [ ] def } if } if PS2 exch setplotstream (xmlns:cpt=http://iri.columbia.edu/CPT/v10/ ) PSprint false mydata { /standard_name known or } forall { (xmlns:cf=http://cf-pcmdi.llnl.gov/documents/cf-conventions/1.4/ ) PSprint } if (cpt:nfields=) PSprint 0 mydata { .nchunk add } forall 1 tgrids { .npts mul } forall idiv s== PSprint ( ) PSprint currentobject /time getknown { (cpt:T) PSprint ( %=CPT[) name cvntos (]) 3array astore concat exch dup totype /gridtype eq { 1 array astore } { [ exch streamgrids counttomark -1 roll ] } ifelse codedstringtostream 1 subplot: PSprint :subplot ( ) PSprint } if mydata 0 get mydata length 1 gt { mydata 1 1 index length 1 sub getinterval { 1 index .nchunk 1 index .nchunk gt stationdata? not { 1 index .nchunk 1 gt and } if { exch } if pop } forall } if stationdata? { ndim 1 gt { 2 RECHUNK } { 1 RECHUNK } ifelse } if nchunk 1 gt { plotstreamflush achunk array astore beginPlotLoop } if 1 subplot: mark mydata { streamrescaleonlyifnecessary nrdim 0 eq { stationdata? { 1 RECHUNK null tgrids 0 get } if } { chunk 1 eq { stationdata? { exch 2 RECHUNK exch tgrids 0 get } { null } ifelse } if } ifelse [ (cpt:field=) counttomark 3 add index .name cvntos stationdata? not { counttomark 3 add index .achunk array astore { get_units timeunits? nip { .name cvntos (, cpt:) exch (=%=CPT[) 1 index (]) } { .name cvntos (, cpt:) exch (=%=[) 1 index (]) } ifelse } forall } if (, cpt:nrow=) counttomark 1 add index dup null eq { pop 1 } { .npts } ifelse s== (, cpt:ncol=) counttomark 2 add index dup null eq { pop 1 } { .npts } ifelse s== (, cpt:row=) counttomark 1 add index .name cvntos counttomark 1 add index null eq not { (, cpt:col=) stationdata? { auxdata length 0 eq (index) (station) ifelse } { counttomark 2 add index .name cvntos } ifelse } if counttomark 3 add index /units getknown { cvntos (, cpt:units=) exch } if counttomark 3 add index /standard_name getknown { cvntos (, cf:standard_name=) exch } if counttomark 3 add index .getmissing_value? { s== (, cpt:missing=) exch } if cptargs /time getknown { dup totype /streamtype eq { (, cpt:T=%=CPT[) exch .name cvntos (]) } { pop } ifelse } if ( ) counttomark 2 add index null eq { ( ) counttomark 3 add index .name cvntos ( ) } if ] concat 3 index .achunk cptargs /time getknown { dup totype /streamtype eq { exch 1 add array astore } { pop array astore } ifelse } { array astore } ifelse codedstringtostream 1 index null eq { nip } if dup PSprint counttomark 2 sub index dup null eq { pop } { (%=CPT[) name cvntos (]) 3array astore concat exch 1 array astore codedstringtostream ( %s) sprintf 1 subplot: PSprint :subplot ( ) PSprint auxdata { (cpt:) PSprint name cvntos PSprint (%=CPT[) name cvntos (]) 3array astore concat exch [ exch streamgrids exch ] codedstringtostream ( %s) sprintf 1 subplot: PSprint :subplot ( ) PSprint } forall } ifelse stationdata? not { counttomark subplot: } if counttomark 3 eq { time 0 RECHUNK exch } if exch (%=CPT[) name cvntos (]) 3array astore concat exch .streamgridarray 0 1 getinterval codedstringtostream 1 RECHUNK exch plotstream counttomark matchachunk 3 index null eq { 4 -1 roll pop 3 index .name 4 1 roll } if 4 index psS new setPS 4 index .bufferwordsize store nwordsize chunk 2 eq { .npts store ny .npts } { .npts store ny 1 } ifelse store nx nip cptv10types 6 index datatype nip getknown { exec } { (Not supported datatype) } ifelse lastinputisnextplotstream stationdata? not { :subplot } if } forall pop PSclose plotstream plotloop { 0 SetStreamIndex* loopStream .streamgrids * endLoop } if realize pop pop pop } |
| BLD | 0 47 object /objecttype { (not ready for datatype) error } def /htmlprinttype { (not ready for datatype) error } def /gridtype { (not ready for datatype) error } def /xmlfiletype { (not ready for datatype) error } def /linktype { (not ready for datatype) error } def /booleantype { (not ready for datatype) error } def /nametype { (not ready for datatype) error } def /messagetype { (not ready for datatype) error } def /figobjecttype { (not ready for datatype) error } def /realtype { (not ready for datatype) error } def /realarraytype { cptv10tsv0r4 } def /namearraytype { (not ready for datatype) error } def /shortarraytype { 6 -1 roll toi4 6 1 roll cptv10tsv0i4 } def /datasettype { (not ready for datatype) error } def /giffiletype { (not ready for datatype) error } def /integertype { (not ready for datatype) error } def /arraytype { (not ready for datatype) error } def /streamtype { (not ready for datatype) error } def /htmlfiletype { (not ready for datatype) error } def /jpegfiletype { (not ready for datatype) error } def /pendingdatasettype { (not ready for datatype) error } def /bytearraytype { 6 -1 roll toi4 6 1 roll cptv10tsv0i4 } def /stringtype { 6 -1 roll toi4 6 1 roll cptv10tsv0i4 } def /imageobjecttype { (not ready for datatype) error } def /figviewtype { (not ready for datatype) error } def /nulltype { (not ready for datatype) error } def /marktype { (not ready for datatype) error } def /operatortype { (not ready for datatype) error } def /geometrytype { (not ready for datatype) error } def /integerarraytype { cptv10tsv0i4 } def /doublearraytype { cptv10tsv0r8 } def |
| BLD | CaseListpops2 /gridtype { pop pop pop true leave } def |
| BLD | FilterSet /streamtype { 3 -1 roll decompress 3 1 roll 2 index 2 index .name getknown { exec 3 -1 roll pop exch 2 index .getmissing_value null eq { pop newmonthlyAverage0 } { 3 1 roll 1 index 0 replaceNaN 1 index newmonthlyAverage0 3 1 roll exch dataflag exch newmonthlyAverage0 3 -1 roll normalize } ifelse } { pop pop } ifelse } def /gridtype { pop 1 index .name 1 index .name eq { pop monthlyedgesgrid partialgrid monthtimegrid } { pop } ifelse } def |
| BLD | { foralldatasetsCase 5 object exch dup null eq { pop } { /gridtype exch def } ifelse exch dup null eq { pop } { /streamtype exch def } ifelse exch dup null eq { pop } { /datasettypeexit0 exch def } ifelse exch dup null eq { pop } { /datasettype0 exch def } ifelse /myCases 1 index def /==alias /myCases cvx def mycasedefs 1 object /myCases 3 -1 roll def begin startdataset mycaseexec enddataset end } |
| BLD | { rootmeansq } |
| BLD | { 4 /butt_filter: publicproc: buttparams buttS new (lp) store ft 2 index store w2 0.7 store flat 0.7 store att 2 store ford } |
| BLD | { dup type /objecttype eq { dup .from exch .to RANGE } { 1 { VALUE0 } /VALUE allstreams1 } ifelse } |
| BLD | { (downloadsNCL) htmlprint } |
| BLD | { exch npts 2 le { nip } { removeextrausingDS 1 index last dup subgrid name exch def last 3 index exec dup totype /arraytype eq { codedstringtostream nip } if nip dup totype /streamtype eq { getrealization } if dup remotefileexistssetlastmod? { pop nip } { pop dup /myintegralgrid getknown { first secondtolast subgrid exch first secondtolast subgrid exch /myintegralgrid exch def } { first secondtolast subgrid } ifelse exch remoteremoveextrausing0 } ifelse } ifelse } |
| BLD | { gridarray1hold astore pop dup type dup /realtype eq exch /integertype eq or not { 0.0 } if 1 index type /objecttype eq { emptyarray exch } if 1 gridarray1hold aload pop allstreams1 } |
| BLD | { mark 1 index .allnames counttomark namearray astore nip cvnatoslurl } |
| BLD | { table: } |
| BLD | { get_scale_min number? { getscale_factor mul getadd_offset add } if } |
| BLD | { (missingfiles) htmlprint } |
| BLD | { dup type /nametype eq { 2 index totype /gridtype eq { 5 } { 3 } ifelse } { 1 index totype /gridtype eq { 4 } { 2 } ifelse } ifelse /BOXEDGES publicproc: dup type /nametype eq { parameter } if dup totype /stringtype eq { geoobject } if dup totype /streamtype eq { geoboundingbox } if 1 index totype /gridtype ne { exch getXY? not { (no spatial grids) error } if 4 -1 roll } if { datastream mabs mord mybbox } inputs /outbbox mybbox def mybbox length 5 ge { datastream getCRS nip mybbox 4 get eq not { mybbox datastream getCRS exch .getX .units projectbbox /outbbox exch def } if } if datastream mabs null ne { mabs outbbox 0 get outbbox 2 get RANGEEDGES } if mord null ne { mord outbbox 1 get outbbox 3 get RANGEEDGES } if 1output :publicproc } |
| BLD | { currentobject 3 1 roll cvx /dodefasvarsilentKeepRestrictions cvx 4 array astore cvx dup 1 get exch pdef } |
| BLD | FilterSet /streamtype { 2 index 2 index known { exch cvx exec exch shiftGRID0 } { pop pop } ifelse } def /gridtype { 2 index .name 2 index eq { nip shiftGRIDgrid nip } { pop pop } ifelse } def |
| BLD | { 4 /seasonalfreqLT publicproc: { mystream monrange thold minfrac } inputs mystream a: dataflag T monthlyAverage minfrac flagge 0 maskle :a: thold maskge dataflag T minfrac monthlyAverage a: T (days since 1960-01-01) streamgridunitconvert T differential_mul T :a: .T :a replaceGRID :a mul T monrange 1.0 seasonalAverage monrange (-) search { nip pop } if 0 3 getinterval interp monrange (-) search { nip nip } if 0 3 getinterval interp sub dup 0 ge { 1 add } { 1 add 12 add } ifelse mul :publicproc nip } |
| BLD | { gridarray1hold astore pop dup type /objecttype eq { emptyarray exch } if 0 gridarray1hold aload pop allstreams1 } |
| BLD | { dup totype /figviewtype eq } |
| BLD | { 2 array astore cvx nopdefasvarsilent } |
| BLD | { { complementgridarray { maxfnof0 maxfnof0dp } (max) apply1get1nocount } /maxover gridarray1fn } |
| BLD | { foralldatasetsCase 5 object exch dup null eq { pop } { /streamtype exch def } ifelse exch dup null eq { pop } { /datasettype exch def } ifelse /myCases 1 index def /==alias /myCases cvx def exch startdataset mycaseexec enddataset pop } |
| BLD | FilterSet /streamtype { currentobject 2 index known { exch cvx exec exch splitstreamgridstream } { pop pop } ifelse } def /gridtype { pop pop } def |
| BLD | { exch npts 2 le { nip } { removeextrausingDS 1 index last dup subgrid name exch def last 3 index exec dup totype /arraytype eq { codedstringtostream nip } if nip dup totype /streamtype eq { getrealization } if dup fileexists? { deflastmod nip } { pop dup /myintegralgrid getknown { first secondtolast subgrid exch first secondtolast subgrid exch /myintegralgrid exch def } { first secondtolast subgrid } ifelse exch removeextrausing0 } ifelse } ifelse } |
| BLD | 0 11 object /buttS buttS def /flatness { store flat } def /freqCut2 { store w2 } def /attenuation { store att } def /filterType { store ft } def /forder { store ford } def |
| BLD | { rootmeansqanom } |
| BLD | { dup type /nametype eq { gridnobyname nip 0 ne } { dup totype /datasettype eq { exch .relativename pknown } { false exch { 2 index exch gridnobyname 0 ne nip or } forall nip } ifelse } ifelse } |
| BLD | { svd-part1 gappy-data? { dup /history known not { /history null def } if history exch eval 0 maskle SELECT exch /history exch def history null eq { /history undef } if } if proclevel 0 get 1 eq { /procargs [ procargs aload pop gappy-data? { /gappy-data cvx } if spatial-mean? { /spatial-mean cvx } if temporal-mean? { /temporal-mean cvx } if /:svd cvx ] store } if svd-part2 :publicproc svd-part3 } |
| BLD | { (dodsdatasets) htmlprint } |
| BLD | FilterSet /streamtype { boxAveragedoarg 1 index boxgrids allknown { /boxgrids 2 index [ boxgrids { currentobject exch get } forall ] nip def 0 1 boxgrids length 1 sub { boxgrids 1 index get exch boxargs exch get ChangeGridStep name exch def } for exch boxgrids 1 index totype /gridtype eq { 1 index 1 index 0 get eq { pop .name exec } { pop } ifelse } { exch decompress exch boxargs dup length 1 sub get regridAverageSP toreal } ifelse nip } { pop } ifelse } def /gridtype { boxAveragedoarg 1 index .name boxgrids anymatch { 0 1 boxgrids length 1 sub { boxgrids 1 index get name eq { boxargs exch get nip ChangeGridStep leave } { pop } ifelse } for } { pop } ifelse } def |
| BLD | { 2 index totype /arraytype eq { 3 index 3 index 2 { 3 index [ exch { .name } forall ] } repeat 4 /svd publicproc: pop pop pop pop } { 2 index 2 { 2 index [ exch { .name } forall ] } repeat 3 /svd publicproc: pop pop pop } ifelse svdparams svd-part1 svd-part2 :publicproc svd-part3 } |
| BLD | { realorintegertype? not { 0.0 } if 1 index totype /gridtype ne { T exch } if 3 /pentadAverage publicproc: 2 array astore cvx newpentadAverageFS 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | FilterSet /streamtype { 3 -1 roll decompress 3 1 roll 2 index 2 index .name getknown { exec 3 -1 roll pop exch 2 index .getmissing_value null eq { pop newpentadAverage0 } { 3 1 roll 1 index 0 replaceNaN 1 index newpentadAverage0 3 1 roll exch dataflag exch newpentadAverage0 3 -1 roll normalize } ifelse } { pop pop } ifelse } def /gridtype { pop 1 index .name 1 index .name eq { pop pentadedgesgrid (pentads since 1961-01-01) gridunitconvert partialgrid } { pop } ifelse } def |
| BLD | { 2 /setmissing_value publicproc: setmissingvalueCase 1 object exch /filterargs exch def datasetexec :publicproc } |
| BLD | { 3 /flexseastotAvgFill publicproc: { mystream daterange minfrac } inputs mystream T daterange minfrac seasonalAverage T differential_mul :publicproc nip } |
| BLD | { counttoobject 1 sub index type /arraytype ne { 3 -1 roll 1 array astore 3 1 roll } if counttoobject 1 sub array astore null 1 index length 5 add object exch /boxargs exch def exch /boxgrids exch cvlit def } |
| BLD | { allgrid dup type /nametype eq { get exec } { dup totype /datasettype eq { exch .relativename pget } { [ exch { counttomark 1 add index exch getknown pop } forall ] nip } ifelse } ifelse } |
| BLD | { (auxinfo) xmlprint } |
| BLD | { appendprep 0 { appendstream } /appenddataset allstreams1 currentfilepattern 0 get -1 ne { /filepattern currentfilepattern 0 get def } if } |
| BLD | { get_calendar exch units exch maybeconvertdays units exch monthtimename unitconvertbyattribute name units ordered low scale_factor mul getadd_offset add rm19602ymd pop pop 1 1 ymd2rm1960 12 high scale_factor mul getadd_offset add rm19602ymd pop pop 1 add 1 1 ymd2rm1960 NewEvenGRID /pointwidth 0 def 1 index .add_offset /add_offset exch def 1 index .scale_factor /scale_factor exch def 1 index /standard_name getknown { /standard_name exch def } if 1 index first last gt nip { last first subgrid } if nip exch unitconvertbyattribute exch /units exch def exch /calendar exch def } |
| BLD | -operator- |
| BLD | { chunksize chunksum0 TaskStreams 0 get 1 NewBuffer 0 SetStreamIndex* TaskStreams 0 get .achunk pop * /fullname [ [ ($Sigma sub {) TaskStreams 0 get .chunks== (}$) ] concat fullname ] def } |
| BLD | { exch 5 object exch /datatype /shortarraytype def /bufferwordsize 2 def 2 NewSizedBuffer0 NewBufferCheck } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | lanheader |
| BLD | { 2 index type dup /realtype eq exch /integertype eq or not { 0 3 1 roll } if 3 index type /objecttype eq { emptyarray 4 1 roll } if { mydata myavggrids mymincntwght myfn myfnname } inputs 23 object mydata SIRecord pop pop mydata .datatype /stringtype eq { mydata .bufferwordsize 1 eq } { true } ifelse { /mydata mydata decompress toNaN def /mygrids mydata myavggrids complementgridarray0 nip def /postprocessgonegrid { dup integralgrid first last subgridvalues partialgrid } def apply1get1sub } { pop null } ifelse } |
| BLD | -operator- |
| BLD | { 3 copy mul add dup 73 div floor 1960 add exch 73 mod dup 0 lt { 73 add } if 5 mul dup 59 gt { 1 index daysperyear 366 eq { 1 add } if } if exch 1 exch 0.5 exch julian_day getadd_offset sub add 0.5 sub nip 3 1 roll } |
| BLD | -operator- |
| BLD | { datatype /stringtype eq { toNaNu1 } { datatype /shortarraytype eq { toNaNshort } if } ifelse datatype /doublearraytype eq { MVtoNaN8 } { toreal MVtoNaN4 streamrescaleinNaN } ifelse } |
| BLD | -operator- |
| BLD | { torealorcomplexfilters datatype get exec } |
| BLD | -operator- |
| BLD | { 4 /weaver: publicproc: weaverparams weaverS new EWNS 3 setdecimal 0 store fine 180 store NX -180 store XL 180 store XH 1 store xper 90 store NY -90 store YL 90 store YH 0 store yper -1 store center 0 store DIST true store ifweave false store ifemphasize } |
| BLD | { exch 5 object exch /datatype /stringtype def /bufferwordsize 1 def 1 NewSizedBuffer0 NewBufferCheck } |
| BLD | -operator- |
| BLD | { (downloadsferret) htmlprint } |
| BLD | 0 11 object /shortarraytype { chunksize shorttoreal0 TaskStreams 0 get chunksize NewRealBuffer units /real eq { scale_factor 1 eq { /units /integer cvntos def } if } if } def /complexarraytype { } def /longintegerarraytype { chunksize longintegertoreal0 TaskStreams 0 get chunksize NewRealBuffer } def /realarraytype { } def /complexdoublearraytype { chunksize 2 mul doubletoreal0 TaskStreams 0 get chunksize NewComplexBuffer } def /integerarraytype { chunksize integertoreal0 TaskStreams 0 get chunksize NewRealBuffer } def /stringtype { chunksize stringtoreal0 TaskStreams 0 get chunksize NewRealBuffer /bufferwordsize STREAM 1 index get def } def /namearraytype { } def /realtype { } def /doublearraytype { chunksize doubletoreal0 TaskStreams 0 get chunksize NewRealBuffer } def /nametype { } def |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | { get_calendar /360 eq { units cvntos ( since ) search { maybeshiftmonthscales 1 index known { exch 3 -1 roll ( ) search { (-01-01) rsearch { 7 npop } { (-) rsearch { interp 1 sub 30.0 div nip exch (-) rsearch { nip interp dup type /realtype eq { 0.5 add } if cvi 1 sub 3 -1 roll add dup 0.0 eq { 6 npop } { 6 1 roll nip (-01-01) 3 -1 roll ( ) exch 6array astore concat preferredunitname 3 -1 roll 2 object 3 1 roll /units exch def maybeshiftmonthscales units cvntos ( since ) search { nip nip } if getknown { mul } if getadd_offset add /add_offset exch def } ifelse } { 6 npop } ifelse } { 5 npop } ifelse } ifelse } { pop pop pop } ifelse } { pop pop pop } ifelse } { pop } ifelse } if } |
| BLD | { counttoobject 3 eq { 0.0 } if 6 /evengridAverage publicproc: 4 1 roll name units gridtype 6 3 roll NewEvenGRID exch regridAverage :publicproc } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | { units (degreeC) eq { fullname exch name exch 1.8 mul 32 add /units (degreeF) def exch /name exch def exch /fullname exch def } if } |
| BLD | { name units gridtype dup periodic eq { pop ordered } if 4 3 roll NewGRID REGRID } |
| BLD | -operator- |
| BLD | { (streamhelp) htmlprint } |
| BLD | { UnitsConversion 1 index known { UnitsConversion exch get exec } if } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | { array astore dup aload length commonachunk1pt null 1 index length object 1 index { name exch def } forall { streams theachunk theachunkobj } inputs streams { dup type /objecttype eq { nrdim mark chunk 2 add index .achunk array astore { name theachunkobj exch known { pop } if } forall theachunk aload pop NewStreamPtr setSIRecord } if } forall streams length 1 add -1 roll pop } |
| BLD | { 3 /setpointwidthreplaceGRID publicproc: 1 index 1 object exch /pointwidth exch def replaceGRID :publicproc } |
| BLD | { { stream1 stream2 gridarray Wght Wmin } inputs Wght type /stringtype eq { /Wght stream2 Wght interp nip def } if stream2 dup Wght mul 0 replaceNaN gridarray { stream1 1 index .name getgridbyname nip regridLinear0 } forall exch dataflag Wght mul gridarray { stream1 1 index .name getgridbyname nip regridLinear0 } forall Wmin Wght mul gridarray { 2 copy gridno nip 0 eq { pop } { stream1 1 index .name getgridbyname nip regridLinear0 } ifelse } forall normalize exch .stream1 exch } |
| BLD | -operator- |
| BLD | { get_calendar pentadedgesversions exch get exec } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | 0 23 object /year { 2592000 mul } def /date { 2592000 mul } def /monthtime { 2592000 mul } def (months since 1960-01-01)cvn { 2592000 mul } def /month { 2592000 mul } def |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | 0 17 object /360 { pentadedgesgrid360 } def /gregorian { pentadedgesgridjd } def /proleptic_gregorian { pentadedgesgridjd } def /360_day { pentadedgesgrid360 } def /365_day { pentadedgesgrid365 } def /365 { pentadedgesgrid365 } def /GREGORIAN { pentadedgesgridjd } def /standard { pentadedgesgridjd } def /NOLEAP { pentadedgesgrid365 } def /noleap { pentadedgesgrid365 } def |
| BLD | 0 11 object /shortarraytype { chunksize shorttoi10 TaskStreams 0 get chunksize NewI1Buffer units /real eq { scale_factor 1 eq { /units /integer cvntos def } if } if } def /realarraytype { chunksize realtoi10 TaskStreams 0 get chunksize NewI1Buffer } def /stringtype { } def /integerarraytype { chunksize integertoi10 TaskStreams 0 get chunksize NewI1Buffer } def /doublearraytype { chunksize doubletoi10 TaskStreams 0 get chunksize NewI1Buffer } def /realtype { chunksize realtoi10 TaskStreams 0 get chunksize NewI1Buffer } def |
| BLD | { counttoobject 1 eq { 0.0 } if 4 /runningAverage publicproc: 4 -1 roll decompress 4 1 roll 3 index .missing_value null eq { pop runningAverage0 } { runningAverageNaN } ifelse :publicproc } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | { dup type /stringtype eq { pop } if dup type /arraytype eq { exch decompress 1 index { 2 copy .name getgridbyname nip exch SAMPLE } forall exch aload length REORDER } { decompress } ifelse } |
| BLD | { 0.0 replaceNaN myX integral myX .name exec last VALUE myY integral myY .name exec last VALUE } |
| BLD | { { mydataset spatialgrids timegrids nclusters } inputs mydataset spatialgrids aload pop timegrids aload pop spatialgrids length timegrids length add REORDER toNaN spatialgrids timegrids svd nclusters varimax .Ss dup abs spatialgrids maxover div dup 0 flagge spatialgrids average 0.5 flaglt 2 mul 1 exch sub mul [ evrot ] dominant_class spatialgrids REORDER toi4 valid_max stepdarktolightgreenscale /scale_symmetric false def 1output } |
| BLD | { dup type /arraytype eq { 3 -1 roll decompress toNaN 3 -1 roll decompress toNaN 3 -1 roll 3 } { exch decompress toNaN exch decompress toNaN 2 } ifelse /BofA=C-bounded publicproc: dup type /arraytype eq { 3 1 roll exch decompress toreal exch decompress toreal 3 -1 roll 3 -1 roll 1 index { gridnobyname dup 0 eq { pop } { gridbyno removeGRID } ifelse } forall 3 1 roll aload length REORDER exch 0 RECHUNK exch } { exch decompress toreal exch decompress toreal } ifelse nptgrids length 1 eq { 1 RECHUNK copyachunk chunk pop toreal copyachunk chunksize 3 index .chunksize 2 integerarray astore dolinint3bounded TaskStreams 0 get 1 object /datatype TaskStreams 1 get .datatype def chunksize NewBuffer /name TaskStreams 1 get .name def /fullname [ TaskStreams 1 get .fullname dup type /arraytype eq { aload pop } if TaskStreams 0 get .fullname dup type /arraytype ne { 1 array astore } if ] def } { 2 matchachunk chunk pop toreal copyachunk chunksize 3 index .chunksize 2 integerarray astore dolinint3bounded TaskStreams 0 get 1 object /datatype TaskStreams 1 get .datatype def chunksize NewBuffer /name TaskStreams 1 get .name def /fullname [ TaskStreams 1 get .fullname dup type /arraytype eq { aload pop } if TaskStreams 0 get .fullname dup type /arraytype ne { 1 array astore } if ] def /long_name TaskStreams 1 get /long_name getknown not { TaskStreams 1 get .name cvntos } if dup type /arraytype eq { exec } if def /units TaskStreams 1 get .units def } ifelse DATAAUTO :publicproc } |
| BLD | { { startcolormap 0.0 1.0 RANGE transparent MediumBlue MediumBlue 0.0 VALUE MediumBlue MediumBlue 0.05 bandmax blue blue 0.1 bandmax RoyalBlue RoyalBlue 0.15 bandmax CornflowerBlue CornflowerBlue 0.2 bandmax DeepSkyBlue DeepSkyBlue 0.25 bandmax aquamarine aquamarine 0.3 bandmax MediumAquamarine MediumAquamarine 0.35 bandmax ForestGreen ForestGreen 0.4 bandmax LimeGreen LimeGreen 0.45 bandmax gold gold 0.5 bandmax BrightMustard BrightMustard 0.55 bandmax moccasin moccasin 0.6 bandmax moccasin moccasin 0.65 bandmax DarkOrange DarkOrange 0.7 bandmax OrangeRed OrangeRed 0.75 bandmax red red 0.8 bandmax firebrick firebrick 0.85 bandmax MediumOrchid MediumOrchid 0.9 bandmax DarkOrchid DarkOrchid 0.95 bandmax NavyBlue NavyBlue 1.0 bandmax NavyBlue endcolormap } /percentiles_colors_40 docolorscale } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | { 3 /runningAverage publicproc: { boxgrid boxinterval } inputs exch a: boxgrid 0 boxinterval 2 index .step sub shiftdatashort dup boxgrid .name get /pointwidth boxgrid .name cvntos (_lag) append cvn cvx exec .width def step pointwidth exch sub 0.5 mul shiftGRID [ boxgrid .name cvntos (_lag) append cvn cvx exec ] average :a: .nrdim RECHUNK toreal :a: .fullname /fullname exch def :a: .history /history exch def :a: .units /units exch def :a: .name /name exch def (Averaged in ) boxgrid .name cvntos append ( with overlapping interval ) append boxinterval s== append addhistory :a 1output :publicproc } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | 0 11 object /shortarraytype { chunksize shorttoi40 TaskStreams 0 get chunksize NewIntegerBuffer units /real eq { scale_factor 1 eq { /units /integer cvntos def } if } if } def /realarraytype { chunksize realtoi40 TaskStreams 0 get chunksize NewIntegerBuffer } def /stringtype { chunksize stringtoi40 TaskStreams 0 get chunksize NewIntegerBuffer /bufferwordsize STREAM 1 index get def } def /integerarraytype { } def /doublearraytype { chunksize doubletoi40 TaskStreams 0 get chunksize NewIntegerBuffer } def /realtype { chunksize realtoi40 TaskStreams 0 get chunksize NewIntegerBuffer } def |
| BLD | { npts 1 gt { mygridsdict name known { .npts { countifknown } /countif myvars ! } { .npts mul } ifelse } { pop } ifelse } |
| BLD | { 5 /regridLinear publicproc: 3 index .missing_value null eq 2 index 1.0 eq and { pop pop dup type /objecttype eq { 2 index 1 index .name getgridbyname nip regridLinear0 } { { 2 index decompress 1 index .name getgridbyname nip regridLinear0 } forall } ifelse } { 1 index 1.0 eq { nip 1 index type /objecttype eq { 3 index 2 index .name getgridbyname nip exch regridLinearNaN } { regridLinearNaNver2 } ifelse } { regridLinearNaNWght } ifelse } ifelse :publicproc } |
| BLD | { dup type /arraytype eq { 3 -1 roll decompress toNaN 3 -1 roll decompress toNaN 3 -1 roll 3 } { exch decompress toNaN exch decompress toNaN 2 } ifelse /CofA=B-bounded publicproc: dup type /arraytype eq { 3 1 roll exch decompress exch decompress 3 -1 roll 3 -1 roll 1 index { gridnobyname dup 0 eq { pop } { gridbyno removeGRID } ifelse } forall 3 1 roll aload length REORDER exch 0 RECHUNK exch } { exch decompress exch decompress } ifelse nptgrids length 1 eq { 1 RECHUNK copyachunk chunk pop toreal copyachunk exch chunksize 3 index .chunksize 2 integerarray astore dolinint3bounded TaskStreams 0 get 1 object /datatype TaskStreams 1 get .datatype def chunksize NewBuffer /name TaskStreams 1 get .name def /fullname [ TaskStreams 1 get .fullname dup type /arraytype eq { aload pop } if TaskStreams 0 get .fullname dup type /arraytype ne { 1 array astore } if ] def } { 2 matchachunk chunk pop toreal copyachunk exch chunksize 3 index .chunksize 2 integerarray astore dolinint3bounded TaskStreams 0 get 1 object /datatype TaskStreams 1 get .datatype def chunksize NewBuffer /name TaskStreams 1 get .name def /fullname [ TaskStreams 1 get .fullname dup type /arraytype eq { aload pop } if TaskStreams 0 get .fullname dup type /arraytype ne { 1 array astore } if ] def /long_name TaskStreams 1 get /long_name getknown not { TaskStreams 1 get .name cvntos } if dup type /arraytype eq { exec } if def /units TaskStreams 1 get .units def } ifelse DATAAUTO :publicproc } |
| BLD | { 4 /definite-integral publicproc: { stream grid ifrom ito } inputs /mygridname grid .name cvx def /thegrid { mygridname exec } def stream grid integral thegrid ifrom dup type /stringtype eq { readoffgridunits } if ito dup type /stringtype eq { readoffgridunits } if 2 copy exch sub exch silentGRID dup thegrid last VALUE exch thegrid first VALUE sub 1output :publicproc } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | { 4 /k-means_svddiff_init publicproc: { mydataset spatialgrids timegrids nclusters } inputs mydataset spatialgrids aload pop timegrids aload pop spatialgrids length timegrids length add REORDER toNaN dup spatialgrids average sub spatialgrids timegrids svd .Ss ev 1 nclusters 1 sub RANGE grid: /name /ss def values: -1 1 :values :grid mul [ ss ev ] dominant_class /CLIST undef /name /mode def classify dup spatialgrids average [ mode ] sort_by [ rank ] dominant_class nclusters min /valid_max nclusters def /scale_max nclusters def spatialgrids REORDER toi4 nclusters stepdarktolightgreenscale /scale_symmetric false def 1output :publicproc } |
| BLD | -operator- |
| BLD | { (datafiles) htmlprint } |
| BLD | -operator- |
| BLD | { dup /SIRecord known { dup /bufferSIRecord known { bufferSIRecord SIRecord ne { /bufferSIRecord SIRecord def } if } { /bufferSIRecord SIRecord def } ifelse } if } |
| BLD | { 2 index type dup /realtype eq exch /integertype eq or not { 0 3 1 roll } if 3 index type /objecttype eq { emptyarray 4 1 roll } if { mydata myavggrids mymincntwght myfn myfnname } inputs 23 object mydata SIRecord pop pop mydata .datatype /stringtype eq { mydata .bufferwordsize 1 eq } { true } ifelse { /mydata mydata decompress toNaN def /mygrids mydata myavggrids complementgridarray0 nip def /postprocessgonegrid { null } def apply1get1sub } { pop null } ifelse } |
| BLD | { 0 RECHUNK copyachunk placelabelsS new 20 store nx 10 store ny 1 index .achunk 1 sub { pop } repeat .npts store npplt 2 index .npts store npts 4 index .plotfirst store xl 4 index .plotlast store xh 3 index .plotfirst store yl 3 index .plotlast store yh placelabels0 TaskStreams 0 get TaskParameterBlock nx ny mul 3 mul nip NewBuffer /J TaskParameterBlock nx ny mul nip NewIntegerGRID name exch def 1 SetStreamIndex* J TaskStreams 3 get .achunk pop * TaskStreams 1 get TaskParameterBlock nx ny mul 3 mul nip NewBuffer 1 index .J name exch def 1 SetStreamIndex* J TaskStreams 3 get .achunk pop * TaskStreams 3 get TaskParameterBlock nx ny mul 3 mul nip NewBuffer 1 index .J name exch def 1 SetStreamIndex* J TaskStreams 3 get .achunk pop * 3 { 3 1 roll TaskStreams 3 get .achunk 1 sub { pop } repeat last VALUE } repeat } |
| BLD | { -operator- -operator- -operator- /realtype -operator- -operator- /integertype -operator- -operator- { 3 1 -operator- -operator- -operator- /objecttype -operator- { emptyarray } -operator- null 1 -operator- -operator- -operator- -operator- { name -operator- -operator- } -operator- -operator- decompress -operator- [ -operator- [ streamgrids -operator- { 2 -operator- .name -operator- { -operator- } { -operator- } -operator- } -operator- -operator- -operator- 3 -1 -operator- } { -operator- -operator- /objecttype -operator- { emptyarray } -operator- null 1 -operator- -operator- -operator- -operator- { name -operator- -operator- } -operator- -operator- decompress -operator- [ -operator- [ streamgrids -operator- { 2 -operator- .name -operator- { -operator- } { -operator- } -operator- } -operator- -operator- -operator- } -operator- } |
| BLD | { datatype datatypearrayCases exch get exec } |
| BLD | { { D mX mY mX2 mY2 oalpha ox oy } inputs /D D mX mY 2 REORDER toNaN def D X copyachunk Y copyachunk mX2 copyachunk mY2 copyachunk rotS new X .npts store N Y .npts store M mX2 .npts store Np mY2 .npts store Mp oalpha store alpha ox store olong oy store olat rotatedata0 STREAM TaskParameterBlock Np Mp mul 2 mul nip NewBuffer pop STREAM TaskParameterBlock Np Mp mul nip NewBuffer pop STREAM TaskParameterBlock Np Mp mul nip NewBuffer pop TaskStreams 0 get TaskParameterBlock Np Mp mul nip NewBuffer 2 SetStreamIndex* mX2 mY2 TaskStreams 0 get .achunk pop * [ (Rotated by ) oalpha s== ( and regridded) ] concat addhistory /missing_value NaN def nip } |
| BLD | -operator- |
| BLD | { { instream gridin gridout Wmin } inputs instream decompress 0 replaceNaN gridin gridout regridAverageSP0 exch instream dataflag gridin gridout regridAverageSP0 exch .Wmin normalize } |
| BLD | -operator- |
| BLD | -operator- |
| BLD | -operator- |
| BLD | 0 11 object /boxgrid { boxgridname exec } def |
| BLD | { exch 1 index 1 index .streamgrids .name get sample-along bumpyAvgS new null store WGHT 3 index 3 index .streamgrids gridstride nip store NX 2 index .npts store NT 3 index .chunksize NX div NT div store NR 4 -2 roll 1 index .datatype /doublearraytype eq { todouble } if 1 RECHUNK copyachunk 4 2 roll 1 index .datatype /doublearraytype eq { bumpyaverageDPfix00 } { bumpyaveragefix00 } ifelse TaskStreams 0 get chunksize NewBuffer } |
| BLD | 0 2 object /attach -operator- def /release -operator- def |
4 is not legal as a grid for grididError 404: Page Not FoundError line: 81 anhtmlserverefize 64000000 def storeError on line 0 of stdin: interpreter thinks " error" not defined 1000 |