source: CMIP6dreq/trunk/dreqPy/scope.py @ 1336

Subversion URL: http://proj.badc.rl.ac.uk/svn/exarch/CMIP6dreq/trunk/dreqPy/scope.py
Revision 1336, 75.4 KB checked in by mjuckes, 2 months ago (diff)

move to 01.00.31.post3 to fix imports for python2.7 from package built with python3.5

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