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

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

TOTAL bug: partial solution

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