source: CMIP6dreqbuild/trunk/src/framework/dreqPy/scope.py @ 828

Subversion URL: http://proj.badc.rl.ac.uk/svn/exarch/CMIP6dreqbuild/trunk/src/framework/dreqPy/scope.py@828
Revision 828, 55.7 KB checked in by mjuckes, 3 years ago (diff)

spid fix

Line 
1"""Date Request Scoping module
2------------------------------
3The scope.py module contains the dreqQuery class and a set of ancilliary functions. The dreqQuery class contains methods for analysing the data request.
4"""
5
6try:
7  import dreq
8  imm=1
9except:
10  import dreqPy.dreq  as dreq
11  imm=2
12
13if imm == 1:
14  from utilities import cmvFilter
15  import makeTables
16  import fgrid
17else:
18  import dreqPy.fgrid as fgrid
19  from dreqPy.utilities import cmvFilter
20  import dreqPy.makeTables as makeTables
21
22import collections, string, operator
23import sys, os
24
25odsz = {'landUse':(5,'free'), 'tau':7, 'scatratio':15, 'effectRadLi|tau':(28,'query pending'), 'vegtype':(8,'free'), 'sza5':5, 'site':(119,'73 for aquaplanet .. '), 'iceband':(5,'free'), 'dbze':15, 'spectband':(10,'free'), 'misrBands':(7,'query pending'), 'effectRadIc|tau':(28,'query pending')}
26
27python2 = True
28if sys.version_info[0] == 3:
29  python2 = False
30  from functools import reduce
31  try: 
32    from utilP3 import mlog3
33  except:
34    from dreqPy.utilP3 import mlog3
35  mlg = mlog3()
36else:
37  from utilP2 import util
38  mlg = util.mlog()
39
40class c1(object):
41  def __init__(self):
42    self.a = collections.defaultdict( int )
43class c1s(object):
44  def __init__(self):
45    self.a = collections.defaultdict( set )
46
47NT_txtopts = collections.namedtuple( 'txtopts', ['mode'] )
48
49def vfmt(ss):
50  stb = ss*1.e-12
51  if stb < .099:
52    return '%7.2fGb' % (stb*100)
53  else:
54    return '%7.2fTb' % stb
55
56class baseException(Exception):
57  """Basic exception for general use in code."""
58
59  def __init__(self,msg):
60    self.msg = 'scope:: %s' % msg
61
62  def __str__(self):
63    return repr( self.msg )
64
65  def __repr__(self):
66    return self.msg
67
68nt_mcfg = collections.namedtuple( 'mcfg', ['nho','nlo','nha','nla','nlas','nls','nh1'] )
69class cmpd(object):
70  def __init__(self,dct):
71    self.d = dct
72  def cmp(self,x,y,):
73    return cmp( self.d[x], self.d[y] )
74
75
76def filter1( a, b ):
77  if b < 0:
78    return a
79  else:
80    return min( [a,b] )
81
82def filter2( a, b, tt, tm ):
83## largest tier less than or equal to tm
84  ll = [t for t in tt if t <= tm]
85  if len( ll ) > 0:
86    t1 = [t for t in tt if t <= tm][-1]
87    it1 = tt.index(t1)
88    aa = a[it1]
89    if b < 0:
90      return aa
91    else:
92      return min( [aa,b] )
93  else:
94    return 0
95
96npy = {'1hrClimMon':24*12, 'daily':365, u'Annual':1, u'fx':0.01, u'1hr':24*365, u'3hr':8*365,
97       u'monClim':12, u'Timestep':100, u'6hr':4*365, u'day':365, u'1day':365, u'mon':12, u'yr':1,
98       u'1mon':12, 'month':12, 'year':1, 'monthly':12, 'hr':24*365, 'other':24*365,
99        'subhr':24*365, 'Day':365, '6h':4*365, '3 hourly':8*365, '':1 }
100
101## There are 4 cmor variables with blank frequency ....
102
103def vol01( sz, v, npy, freq, inx ):
104  n1 = npy[freq]
105  s = sz[inx.uid[v].stid]
106  assert type(s) == type(1), 'Non-integer size found for %s' % v
107  assert type(n1) in (type(1),type(0.)), 'Non-number "npy" found for %s, [%s]' % (v,freq)
108  return s*n1
109
110class col_list(object):
111  def __init__(self):
112    self.a = collections.defaultdict(list)
113
114class col_count(object):
115  def __init__(self):
116    self.a = collections.defaultdict(int)
117
118class dreqQuery(object):
119  __doc__ = """Methods to analyse the data request, including data volume estimates"""
120  def __init__(self,dq=None,tierMax=1):
121    if dq == None:
122      self.dq = dreq.loadDreq()
123    else:
124      self.dq=dq
125    self.rlu = {}
126    for i in self.dq.coll['objective'].items:
127      k = '%s.%s' % (i.mip,i.label)
128      assert not k in self.rlu, 'Duplicate label in objectives: %s' % k
129      self.rlu[k] = i.uid
130
131    self.odsz = odsz
132    self.npy = npy
133    self.strSz = dict()
134    self.cmvFilter = cmvFilter( self )
135    self.tierMax = tierMax
136    self.gridPolicyDefaultNative = False
137    self.gridPolicyTopOnly = True
138    self.exptFilter = None
139    self.uniqueRequest = False
140
141    self.mips = set( [x.label for x in self.dq.coll['mip'].items ] )
142    self.mips = ['AerChemMIP', 'C4MIP', 'CFMIP', 'DAMIP', 'DCPP', 'FAFMIP', 'GeoMIP', 'GMMIP', 'HighResMIP', 'ISMIP6', 'LS3MIP', 'LUMIP', 'OMIP', 'PMIP', 'RFMIP', 'ScenarioMIP', 'VolMIP', 'CORDEX', 'DynVar', 'SIMIP', 'VIACSAB']
143    self.mipsp = ['DECK','CMIP6',] + self.mips[:-4]
144    self.cmvGridId, i4 = fgrid.fgrid( self.dq )
145    assert len(i4) == 0
146
147    self.experiments = set( [x.uid for x in self.dq.coll['experiment'].items ] )
148    self.exptByLabel = {}
149    for x in self.dq.coll['experiment'].items:
150      if x.label in self.exptByLabel:
151        print ( 'ERROR: experiment label duplicated: %s' % x.label )
152      self.exptByLabel[x.label] = x.uid
153    self.mipls = sorted( list( self.mips ) )
154
155    self.default_mcfg = nt_mcfg._make( [259200,60,64800,40,20,5,100] )
156    self.mcfg = self.default_mcfg._asdict()
157    self.mcfgNote = None
158    self.szcfg()
159    self.requestItemExpAll(  )
160
161  def setMcfg(self, ll, msg=None ):
162    assert len(ll) == 7, 'Model config must be of length 7: %s' % str(ll)
163    assert all( [type(x) == type(1) for x in ll] )
164    self.mcfg = nt_mcfg._make( ll )._asdict()
165    if msg == None:
166      self.mcfgNote = 'User supplied model configuration: %s' % str(ll)
167    else:
168      self.mcfgNote = msg
169    self.szcfg()
170
171  def szcfg(self):
172    szr = {'100km':64800, '1deg':64800, '2deg':16200 }
173    self.szss = {}
174    self.sz = {}
175    self.szg = collections.defaultdict( dict )
176    self.szgss = collections.defaultdict( dict )
177    self.isLatLon = {}
178    self.szSrf = collections.defaultdict( dict )
179    self.szssSrf = collections.defaultdict( dict )
180    for i in self.dq.coll['spatialShape'].items:
181      gtype = 'a'
182      if i.levelFlag == False:
183        ds =  i.dimensions.split( '|' )
184        if ds[-1] in ['site', 'basin']:
185          vd = ds[-2]
186        else:
187          vd = ds[-1]
188 
189        if vd[:4] == 'olev' or vd == 'rho':
190          gtype = 'o'
191          nz = self.mcfg['nlo']
192        elif vd[:4] == 'alev':
193          nz = self.mcfg['nla']
194        elif vd in ['slevel','sdepth']:
195          nz = self.mcfg['nls']
196        elif vd == 'aslevel':
197          nz = self.mcfg['nlas']
198        else:
199          mlg.prnt( 'Failed to parse dimensions %s' % i.dimensions )
200          raise
201      else:
202        nz = i.levels
203
204      dims = set( i.dimensions.split( '|' ) )
205      if 'latitude' in dims and 'longitude' in dims:
206        if gtype == 'o':
207          nh = self.mcfg['nho']
208          self.isLatLon[i.uid] = 'o'
209        else:
210          nh = self.mcfg['nha']
211          self.isLatLon[i.uid] = 'a'
212      else:
213        nh = 10
214        self.isLatLon[i.uid] = False
215
216      self.szss[i.uid] = nh*nz
217      if self.isLatLon[i.uid] != False and len(dims) == 2:
218        self.szssSrf[i.uid] = { 'a':self.mcfg['nha']*nz, 'o':self.mcfg['nho']*nz }
219
220      for k in szr:
221        if self.isLatLon[i.uid] != False:
222          self.szgss[k][i.uid] = szr[k]*nz
223        else:
224          self.szgss[k][i.uid] = nh*nz
225
226    for i in self.dq.coll['structure'].items:
227      s = 1
228      knownAtmos = False
229      if i.odims != '':
230        if i.odims in odsz:
231           sf = odsz[i.odims]
232        else:
233           ## print 'SEVERE.odims.00001: no information on dimension size: %s' % i.odims
234           sf = 5
235        if type( sf ) == type( () ):
236          sf = sf[0]
237        s = s*sf
238        if i.odims not in ['iceband']:
239          knownAtmos = True
240      if i.spid in self.szss:
241        self.sz[i.uid] = self.szss[i.spid]*s
242
243        if i.uid in self.szssSrf:
244          if knownAtmos:
245            self.sz[i.uid] = self.szssSrf[i.spid]['a']*s
246          else:
247            for k in ['a','o']:
248               self.szSrf[i.uid][k] = self.szssSrf[i.spid][k]*s
249
250        for k in szr:
251          self.szg[k][i.uid] = self.szgss[k][i.spid]*s
252      else:
253        print ('WARNING: spid has no size info: %s [%s]' % (i.spid,i.uid) )
254        self.sz[i.uid] = 0.
255        for k in szr:
256          self.szg[k][i.uid] = 0.
257
258  def getRequestLinkByMip( self, mipSel ):
259    """Return the set of request links which are associated with specified MIP"""
260
261    if type(mipSel) == type( {} ):
262      return self.getRequestLinkByMipObjective(self,mipSel)
263
264    if type(mipSel) == type(''):
265      t1 = lambda x: x == mipSel
266    elif type(mipSel) == type(set()):
267      t1 = lambda x: x in mipSel
268
269    s = set()
270    for i in self.dq.coll['requestLink'].items:
271      if t1(i.mip):
272        if 'requestItem' in self.dq.inx.iref_by_sect[i.uid].a:
273          if any( [ self.rqiExp[x][-1] > 0 for  x in self.dq.inx.iref_by_sect[i.uid].a['requestItem'] if x in self.rqiExp ] ):
274            s.add( i )
275
276    self.rqs = list( s )
277    return self.rqs
278
279  def getRequestLinkByMipObjective( self, mipSel ):
280    """Return the set of request links which are associated with specified MIP and its objectives"""
281
282    assert type(mipSel) == type( {} ),'Argument must be a dictionary, listing objectives for each MIP'
283
284    s = set()
285    for i in self.dq.coll['requestLink'].items:
286      if i.mip in mipSel:
287        if len(mipSel[i.mip]) == 0:
288          s.add( i )
289        elif 'objectiveLink' in self.dq.inx.iref_by_sect[i.uid].a:
290          ss = set( [self.dq.inx.uid[k].label for k in self.dq.inx.iref_by_sect[i.uid].a['objectiveLink'] ] )
291          if any( [x in mipSel[i.mip] for x in ss] ):
292            s.add( i )
293##
294## filter requestLinks by tierMax: check to see whether they link to experiments with tier below or equal to tiermax.
295##
296    s1 = set()
297    for i in s:
298      if 'requestItem' in self.dq.inx.iref_by_sect[i.uid].a:
299        if any( [ self.rqiExp[x][-1] > 0 for  x in self.dq.inx.iref_by_sect[i.uid].a['requestItem'] if x in self.rqiExp ] ):
300            s1.add( i )
301
302    self.rqs = list( s1 )
303    return self.rqs
304
305  def varGroupXexpt(self, rqList ):
306    """For a list of request links, return a list of variable group IDs for each experiment"""
307    self.cc = collections.defaultdict( list )
308    ## dummy = {self.cc[i.expt].append(i.rlid) for i in self.dq.coll['requestItem'].items if i.rlid in {j.uid for j in rqList} }
309    return self.cc
310
311  def yearsInRequest(self, rql ):
312    self.ntot = sum( [i.ny for i in self.dq.coll['requestItem'].items if i.rlid == rql.uid] )
313    return self.ntot
314
315  def rqlByExpt( self, l1, ex, pmax=2, expFullEx=False ):
316    """rqlByExpt: return a set of request links for an experiment"""
317##
318    inx = self.dq.inx
319
320    if ex != None:
321   
322      exi = self.dq.inx.uid[ex]
323      if exi._h.label == 'experiment':
324        exset = set( [ex,exi.egid,exi.mip] )
325      else:
326        exset = set( self.esid_to_exptList(ex,deref=False,full=expFullEx) )
327##
328## rql is the set of all request links which are associated with a request item for this experiment set
329##
330   
331      l1p = set()
332      for i in l1:
333        if i.preset < 0 or i.preset <= pmax:
334          if i.esid in exset:
335            l1p.add(i)
336    else:
337      exset = None
338      l1p = l1
339
340    rql0 = set()
341    for i in l1p:
342       rql0.add(i.rlid)
343
344    rqlInv = set()
345    for u in rql0:
346      if inx.uid[u]._h.label == 'remarks':
347        rqlInv.add( u )
348    if len(rqlInv) != 0:
349      mlg.prnt ( 'WARNING.001.00002: %s invalid request links from request items ...' % len(rqlInv) )
350    rql = set()
351    for u in rql0:
352       if inx.uid[u]._h.label != 'remarks':
353         rql.add( u ) 
354
355    return rql, l1p, exset
356
357  def varsByRql( self, rql, pmax=2, intersection=False, asDict=False): 
358      """The complete set of variables associated with a set of request links."""
359      inx = self.dq.inx
360      cc1 = collections.defaultdict( set )
361      for i in rql:
362        o = inx.uid[i]
363        if o.opt == 'priority':
364          p = int( float( o.opar ) )
365          assert p in [1,2,3], 'Priority incorrectly set .. %s, %s, %s' % (o.label,o.title, o.uid)
366          cc1[inx.uid[i].mip].add( (inx.uid[i].refid,p) )
367        else:
368          cc1[inx.uid[i].mip].add( inx.uid[i].refid )
369
370      if intersection:
371        ccv = {}
372#
373# set of request variables for each MIP
374#
375        for k in cc1:
376          thisc = reduce( operator.or_, [set( inx.iref_by_sect[vg].a['requestVar'] ) for vg in cc1[k] ] )
377          rqvgs = collections.defaultdict( set )
378          for x in cc1[k]:
379            if type(x) == type( () ):
380              rqvgs[x[0]].add( x[1] )
381            else:
382              rqvgs[x].add( 3 )
383         
384          s = set()
385          for vg in rqvgs:
386            for l in inx.iref_by_sect[vg].a['requestVar']:
387              if inx.uid[l].priority <= min(pmax,max(rqvgs[vg])):
388                s.add( inx.uid[l].vid )
389          ccv[k] = s
390
391        if len( ccv.keys() ) < len( list(imips) ):
392          vars = set()
393        else:
394          vars =  reduce( operator.and_, [ccv[k] for k in ccv] )
395      else:
396        rqvgs = collections.defaultdict( set )
397        for k in cc1:
398          for x in cc1[k]:
399            if type(x) == type( () ):
400              rqvgs[x[0]].add( x[1] )
401            else:
402              rqvgs[x].add( 3 )
403         
404###To obtain a set of variables associated with this collection of variable groups:
405
406        if asDict:
407          vars = collections.defaultdict( list )
408        else:
409          vars = set()
410        for vg in rqvgs:
411          for l in inx.iref_by_sect[vg].a['requestVar']:
412            if inx.uid[l].priority <= min(pmax,max(rqvgs[vg])):
413               if asDict:
414                 vars[inx.uid[l].vid].append( vg )
415               else:
416                 vars.add(inx.uid[l].vid)
417
418        ##col1 = reduce( operator.or_, [set( inx.iref_by_sect[vg].a['requestVar'] ) for vg in rqvg ] )
419### filter out cases where the request does not point to a CMOR variable.
420    ##vars = {vid for vid in vars if inx.uid[vid][0] == u'CMORvar'}
421
422      if asDict:
423        thisvars = {}
424        for vid in vars:
425           if inx.uid[vid]._h.label == u'CMORvar':
426             thisvars[vid] = vars[vid]
427      else:
428        thisvars = set()
429        for vid in vars:
430           if inx.uid[vid]._h.label == u'CMORvar':
431             thisvars.add(vid)
432
433      return thisvars
434
435  def exptYears( self, rqll, ex=None):
436    """Parse a set of request links, and get years requested for each (varGroup, expt, grid) tuple """
437     
438    cc = collections.defaultdict( set )
439    for rl in rqll:
440      if 'requestItem' not in self.dq.inx.iref_by_sect[rl.uid].a:
441        print ( 'WARN.001.00001: no request items for: %s, %s' % (rl.uid, rl.title) )
442      else:
443
444        if rl.grid == '100km':
445            grd = '1deg'
446        if rl.grid in ['1deg','2deg']:
447            grd = rl.grid
448        else:
449          ## note that naming of "gridreq" is unfortunate ... "No" means that native grid is required
450          if rl.gridreq in ['No', 'no'] or self.gridPolicyDefaultNative:
451            grd = 'native'
452          else:
453            ## print ( 'INFO.grd.00001: defaulting to grid ..%s, %s, %s' % (rl.label,rl.title, rl.uid) )
454            grd = 'DEF'
455
456        for iu in self.dq.inx.iref_by_sect[rl.uid].a['requestItem']:
457          i = self.dq.inx.uid[iu]
458          if iu in self.rqiExp:
459            for e in self.rqiExp[iu][1]:
460              if ex == None or e in ex:
461                this = self.rqiExp[iu][1][e]
462                if this != None:
463                  thisns = this[-3]
464                  thisny = this[-2]
465                  thisne = this[-1]
466                  ##cc[ (rl.refid,e,grd) ].add( filter1( thisns*thisny*thisne, i.nymax) )
467                  cc[ (rl.refid,e,grd) ].add( thisns*thisny*thisne )
468    ee = collections.defaultdict( dict )
469
470    revertToLast = True
471    if revertToLast:
472      for g,e,grd in cc:
473        ee[g][(e,grd)] = max( cc[( g,e,grd) ] )
474      return ee
475    ff = collections.defaultdict( dict )
476##
477## this needs to be done separately for ocean and atmosphere, because of the default logic workflow ...
478    for g,e,grd in cc:
479      ee[(g,e)][grd] = max( cc[( g,e,grd) ] )
480
481    xx = collections.defaultdict( dict )
482    for g,e in ee:
483      ddef = ee[(g,e)].get( 'DEF', 0 )
484      for grd in ee[(g,e)]:
485        if grd != 'DEF':
486          xx[(g,'a')][(e, grd)] = ee[(g,e)][grd]
487          xx[(g,'o')][(e, grd)] = ee[(g,e)][grd]
488          xx[(g,'')][(e, grd)] = ee[(g,e)][grd]
489        if grd == 'native' and ddef != 0:
490          xx[(g,'a')][(e, 'native')] = max( [xx[(g,'a')][(e, 'native')],ddef] )
491          xx[(g,'')][(e, 'native')] = max( [xx[(g,'')][(e, 'native')],ddef] )
492        if grd == '1deg' and ddef != 0:
493          xx[(g,'o')][(e, '1deg')] = max( [xx[(g,'o')][(e, '1deg')],ddef] )
494
495    for grp,flg in xx:
496      ff[grp][flg] = xx[(grp,flg)]
497         
498    ## return dict[<variable group>]{dict[<experiment><grid>]{<years>}}
499    ## return dict[<variable group>][grid flag]{dict[<experiment>,<grid>]{<years>}}
500    return ff
501
502  def volByExpt( self, l1, ex, pmax=1, cc=None, retainRedundantRank=False, intersection=False,expFullEx=False, adsCount=False ):
503    """volByExpt: calculates the total data volume associated with an experiment/experiment group and a list of request items.
504          The calculation has some approximations concerning the number of years in each experiment group.
505          cc: an optional collector, to accumulate indexed volumes. """
506##
507    inx = self.dq.inx
508    imips = set()
509    for i in l1:
510      imips.add(i.mip)
511   
512    rql, l1p, exset = self.rqlByExpt( l1, ex, pmax=pmax, expFullEx=expFullEx )
513    verbose = False
514    if verbose:
515      for i in rql:
516        r = inx.uid[i]
517        print ( '%s, %s, %s' % (r.label, r.title, r.uid) )
518
519    if ex != None:
520     
521      exi = self.dq.inx.uid[ex]
522      if exi._h.label == 'experiment':
523        exset = set( [ex,exi.egid,exi.mip] )
524#####
525    if len( rql ) == 0:
526      self.vars = set()
527      return (0,{},{} )
528
529## The complete set of variables associated with these requests:
530    vars = self.varsByRql( rql, pmax=pmax, intersection=intersection, asDict=True) 
531##
532## filter by configuration option and rank
533##
534    if not retainRedundantRank:
535      len1 = len(vars.keys())
536      cmv = self.cmvFilter.filterByChoiceRank(cmv=vars.keys())
537      vars = cmv
538   
539    self.vars = vars
540
541    e = {}
542    for u in rql:
543### for request variables which reference the variable group attached to the link, add the associate CMOR variables, subject to priority
544      i = inx.uid[u]
545      e[i.uid] = set()
546      si = collections.defaultdict( list )
547      for x in inx.iref_by_sect[i.refid].a['requestVar']:
548           if inx.uid[x].priority <= pmax:
549              e[i.uid].add( inx.uid[x].vid )
550
551              if verbose:
552                cmv = inx.uid[inx.uid[x].vid]
553                if cmv._h.label == 'CMORvar':
554                  si[ cmv.mipTable ].append( inx.uid[x].label )
555#
556# for each variable, calculate the maximum number of years across all the request links which reference that variable.
557##
558## for each request item we have nymax, nenmax, nexmax.
559##
560    nymg = collections.defaultdict( dict )
561##
562## if dataset count rather than volume is wanted, use item 3 from rqiExp tuple.
563    if adsCount:
564      irqi = 3
565    else:
566      irqi = 2
567
568    sgg = set()
569    for v in vars:
570      s = set()
571      sg = collections.defaultdict( set )
572      cc2 = collections.defaultdict( set )
573      cc2s = collections.defaultdict( c1s )
574      for i in l1p:
575##################
576        if (exset == None or i.esid in exset) and v in e[i.rlid]:
577          ix = inx.uid[i.esid]
578          rl = inx.uid[i.rlid]
579          sgg.add( rl.grid )
580          if rl.grid in ['100km','1deg','2deg']:
581            grd = rl.grid
582          else:
583            grd = 'native'
584
585          this = None
586          if exset == None:
587            thisz = 100
588##
589## for a single experiment, look up n years, and n ensemble.
590## should have nstart????
591##
592          elif exi._h.label == 'experiment' or ix._h.label == 'experiment':
593            this = None
594            if ex in self.rqiExp[i.uid][1]:
595              this = self.rqiExp[i.uid][1][ex]
596            elif ix.uid in self.rqiExp[i.uid][1]:
597              this = self.rqiExp[i.uid][1][ix.uid]
598            if this != None:
599              thisns = this[-3]
600              thisny = this[-2]
601              thisne = this[-1]
602              cc2s[grd].a[u].add( filter1( thisns*thisny*thisne, i.nymax) )
603          else:
604            thisz = None
605            if 'experiment' in inx.iref_by_sect[i.esid].a:
606              for u in inx.iref_by_sect[i.esid].a['experiment']:
607                if u in self.rqiExp[i.uid][1]:
608                  this = self.rqiExp[i.uid][1][u]
609                  thisns = this[-3]
610                  thisny = this[-2]
611                  thisne = this[-1]
612##
613###   aggregate year count for each experiment and output grid
614## clarify definition and usage of nymax -- should be redundant ... could be replaced by inward references from "timeSlice"
615                  cc2s[grd].a[u].add( filter1( thisns*thisny*thisne, i.nymax) )
616
617          if exset != None:
618            sg[grd].add( self.rqiExp[i.uid][irqi] )
619     
620###
621### sum over experiments of maximum within each experiment
622###
623      for g in sg:
624        nymg[v][g] = sum( [max( cc2s[g].a[k] ) for k in cc2s[g].a] )
625
626    szv = {}
627    ov = []
628    for v in vars:
629      if 'requestVar' not in inx.iref_by_sect[v].a:
630         print ( 'Variable with no request ....: %s, %s' % (inx.uid[v].label, inx.uid[v].mipTable) )
631      try:
632        szv[v] = self.sz[inx.uid[v].stid]*npy[inx.uid[v].frequency]
633      except:
634        if inx.uid[v].stid not in self.sz:
635          print ('ERROR: size not found for stid %s (v=%s, %s)' % (inx.uid[v].stid,v,inx.uid[v].label) )
636        if inx.uid[v].frequency not in npy:
637          print ('ERROR: npy not found for frequency %s (v=%s, %s)' % (inx.uid[v].frequency,v,inx.uid[v].label) )
638        szv[v] = 0
639      ov.append( self.dq.inx.uid[v] )
640
641    ff = {}
642    for v in vars:
643      if adsCount:
644        ff[v] = 1
645      else:
646        if 'native' in nymg[v]:
647          ff[v] = szv[v]
648          ny = nymg[v]['native']
649        else:
650          if len( nymg[v] ) > 1:
651            print ( '########### Selecting first in list .............' )
652          ks0 = nymg[v].keys()
653          if len(ks0) == 0:
654            ff[v] = 0.
655            ny = 0.
656          else:
657            ks = list( nymg[v].keys() )[0]
658            ny = nymg[v][ks]
659            if inx.uid[v].stid in self.szg[ks]:
660              ff[v] = self.szg[ks][ inx.uid[v].stid ] * npy[inx.uid[v].frequency]
661            else:
662              ff[v] = 0.
663
664        if inx.uid[v].frequency != 'monClim':
665          ff[v] = ff[v]*ny
666
667    ee = self.listIndexDual( ov, 'mipTable', 'label', acount=None, alist=None, cdict=ff, cc=cc )
668    self.ngptot = sum( [  ff[v]  for v in vars] )
669    return (self.ngptot, ee, ff )
670
671  def esid_to_exptList(self,esid,deref=False,full=False):
672    if not esid in self.dq.inx.uid:
673      mlg.prnt ( 'Attempt to dereferece invalid uid: %s' % esid )
674      raise
675
676    if self.dq.inx.uid[esid]._h.label == 'experiment':
677      expts = [esid,]
678    elif self.dq.inx.uid[esid]._h.label != 'remarks':
679      if esid in self.dq.inx.iref_by_sect and 'experiment' in self.dq.inx.iref_by_sect[esid].a:
680        expts = list( self.dq.inx.iref_by_sect[esid].a['experiment'][:] )
681      else:
682        expts = []
683
684## add in groups and mips for completeness
685##
686      if full:
687        if self.dq.inx.uid[esid]._h.label == 'mip':
688          s = set()
689          for e in expts:
690            if self.dq.inx.uid[e]._h.label != 'experiment':
691              mlg.prnt ( 'ERROR: %s, %s, %s ' % (esid,e, self.dq.inx.uid[e].title ) )
692            s.add( self.dq.inx.uid[e].egid )
693          for i in s:
694            expts.append( i )
695        expts.append( esid )
696    else:
697      ##print ( 'WARNING: request link not associated with valid experiment group' )
698      ##raise
699      return None
700
701    if self.tierMax > 0:
702      expts1 = []
703      for i in expts:
704        if self.dq.inx.uid[i]._h.label == 'experiment':
705          if self.dq.inx.uid[i].tier[0] <= self.tierMax:
706            expts1.append( i )
707        elif self.dq.inx.uid[i]._h.label == 'exptgroup':
708          if self.dq.inx.uid[i].tierMin <= self.tierMax:
709            expts1.append( i )
710        else:
711            expts1.append( i )
712    else:
713      expts1 = expts
714
715    if deref:
716      return [self.dq.inx.uid[e] for e in expts1]
717    else:
718      return expts1
719##
720## need to call this on load
721## then use instead of i.ny etc below
722##
723  def requestItemExpAll( self ):
724    self.rqiExp = {}
725    for rqi in self.dq.coll['requestItem'].items:
726      a,b,c,d = self.requestItemExp( rqi )
727      if a != None:
728        self.rqiExp[rqi.uid] = (a,b,c,d)
729
730  def requestItemExp( self, rqi ):
731    assert rqi._h.label == "requestItem", 'Argument to requestItemExp must be a requestItem'
732    u = rqi.esid
733    if self.dq.inx.uid[u]._h.label == 'experiment':
734      expts = [u,]
735    elif self.dq.inx.uid[u]._h.label != 'remarks':
736      if u in self.dq.inx.iref_by_sect and 'experiment' in self.dq.inx.iref_by_sect[u].a:
737        expts = self.dq.inx.iref_by_sect[u].a['experiment']
738      else:
739        expts = []
740    else:
741      return (None, None, None, None)
742
743    if self.tierMax > 0:
744      expts = [i for i in expts if self.dq.inx.uid[i].tier[0] <= self.tierMax]
745
746    self.multiTierOnly = False
747    if self.multiTierOnly:
748      expts = [i for i in expts if len(self.dq.inx.uid[i].tier) > 1]
749      print ('Len expts: %s' % len(expts) )
750
751    if len(expts) > 0:
752      e = [self.dq.inx.uid[i] for i in expts]
753      for i in e:
754        if i._h.label != 'experiment':
755          mlg.prnt ( 'ERROR: %s, %s, %s ' % ( u,i._h.label, i.label, i.title ) )
756      ##dat = [ (i.ntot, i.yps, i.ensz, i.tier, i.nstart, filter1(i.yps,rqi.nymax), filter2(i.ensz,rqi.nenmax,i.tier,self.tierMax) ) for i in e]
757      dat2 = {}
758      for i in e:
759        dat2[i.uid] = (i.ntot, i.yps, i.ensz, i.tier, i.nstart, filter1(i.yps,rqi.nymax), filter2(i.ensz,rqi.nenmax,i.tier,self.tierMax) )
760
761      nytot = sum( [dat2[x][-2]*dat2[x][-3] for x in dat2 ] )
762      netot = sum( [dat2[x][-1] for x in dat2 ] )
763    else:
764      dat2 = {}
765      nytot = 0
766      netot = 0
767   
768##
769## to get list of years per expt for each requestLink ... expts is union of all dat2 keys,
770## and want max of dat2[x][0] for each experiment x.
771##
772    return (expts, dat2, nytot, netot )
773
774  def setTierMax( self, tierMax ):
775    """Set the maxium tier and recompute request sizes"""
776    if tierMax != self.tierMax:
777      self.tierMax = tierMax
778      self.requestItemExpAll(  )
779
780  def summaryByMip( self, pmax=1 ):
781    bytesPerFloat = 2.
782    for m in self.mipls:
783      v = self.volByMip( m, pmax=pmax )
784      mlg.prnt ( '%12.12s: %6.2fTb' % (m,v*bytesPerFloat*1.e-12) )
785
786  def rqlByMip( self, mip):
787    if mip == 'TOTAL':
788        mip = self.mips
789
790    if type(mip) in [type( '' ),type( u'') ]:
791      if mip not in self.mips:
792        mlg.prnt ( self.mips )
793        raise baseException( 'rqiByMip: Name of mip not recognised: %s' % mip )
794      l1 = [i for i in  self.dq.coll['requestLink'].items if i.mip == mip]
795    elif type(mip) in [ type( set()), type( [] ) ]:
796      nf = [ m for m in mip if m not in self.mips]
797      if len(nf) > 0:
798          raise baseException( 'rqlByMip: Name of mip(s) not recognised: %s' % str(nf) )
799      l1 = [i for i in  self.dq.coll['requestLink'].items if i.mip in mip]
800    elif type(mip) == type( dict()):
801      nf = [ m for m in mip if m not in self.mips]
802      if len(nf) > 0:
803        raise baseException( 'rqlByMip: Name of mip(s) not recognised: %s' % str(nf) )
804      l1 = []
805      for i in  self.dq.coll['requestLink'].items:
806        if i.mip in mip:
807          ok = False
808          if len( mip[i.mip] ) == 0:
809            ok = True
810          else:
811            for ol in self.dq.inx.iref_by_sect[i.uid].a['objectiveLink']:
812              o = self.dq.inx.uid[ol]
813              if self.dq.inx.uid[o.oid].label in mip[i.mip]:
814                ok = True
815          if ok:
816              l1.append( i )
817    else:
818      raise baseException( 'rqiByMip: "mip" (1st explicit argument) should be type string or set: %s -- %s' % (mip, type(mip))   )
819
820    return l1
821
822  def rqiByMip( self, mip):
823    l1 = self.rqlByMip( mip )
824    if len(l1) == 0:
825       return []
826    l2 = [] 
827    for i in l1:
828       if 'requestItem' in self.dq.inx.iref_by_sect[i.uid].a:
829          for u in self.dq.inx.iref_by_sect[i.uid].a['requestItem']:
830               l2.append( self.dq.inx.uid[u] )
831
832    l20 = self.rqiByMip0( mip )
833    for i in l20:
834      assert i in l2
835    return l2
836   
837   
838  def rqiByMip0( self, mip):
839
840    if mip == 'TOTAL':
841        mip = self.mips
842    if type(mip) in [type( '' ),type( u'') ]:
843      if mip not in self.mips:
844        mlg.prnt ( self.mips )
845        raise baseException( 'rqiByMip: Name of mip not recognised: %s' % mip )
846      l1 = [i for i in  self.dq.coll['requestItem'].items if i.mip == mip]
847    elif type(mip) in [ type( set()), type( [] ) ]:
848      nf = [ m for m in mip if m not in self.mips]
849      if len(nf) > 0:
850          raise baseException( 'rqiByMip: Name of mip(s) not recognised: %s' % str(nf) )
851      l1 = [i for i in  self.dq.coll['requestItem'].items if i.mip in mip]
852    elif type(mip) == type( dict()):
853      nf = [ m for m in mip if m not in self.mips]
854      if len(nf) > 0:
855        raise baseException( 'rqiByMip: Name of mip(s) not recognised: %s' % str(nf) )
856      l1 = []
857      for i in  self.dq.coll['requestLink'].items:
858        if i.mip in mip:
859          ok = False
860          if len( mip[i.mip] ) == 0:
861            ok = True
862          else:
863            for ol in self.dq.inx.iref_by_sect[i.uid].a['objectiveLink']:
864              o = self.dq.inx.uid[ol]
865              if self.dq.inx.uid[o.oid].label in mip[i.mip]:
866                ok = True
867          if ok:
868              if 'requestItem' in self.dq.inx.iref_by_sect[i.uid].a:
869                for u in self.dq.inx.iref_by_sect[i.uid].a['requestItem']:
870                  l1.append( self.dq.inx.uid[u] )
871    else:
872      raise baseException( 'rqiByMip: "mip" (1st explicit argument) should be type string or set: %s -- %s' % (mip, type(mip))   )
873
874    return l1
875
876  def checkDir(self,odir,msg):
877      if not os.path.isdir( odir ):
878         try:
879            os.mkdir( odir )
880         except:
881            print ('\n\nFailed to make directory "%s" for: %s: make necessary subdirectories or run where you have write access' % (odir,msg) )
882            print ( '\n\n' )
883            raise
884         print ('Created directory %s for: %s' % (odir,msg) )
885
886
887  def xlsByMipExpt(self,m,ex,pmax,odir='xls',xls=True,txt=False,txtOpts=None):
888    import scope_utils
889    mxls = scope_utils.xlsTabs(self,tiermax=self.tierMax,pmax=pmax,xls=xls, txt=txt, txtOpts=txtOpts,odir=odir)
890    mlab = makeTables.setMlab( m )
891    mxls.run( m, mlab=mlab )
892
893  def cmvByInvMip( self, mip,pmax=1,includeYears=False, exptFilter=None ):
894    mips = set( self.mips[:] )
895    if type(mip) == type( '' ):
896        mips.discard( mip )
897    else:
898      for m in mip:
899        mips.discard( m )
900
901    return self.cmvByMip( mips,pmax=pmax,includeYears=includeYears, exptFilter=exptFilter )
902
903  def cmvByMip( self, mip,pmax=1,includeYears=False, exptFilter=None ):
904    if exptFilter != None:
905      assert type(exptFilter) == type( set() ), 'Argument exptFilter must be None or a set: %s' % str(exptFilter)
906    l1,ee = self.rvgByMip( mip, includePreset=True, returnLinks=True )
907    if includeYears:
908      expys = self.exptYears( l1, ex=exptFilter )
909      cc = collections.defaultdict( set )
910    ss = set()
911    for pr in ee:
912### loop over request  var groups.
913      for i in ee[pr]:
914        if 'requestVar' in self.dq.inx.iref_by_sect[i.uid].a:
915#
916# loop over request vars in group
917#
918          for x in self.dq.inx.iref_by_sect[i.uid].a['requestVar']:
919            i1 = self.dq.inx.uid[x]
920            if (pr == -1 and i1.priority <= pmax) or (pr > 0 and pr <= pmax):
921              if includeYears and i1.vid in self.cmvGridId:
922                ##assert i.uid in expys, 'No experiment info found for requestVarGroup: %s' % i.uid
923                ## may have no entry as a consequence of tierMin being set in the requestLink(s).
924                assert i1.vid in self.cmvGridId, 'No grid identification lookup found for %s: %s' % (i1.label,i1.vid)
925                assert self.cmvGridId[i1.vid] in ['a','o','si','li'], 'Unexpected grid id: %s: %s:: %s' % (i1.label,i1.vid, self.cmvGridId[i1.vid])
926                gflg = {'si':'','li':''}.get( self.cmvGridId[i1.vid], self.cmvGridId[i1.vid] )
927                rtl = True
928                if i.uid in expys:
929                  if rtl:
930                    for e,grd in expys[i.uid]:
931                        if exptFilter == None or e in exptFilter:
932                          if grd == 'DEF':
933                            if gflg == 'o':
934                              grd1 = '1deg'
935                            else:
936                              grd1 = 'native'
937                          else:
938                            grd1 = grd
939                          cc[(i1.vid,e,grd1)].add( expys[i.uid][e,grd] )
940                  else:
941                   for gf in expys[i.uid]:
942                    for e,grd in expys[i.uid][gf]:
943                      if grd in ["1deg",'2deg'] or gf == gflg:
944                        if exptFilter == None or e in exptFilter:
945                          cc[(i1.vid,e,grd)].add( expys[i.uid][gf][e,grd] )
946              else:
947                print ( 'SKIPPING %s: %s' % (i1.label,i1.vid) )
948                ss.add( i1.vid )
949    if includeYears:
950      l2 = collections.defaultdict( dict )
951      l2x = collections.defaultdict( dict )
952##
953## this removes lower ranked grids .... but for some groups want different grids for different variable categories
954##
955      if self.gridPolicyTopOnly:
956        for v,e,g in cc:
957          l2x[(v,e)][g] = max( list( cc[(v,e,g)] ) )
958        for v,e in l2x:
959          if len( l2x[(v,e)].keys() ) == 1:
960             g,val = list( l2x[(v,e)].items() )[0]
961          else:
962            if 'native' in l2x[(v,e)].keys():
963               g = 'native'
964               val = l2x[(v,e)][g]
965            else:
966               g = sorted( list( l2x[(v,e)].keys() ) )[0]
967               val = l2x[(v,e)][g]
968          l2[v][(e,g)] = val
969      else:
970        for v,e,g in cc:
971          l2[v][(e,g)] = max( list( cc[(v,e,g)] ) )
972    else:
973      l2 = sorted( [i for i in [self.dq.inx.uid[i] for i in ss] if i._h.label != 'remarks'], key=lambda x: x.label )
974    return l2
975
976  def exptFilterList(self,val,option,ret='uid'):
977    if type( val ) not in [[],()]:
978      val = [val,]
979
980    if option == 'lab':
981      v0 = val[:]
982      val = []
983      mm = []
984      for v in v0:
985        if v not in self.exptByLabel:
986          mm.append( v )
987        else:
988          val.append( self.exptByLabel[v] )
989
990      assert len(mm) == 0, 'Experiment names not all recognised: %s' % str(mm)
991
992    oo = set()
993    for v in val:
994      i = self.dq.inx.uid[v]
995      if i._h.label in ['exptgroup','mip']:
996        if 'experiment' in self.dq.inx.iref_by_sect[i.uid].a:
997          for u in self.dq.inx.iref_by_sect[i.uid].a['experiment']:
998            oo.add( u )
999      elif i._h.label == 'experiment':
1000            oo.add( i.uid )
1001      else:
1002        print ('WARNING .. skipping request for experiment which links to record of type %s' % i._h.label )
1003    return oo
1004   
1005  def getFreqStrSummary(self,mip,pmax=1):
1006##
1007## get a dictionary keyed on CMORvar uid, containing dictionary keyed on (experiment, grid) with value as number of years.
1008##
1009    if not self.uniqueRequest:
1010      cmv = self.cmvByMip(mip,pmax=pmax,includeYears=True,exptFilter=self.exptFilter)
1011    else:
1012      cmv1 = self.cmvByInvMip(mip,pmax=pmax,includeYears=True,exptFilter=self.exptFilter)
1013      cmv2 = self.cmvByMip('TOTAL',pmax=pmax,includeYears=True,exptFilter=self.exptFilter)
1014      cmv = self.differenceSelectedCmvDict(  cmv1, cmv2 )
1015 
1016    self.selectedCmv = cmv
1017    return self.cmvByFreqStr( cmv )
1018
1019  def differenceSelectedCmvDict( self, cmv1, cmv2 ):
1020      """Return the diffence between two dictionaries of cmor variables returned by self.cmvByMip.
1021         The dictionaries contain dictionaries of values. Differences may be subdictionaries not present,
1022         elements of sub-dictionaries not present, or elements of sub-dictionaries present with different values.
1023         A one sided difference is returned."""
1024
1025      cmv = {}
1026      for i in cmv2:
1027        if i not in cmv1:
1028          cmv[i] = cmv2[i]
1029        else:
1030          eei = {}
1031          for t in cmv2[i]:
1032            if t not in cmv1[i]:
1033              eei[t] = cmv2[i][t]
1034            else:
1035              if cmv2[i][t] > cmv1[i][t]:
1036                 eei[t] = cmv2[i][t] - cmv1[i][t]
1037          if len( eei.keys() ) != 0:
1038            cmv[i] = eei
1039      return cmv
1040
1041  def cmvByFreqStr(self,cmv,asDict=True,exptFilter=None):
1042    if exptFilter != None:
1043      assert type(exptFilter) == type( set() ), 'Argument exptFilter must be None or a set: %s' % str(exptFilter)
1044    cc = collections.defaultdict( list )
1045    for i in cmv:
1046      if asDict:
1047        ii = self.dq.inx.uid[i]
1048        if ii._h.label != 'remarks':
1049          st = self.dq.inx.uid[ ii.stid ]
1050          cc0 = collections.defaultdict( float )
1051          cc1 = collections.defaultdict( int )
1052          se = collections.defaultdict( set )
1053          for e,g in cmv[i]:
1054            cc0[g] += cmv[i][(e,g)]
1055            cc1[g] += 1
1056            se[g].add(e)
1057          for g in cc0:
1058            g1 = 'native'
1059            if self.isLatLon[st.spid] != False:
1060              g1 = g
1061              if g1 == 'DEF' and self.isLatLon[st.spid] == 'o':
1062                  g1 = '1deg'
1063              else:
1064                  g1 = 'native'
1065            g1 = g
1066
1067            cc[ (st.spid,st.odims,ii.frequency,g1) ].append( (i,cc0[g],cc1[g],se[g]) )
1068
1069      else:
1070        st = self.dq.inx.uid[ i.stid ]
1071        cc[ (st.spid,st.odims,i.frequency) ].append( i.label )
1072
1073    self.thiscmvset = set()
1074    c2 = collections.defaultdict( dict )
1075    sf = set()
1076    if asDict:
1077      for s,o,f,g in cc.keys():
1078        c2[(s,o,g)][f] = cc[ (s,o,f,g) ]
1079        sf.add( f )
1080    else:
1081      for s,o,f in cc.keys():
1082        c2[(s,o)][f] = cc[ (s,o,f) ]
1083        sf.add( f )
1084    lf = sorted( list(sf) )
1085    c3 = collections.defaultdict( dict )
1086
1087    for tt in sorted( c2.keys() ):
1088      if asDict:
1089        s,o,g = tt
1090      else:
1091        s,o = tt
1092        g = 'native'
1093      i = self.dq.inx.uid[ s ]
1094
1095      if asDict:
1096        for f in c2[tt]:
1097            isClim = f.lower().find( 'clim' ) != -1
1098            ny = 0
1099            expts = set()
1100            labs = []
1101            labs = collections.defaultdict( int )
1102            ccx = collections.defaultdict( list )
1103            for cmvi, ny1, ne, eset in c2[tt][f]:
1104              ccx[cmvi].append( (ny1, ne, eset) )
1105            net = 0
1106            for cmvi in ccx:
1107              if len( ccx[cmvi] ) == 1:
1108                 ny1, ne, eset = ccx[cmvi][0]
1109              else:
1110                 ny1, ne, eset = ( 0,0,set() )
1111                 for a,b,s in ccx[cmvi]:
1112                   ny1 += a
1113                   ne += b
1114                   eset = eset.union(  s )
1115             
1116              net += ne
1117              if len(eset) != ne:
1118                print ( 'WARNING: inconsistency in volume estimate ... possible duplication for %s,%s' % (cmvi,f) )
1119              for e in eset:
1120                elab = self.dq.inx.uid[e].label
1121                expts.add(elab)
1122
1123              if exptFilter != None:
1124                expts = exptFilter.intersection( expts )
1125
1126              if len(expts) > 0:
1127                lab = self.dq.inx.uid[cmvi].label
1128                self.thiscmvset.add( cmvi )
1129                ny += ny1
1130                labs[cmvi] += ny1
1131            ne = len( expts )
1132            nn = len( labs.keys() )
1133             
1134            if isClim:
1135              ny = net/float(nn)
1136            else:
1137              ny = ny/float(nn)
1138            assert tt[2] in ['native','1deg','2deg'], 'BAD grid identifier: %s' % str(tt)
1139            c3[tt][f] = (nn,ny,ne, labs,expts)
1140    return (sf,c3)
1141
1142  def getStrSz( self, g, stid=None, s=None, o=None, tt=False ):
1143    assert stid == None or (s==None and o==None), 'Specify either stid or s and o'
1144    assert stid != None or (s!=None and o!=None), 'Specify either stid or s and o'
1145
1146    if stid != None:
1147      st = self.dq.inx.uid[stid]
1148      if st._h.label != 'remarks':
1149        s = st.spid
1150        o = st.odims
1151      else:
1152        self.strSz[ (stid,g) ] = (False,0)
1153        if tt:
1154          return (self.strSz[ (stid,g) ], None)
1155        else:
1156          return self.strSz[ (stid,g) ]
1157
1158    g1 = g
1159    if g1 == 'DEF':
1160          if self.isLatLon[s] == 'o':
1161             g1 = '1deg'
1162          else:
1163             g1 = 'native'
1164    if (s,o,g) not in self.strSz:
1165
1166        if o == '':
1167           sf = 1
1168        elif o in self.odsz:
1169           sf = self.odsz[o]
1170        else:
1171           # print ( 'SEVERE.odims.00006: no information on dimension size: %s' % o )
1172           sf = 5
1173
1174        if type( sf ) == type( () ):
1175           sf = sf[0]
1176
1177
1178        try:
1179          if g1 != 'native' and self.isLatLon[s] != False:
1180            szg = self.szgss[g1][s]
1181          else:
1182            szg = self.szss[s]
1183        except:
1184          print ( 'Failed to get size for: %s, %s, %s' % (g,g1,s ) )
1185          raise
1186
1187        szg = szg * sf
1188        self.strSz[ (s,o,g) ] = (True,szg)
1189
1190    if tt:
1191      return (self.strSz[ (s,o,g) ], (s,o,g1) )
1192    else:
1193      return self.strSz[ (s,o,g) ]
1194
1195  def xxx__csvFreqStrSummary(self,mip,records=False,pmax=1):
1196    sf, c3 = self.getFreqStrSummary(mip,pmax=pmax)
1197    lf = sorted( list(sf) )
1198    hdr = ['','','']
1199    for f in lf:
1200      hdr += [f,'','',str( npy.get( f, '****') )]
1201    orecs = [hdr,]
1202    crecs = [None,]
1203    for tt in sorted( c3.keys() ):
1204      s,o,g = tt
1205      i = self.dq.inx.uid[ s ]
1206      if o != '':
1207        msg = '%48.48s [%s]' % (i.title,o)
1208      else:
1209        msg = '%48.48s' % i.title
1210      if g != 'native':
1211        msg += '{%s}' % g
1212      szg = self.getStrSz( g, s=s, o=o )[1]
1213
1214      rec = [msg,szg,2]
1215      crec = ['','','']
1216      for f in lf:
1217        if f in c3[tt]:
1218            nn,ny,ne,labs = c3[tt][f]
1219            rec += [nn,ny,ne,'']
1220            crec += [labs,'','','']
1221        else:
1222            rec += ['','','','']
1223            crec += ['','','','']
1224      orecs.append( rec )
1225      crecs.append( crec )
1226
1227    if records:
1228      return (orecs, crecs)
1229    oo = open( 'text.csv', 'w' )
1230    for rec in orecs:
1231      oo.write( '\t'.join( [str(x) for x in rec] ) + '\n' )
1232    oo.close()
1233
1234  def rvgByMip( self, mip, years=False, includePreset=False, returnLinks=False ):
1235    l1 = self.rqlByMip( mip )
1236    if includePreset:
1237      cc = collections.defaultdict( set )
1238      ss = set()
1239      for i in l1:
1240        if 'requestItem' in self.dq.inx.iref_by_sect[i.uid].a:
1241          prs = set()
1242          for x in self.dq.inx.iref_by_sect[i.uid].a['requestItem']:
1243             prs.add(self.dq.inx.uid[x].preset)
1244
1245          for p in prs:
1246            assert p in [-1,1,2,3], 'Bad preset value'
1247            cc[p].add( i.refid )
1248      ee = {}
1249      for p in cc:
1250        l2 = sorted( [self.dq.inx.uid[i] for i in cc[p]], key=lambda x: x.label )
1251        ee[p] = l2
1252      if returnLinks:
1253        return (l1,ee)
1254      else:
1255        return ee
1256    else:
1257      ss = set( [i.refid for i in l1] )
1258      l2 = sorted( [self.dq.inx.uid[i] for i in ss], key=lambda x: x.label )
1259      if returnLinks:
1260        return (l1,l2)
1261      else:
1262        return l2
1263
1264  def volByMip( self, mip, pmax=2, retainRedundantRank=False, intersection=False, adsCount=False, exptid=None):
1265
1266    l1 = self.rqiByMip( mip )
1267     
1268    #### The set of experiments/experiment groups:
1269    if exptid == None:
1270      exps = self.experiments
1271    elif type( exptid ) == type(''):
1272      exps = set( [exptid,] )
1273    else:
1274      assert type( exptid ) == type( set() ),'exptid arg to volByMip must be None, string or set: %s' % type( exptid )
1275      exps = exptid
1276   
1277    self.volByE = {}
1278    vtot = 0
1279    cc = collections.defaultdict( col_count )
1280    self.allVars = set()
1281    for e in exps:
1282      expts = self.esid_to_exptList(e,deref=True,full=False)
1283      if expts not in  [None,[]]:
1284        ###print 'EXPTS: ',e,len(expts), list( expts )[0].label
1285        for ei in expts:
1286          self.volByE[ei.label] = self.volByExpt( l1, ei.uid, pmax=pmax, cc=cc, retainRedundantRank=retainRedundantRank, intersection=intersection, adsCount=adsCount )
1287          vtot += self.volByE[ei.label][0]
1288        self.allVars = self.allVars.union( self.vars )
1289      ##else:
1290        ##print 'No expts found: ',e
1291    self.indexedVol = cc
1292
1293    return vtot
1294
1295  def listIndexDual(self, ll, a1, a2, acount=None, alist=None, cdict=None, cc=None ):
1296    do_count = acount != None
1297    do_list = alist != None
1298    assert not (do_count and do_list), 'It is an error to request both list and count'
1299    if not (do_count or do_list):
1300      acount = '__number__'
1301      do_count = True
1302
1303    if cc == None:
1304      if do_count:
1305        cc = collections.defaultdict( col_count )
1306      elif do_list:
1307        cc = collections.defaultdict( col_list )
1308
1309    if do_count:
1310      for l in ll:
1311        if cdict != None:
1312          v = cdict[l.uid]
1313        elif acount == '__number__':
1314          v = 1
1315        else:
1316          v = l.__dict__[acount]
1317
1318        cc[ l.__dict__[a1] ].a[ l.__dict__[a2] ] += v
1319    elif do_list:
1320      for l in ll:
1321        if cdict != None:
1322          v = cdict[l.uid]
1323        elif alist == '__item__':
1324          v = l
1325        else:
1326          v = l.__dict__[alist]
1327        cc[ l.__dict__[a1] ].a[ l.__dict__[a2] ].append( v )
1328
1329    od = {}
1330    for k in cc.keys():
1331      d2 = {}
1332      for k2 in cc[k].a.keys():
1333        d2[k2] = cc[k].a[k2]
1334      od[k] = d2
1335    return od
1336
1337class dreqUI(object):
1338  """Data Request Command line.
1339-------------------------
1340      -v : print version and exit;
1341      --unitTest : run some simple tests;
1342      -m <mip>:  MIP of list of MIPs (comma separated; for objective selection see note [1] below);
1343      -l <options>: List for options:
1344              o: objectives
1345              e: experiments
1346      -q <options>: List information about the schema:
1347              s: sections
1348              <section>: attributes for a section
1349              <section:attribute>: definition of an attribute.
1350      -h :       help: print help text;
1351      -e <expt>: experiment;
1352      -t <tier> maxmum tier;
1353      -p <priority>  maximum priority;
1354      --xls : Create Excel file with requested variables;
1355      --sf : Print summary of variable count by structure and frequency;
1356      --SF : Print summary of variable count by structure and frequency for all MIPs;
1357      --grdpol <native|1deg> :  policy for default grid, if MIPs have not expressed a preference;
1358      --allgrd :  When a variable is requested on multiple grids, archive all grids requested (default: only the finest resolution);
1359      --unique :  List only variables which are not requested uniquely by this MIP, for at least one experiment;
1360      --txt : Create text file with requested variables;
1361      --mcfg : Model configuration: 7 integers, comma separated, 'nho','nlo','nha','nla','nlas','nls','nh1'
1362                 default: 259200,60,64800,40,20,5,100
1363      --txtOpts : options for content of text file: (v|c)[(+|-)att1[,att2[...]]]
1364      --xlsDir <directory> : Directory in which to place variable listing [xls];
1365      --printLinesMax <n>  : Maximum number of lines to be printed (default 20)
1366      --printVars    : If present, a summary of the variables (see --printLinesMax) fitting the selection options will be printed
1367      --intersection : Analyse the intersection of requests rather than union.
1368
1369NOTES
1370-----
1371[1] A set of objectives within a MIP can be specified in the command line. The extended syntax of the "-m" argument is:
1372-m <mip>[:objective[.obj2[.obj3 ...]]][,<mip2]...]
1373
1374e.g.
1375drq -m HighResMIP:Ocean.DiurnalCycle
1376"""
1377  def __init__(self,args):
1378    self.adict = {}
1379    self.knownargs = {'-m':('m',True), '-p':('p',True), '-e':('e',True), '-t':('t',True), \
1380                      '-h':('h',False), '--printLinesMax':('plm',True), \
1381                      '-l':('l',True),
1382                      '-q':('q',True),
1383                      '--printVars':('vars',False), '--intersection':('intersection',False), \
1384                      '--count':('count',False), \
1385                      '--txt':('txt',False), \
1386                      '--sf':('sf',False), \
1387                      '--SF':('SF',False), \
1388                      '--grdpol':('grdpol',True), \
1389                      '--allgrd':('allgrd',False), \
1390                      '--unique':('unique',False), \
1391                      '--mcfg':('mcfg',True), \
1392                      '--txtOpts':('txtOpts',True), \
1393                      '--xlsDir':('xlsdir',True), '--xls':('xls',False) \
1394                       } 
1395    aa = args[:]
1396    notKnownArgs = []
1397    while len(aa) > 0:
1398      a = aa.pop(0)
1399      if a in self.knownargs:
1400        b = self.knownargs[a][0]
1401        if self.knownargs[a][1]:
1402          v = aa.pop(0)
1403          self.adict[b] = v
1404        else:
1405          self.adict[b] = True
1406      else:
1407        notKnownArgs.append(a)
1408
1409    assert self.checkArgs( notKnownArgs ), 'FATAL ERROR 001: Arguments not recognised: %s' % (str(notKnownArgs) )
1410
1411    if 'm' in self.adict:
1412      if self.adict['m'] == '_all_':
1413        pass
1414      elif self.adict['m'].find( ':' ) != -1:
1415        ee = {}
1416        for i in self.adict['m'].split(','):
1417          bits =  i.split( ':' )
1418          if len( bits ) == 1:
1419             ee[bits[0]] = []
1420          else:
1421             assert len(bits) == 2, 'Cannot parse %s' % self.adict['m']
1422             ee[bits[0]] = bits[1].split( '.' )
1423        self.adict['m'] = ee
1424      else:
1425        self.adict['m'] = set(self.adict['m'].split(',') )
1426
1427    if 'grdpol' in self.adict:
1428      assert self.adict['grdpol'] in ['native','1deg'], 'Grid policy argument --grdpol must be native or 1deg : %s' % self.adict['grdpol']
1429
1430    integerArgs = set( ['p','t','plm'] )
1431    for i in integerArgs.intersection( self.adict ):
1432      self.adict[i] = int( self.adict[i] )
1433
1434    self.intersection = self.adict.get( 'intersection', False )
1435
1436 
1437  def checkArgs( self, notKnownArgs ):
1438    if len( notKnownArgs ) == 0:
1439      return True
1440    print ('--------------------------------------')
1441    print ('------------  %s Arguments Not Recognised ------------' % len(notKnownArgs) )
1442    k = 0
1443    for x in notKnownArgs:
1444      k += 1
1445      if x[1:] in self.knownargs:
1446        print ( '%s PERHAPS %s instead of %s' % (k, x[1:],x) )
1447      elif '-%s' % x in self.knownargs:
1448        print ( '%s PERHAPS -%s instead of %s' % (k, x,x) )
1449      elif x[0] == '\xe2':
1450        print ( '%s POSSIBLY -- (double hyphen) instead of long dash in %s' % (k, x) )
1451    print ('--------------------------------------')
1452
1453    return len( notKnownArgs ) == 0
1454     
1455  def run(self, dq=None):
1456    if 'h' in self.adict:
1457      mlg.prnt ( self.__doc__ )
1458      return
1459
1460    if 'q' in self.adict:
1461      if dq == None:
1462        dq = dreq.loadDreq(configOnly=True)
1463      s = self.adict['q']
1464      if self.adict['q'] == 's':
1465        ss = sorted( [(i.title,i.label) for i in dq.coll['__sect__'].items] )
1466        for s in ss:
1467          mlg.prnt( '%16s:: %s' % (s[1],s[0]) )
1468      else:
1469        ss = [i.label for i in dq.coll['__sect__'].items]
1470        if s.find( ':' ) != -1:
1471          s,a = s.split( ':' )
1472        else:
1473          a = None
1474        if s not in ss:
1475          mlg.prnt( 'ERROR: option must be a section; use "-q s" to list sections' )
1476        elif a == None:
1477          x = [i for i in dq.coll['__sect__'].items if i.label == s]
1478          s1 = [i for i in  dq.coll['__main__'].items if 'ATTRIBUTE::%s' % s in i.uid]
1479          mlg.prnt( x[0].title )
1480          mlg.prnt( ' '.join( sorted  ([i.label for i in s1] ) ))
1481        else:
1482          x = [i for i in dq.coll['__main__'].items if i.uid == 'ATTRIBUTE::%s.%s' % (s,a) ]
1483          if len(x) == 0:
1484            mlg.prnt( 'ERROR: attribute not found' )
1485            s1 = [i for i in  dq.coll['__main__'].items if 'ATTRIBUTE::%s' % s in i.uid]
1486            mlg.prnt( 'ATTRIBUTES: ' + ' '.join( sorted  ([i.label for i in s1] ) ))
1487          else:
1488            mlg.prnt( 'Section %s, attribute %s' % (s,a) )
1489            mlg.prnt( x[0].title )
1490            mlg.prnt( x[0].description )
1491      return
1492
1493    if not ('m' in self.adict or 'SF' in self.adict):
1494      mlg.prnt ( 'Current version requires -m or --SF argument'  )
1495      mlg.prnt ( self.__doc__ )
1496      sys.exit(0)
1497
1498    if dq == None:
1499      self.dq = dreq.loadDreq()
1500    else:
1501      self.dq = dq
1502
1503    if 'l' in self.adict:
1504      self.printList()
1505      return
1506
1507    if 'mcfg' in self.adict:
1508      ll = string.split( self.adict['mcfg'], ',' )
1509      assert len(ll) == 7, 'Length of model configuration argument must be 7 comma separated integers: %s' %  self.adict['mcfg']
1510      lli = [ int(x) for x in ll]
1511
1512    self.sc = dreqQuery( dq=self.dq )
1513
1514    if 'grdpol' in self.adict:
1515      self.sc.gridPolicyDefaultNative = self.adict['grdpol'] == 'native'
1516      print ( 'SETTING grid policy: %s' % self.sc.gridPolicyDefaultNative )
1517    if 'allgrd' in self.adict:
1518      self.sc.gridPolicyTopOnly = False
1519      print ( 'SETTING grid policy for multiple preferred grids: %s' % self.sc.gridPolicyTopOnly )
1520    if 'unique' in self.adict:
1521      self.sc.uniqueRequest = True
1522
1523    if 'mcfg' in self.adict:
1524      self.sc.setMcfg( lli )
1525
1526    tierMax = self.adict.get( 't', 1 )
1527    self.sc.setTierMax(  tierMax )
1528    pmax = self.adict.get( 'p', 1 )
1529
1530    makeXls = self.adict.get( 'xls', False )
1531    makeTxt = self.adict.get( 'txt', False )
1532    doSf = 'SF' in self.adict or 'sf' in self.adict
1533    if makeXls or makeTxt or doSf:
1534      xlsOdir = self.adict.get( 'xlsdir', 'xls' )
1535      self.sc.checkDir( xlsOdir, 'xls files' )
1536
1537    if 'SF' in self.adict:
1538      import volsum
1539      self.sc.gridPolicyDefaultNative = True
1540      vs = volsum.vsum( self.sc, odsz, npy, odir=xlsOdir )
1541      vs.analAll(pmax)
1542
1543      self.sc.gridPolicyDefaultNative = False
1544      vs = volsum.vsum( self.sc, odsz, npy, odir=xlsOdir )
1545      vs.analAll(pmax)
1546
1547      self.sc.setTierMax( 3 )
1548      vs = volsum.vsum( self.sc, odsz, npy, odir=xlsOdir )
1549      vs.analAll(3)
1550      return
1551
1552    ok = True
1553    if self.adict['m'] == '_all_':
1554      self.adict['m'] = set(self.sc.mips )
1555      mlab = 'TOTAL'
1556    else:
1557      for i in self.adict['m']:
1558        if i not in self.sc.mips:
1559          ok = False
1560          mlg.prnt ( 'NOT FOUND: %s' % i )
1561      mlab = makeTables.setMlab( self.adict['m'] )
1562    assert ok,'Available MIPs: %s' % str(self.sc.mips)
1563
1564    eid = None
1565    ex = None
1566    if 'e' in self.adict:
1567      ex = self.adict['e']
1568      if ex in self.sc.mipsp:
1569        eid = set( self.dq.inx.iref_by_sect[ex].a['experiment'] )
1570        self.sc.exptFilter = eid
1571      else:
1572        for i in self.dq.coll['experiment'].items:
1573          if i.label == self.adict['e']:
1574            eid = i.uid
1575        assert eid != None, 'Experiment/MIP %s not found' % self.adict['e']
1576        self.sc.exptFilter = set( [eid,] )
1577
1578    if 'sf' in self.adict:
1579      import volsum
1580      vs = volsum.vsum( self.sc, odsz, npy, odir=xlsOdir )
1581      vs.run( self.adict['m'], 'requestVol_%s_%s_%s' % (mlab,tierMax,pmax), pmax=pmax ) 
1582      vs.anal(olab=mlab,doUnique=False)
1583      ttl = sum( [x for k,x in vs.res['vu'].items()] )*2.*1.e-12
1584      ttl2 = sum( [x for k,x in vs.res['vu'].items()] )*2.*1.e-12
1585      mlg.prnt( 'TOTAL volume: %8.2fTb' % ttl )
1586      return
1587
1588
1589    adsCount = self.adict.get( 'count', False )
1590
1591    self.getVolByMip(pmax,eid,adsCount)
1592    makeXls = self.adict.get( 'xls', False )
1593    makeTxt = self.adict.get( 'txt', False )
1594    if makeXls or makeTxt:
1595      mips = self.adict['m']
1596
1597      if 'txtOpts' in self.adict:
1598        if self.adict['txtOpts'][0] == 'v':
1599          txtOpts = NT_txtopts( 'var' )
1600        else:
1601          txtOpts = NT_txtopts( 'cmv' )
1602      else:
1603        txtOpts=None
1604
1605      self.sc.xlsByMipExpt(mips,eid,pmax,odir=xlsOdir,xls=makeXls,txt=makeTxt,txtOpts=txtOpts)
1606
1607  def printList(self):
1608    mips = self.adict['m']
1609    ee = {}
1610    for i in self.dq.coll['mip'].items:
1611      if i.label in mips:
1612        ee[i.label] = i
1613    if self.adict['l'] in ['o','e']:
1614      targ = {'o':'objective', 'e':'experiment' }[self.adict['l']]
1615      for k in sorted( ee.keys() ):
1616        if targ in self.dq.inx.iref_by_sect[ee[k].uid].a:
1617          for u in self.dq.inx.iref_by_sect[ee[k].uid].a[targ]:
1618            print ( '%s: %s' % (ee[k].label, self.dq.inx.uid[u].label) )
1619    else:
1620      print ('list objective *%s* not recognised (should be e or o)' % self.adict['l'] )
1621     
1622  def getVolByMip(self,pmax,eid,adsCount):
1623
1624    v0 = self.sc.volByMip( self.adict['m'], pmax=pmax, intersection=self.intersection, adsCount=adsCount, exptid=eid )
1625    mlg.prnt ( 'getVolByMip: %s [%s]' % (v0,makeTables.vfmt(v0*2.)) )
1626    cc = collections.defaultdict( int )
1627    for e in self.sc.volByE:
1628      for v in self.sc.volByE[e][2]:
1629          cc[v] += self.sc.volByE[e][2][v]
1630    x = 0
1631    for v in cc:
1632      x += cc[v]
1633   
1634    if python2:
1635      vl = sorted( cc.keys(), cmp=cmpd(cc).cmp, reverse=True )
1636    else:
1637      vl = sorted( cc.keys(), key=lambda x: cc[x], reverse=True )
1638    if self.adict.get( 'vars', False ):
1639      printLinesMax = self.adict.get( 'plm', 20 )
1640      if printLinesMax > 0:
1641        mx = min( [printLinesMax,len(vl)] )
1642      else:
1643        mx = len(vl)
1644
1645      for v in vl[:mx]:
1646        mlg.prnt ( '%s.%s: %s' % (self.dq.inx.uid[v].mipTable,self.dq.inx.uid[v].label, makeTables.vfmt( cc[v]*2. ) ) )
1647      if mx < len(vl):
1648        mlg.prnt ( '%s variables not listed (use --printLinesMax to print more)' % (len(vl)-mx) )
1649
Note: See TracBrowser for help on using the repository browser.