source: CCCC/trunk/utils_c4.py @ 155

Subversion URL: http://proj.badc.rl.ac.uk/svn/exarch/CCCC/trunk/utils_c4.py@155
Revision 155, 36.7 KB checked in by mjuckes, 7 years ago (diff)

various fixes for aMap feature -- see updates.txt

Line 
1
2import string, re, os, sys, traceback
3
4def strmm3( mm ):
5  return string.join( map( lambda x: '%s="%s" [correct: "%s"]' % x, mm ), '; ' )
6
7from fcc_utils import mipTableScan
8
9class reportSection:
10
11  def __init__(self,id,cls,parent=None, description=None):
12    self.id = id
13    self.cls = cls
14    self.parent = parent
15    self.description = description
16    self.records = []
17    self.subsections = []
18    self.closed = False
19    self.npass = 0
20    self.fail = 0
21    self.auditDone = True
22
23  def addSubSection( self, id, cls, description=None):
24    assert not self.closed, 'Attempt to add sub-section to closed report section'
25    self.subsections.append( reportSection(id, cls, parent=self, description=description )  )
26    self.auditDone = False
27    return self.subsections[-1]
28
29  def addRecord( self, id, cls, res, msg ):
30    assert not self.closed, 'Attempt to add record to closed report section'
31    self.records.append( (id, cls, res, msg) )
32    self.auditDone = False
33
34  def close(self):
35    self.closed = True
36
37  def reopen(self):
38    self.closed = False
39
40  def audit(self):
41    if self.auditDone:
42      return
43    self.closed = True
44    self.fail = 0
45    self.npass = 0
46    for ss in self.subsections:
47      ss.audit()
48      self.fail += ss.fail
49      self.npass += ss.npass
50
51    for r in self.records:
52      if r[2]:
53        self.npass += 1
54      else:
55        self.fail += 1
56
57class abortChecks(Exception):
58  pass
59class loggedException(Exception):
60  pass
61class baseException(Exception):
62 
63  def __init__(self,msg):
64    self.msg = 'utils_c4:: %s' % msg
65
66  def __str__(self):
67        return unicode(self).encode('utf-8')
68
69  def __unicode__(self):
70        return self.msg % tuple([force_unicode(p, errors='replace')
71                                 for p in self.params])
72class checkSeq:
73  def __init__(self):
74    pass
75
76  def check(self,x):
77    d = map( lambda i: x[i+1] - x[i], range(len(x)-1) )
78    self.delt = sum(d)/len(d)
79    self.dmx = max(d)
80    self.dmn = min(d)
81    return self.dmx - self.dmn < abs(self.delt)*1.e-4
82
83cs = checkSeq()
84
85class checkBase:
86
87  def  __init__(self,cls="CORDEX",reportPass=True,parent=None,monitor=None):
88    self.cls = cls
89    self.project = cls
90    self.abortMessageCount = parent.abortMessageCount
91    self.monitor = monitor
92    ## check done earlier
93    ## assert cls in ['CORDEX','SPECS'],'This version of the checker only supports CORDEX, SPECS'
94    self.re_isInt = re.compile( '[0-9]+' )
95    self.errorCount = 0
96    self.passCount = 0
97    self.missingValue = 1.e20
98    from file_utils import ncLib
99    if ncLib == 'netCDF4':
100      import numpy
101      self.missingValue = numpy.float32(self.missingValue)
102    self.parent = parent
103    self.reportPass=reportPass
104    self.pcfg = parent.pcfg
105################################
106    self.requiredGlobalAttributes = self.pcfg.requiredGlobalAttributes
107    self.controlledGlobalAttributes = self.pcfg.controlledGlobalAttributes
108    self.globalAttributesInFn = self.pcfg.globalAttributesInFn
109    self.requiredVarAttributes = self.pcfg.requiredVarAttributes
110    self.drsMappings = self.pcfg.drsMappings
111#######################################
112    self.checks = ()
113    self.messageCount = 0
114    self.init()
115    if not hasattr( self.parent, 'amapListDraft' ):
116      self.parent.amapListDraft = []
117
118  def isInt(self,x):
119    return self.re_isInt.match( x ) != None
120
121  def logMessage(self, msg, error=False ):
122    self.messageCount += 1
123    assert self.abortMessageCount < 0 or self.abortMessageCount > self.messageCount, 'Raising error [TESTX01], perhaps for testing'
124    if self.parent != None and self.parent.log != None:
125       if error:
126         self.parent.log.error( msg )
127       else:
128         self.parent.log.info( msg )
129    else:
130       print msg
131
132    doThis = True
133    if self.appendLogfile[0] != None and doThis:
134      if self.monitor != None:
135         nofh0 = self.monitor.get_open_fds()
136      xlog = self.c4i.getFileLog( self.appendLogfile[1], flf=self.appendLogfile[0] )
137      if error:
138         xlog.error( msg )
139      else:
140         xlog.info( msg )
141      self.c4i.closeFileLog()
142      if self.monitor != None:
143         nofh9 = self.monitor.get_open_fds()
144         if nofh9 > nofh0:
145           print 'Leaking file handles [1]: %s --- %s' % (nofh0, nofh9)
146
147  def log_exception( self, msg):
148    if self.parent != None and self.parent.log != None:
149        self.parent.log.error("Exception has occured" ,exc_info=1)
150    else:
151        traceback.print_exc(file=sys.stdout)
152
153  def log_error( self, msg ):
154    self.lastError = msg
155    self.errorCount += 1
156    self.logMessage( '%s.%s: FAILED:: %s' % (self.id,self.checkId,msg), error=True )
157
158  def log_pass( self ):
159    self.passCount = True
160    if self.reportPass:
161      self.logMessage(  '%s.%s: OK' % (self.id,self.checkId) )
162
163  def log_abort( self ):
164    self.completed = False
165    self.logMessage(   '%s.%s: ABORTED:: Errors too severe to complete further checks in this module' % (self.id,'xxx') )
166    raise abortChecks
167
168  def status(self):
169    return '%s.%s' % (self.id,self.checkId)
170
171  def test(self,res,msg,abort=False,part=False,appendLogfile=(None,None)):
172    self.appendLogfile = appendLogfile
173    if res:
174      if not part:
175         self.log_pass()
176    else:
177      self.log_error(msg)
178      if abort:
179        self.log_abort()
180    return res
181
182  def runChecks(self):
183
184    try:
185      for c in self.checks:
186        c()  # run check
187      self.completed = True
188    except abortChecks:
189      ## error logging done before raising this exception
190      return
191    except:
192      self.log_exception( 'Exception caught by runChecks' )
193      raise loggedException
194      ##traceback.print_exc(file=open("errlog.txt","a"))
195      ##logger.error("Exception has occured" ,exc_info=1)
196   
197class checkFileName(checkBase):
198
199  def init(self):
200    self.id = 'C4.001'
201    self.checkId = 'unset'
202    self.step = 'Initialised'
203    self.checks = (self.do_check_fn,)
204####
205
206  def check(self,fn):
207    self.errorCount = 0
208    assert type(fn) in [type('x'),type(u'x')], '1st argument to "check" method of checkGrids shound be a string variable name (not %s)' % type(fn)
209    self.fn = fn
210
211    self.runChecks()
212###
213  def do_check_fn(self):
214    fn = self.fn
215    self.errorCount = 0
216    self.completed = False
217
218## check basic parsing of file name
219    self.checkId = '001'
220    self.test( fn[-3:] == '.nc', 'File name ending ".nc" expected', abort=True, part=True )
221    bits = string.split( fn[:-3], '_' )
222    self.fnParts = bits[:]
223
224    if self.pcfg.domainIndex != None:
225      self.domain = self.fnParts[self.pcfg.domainIndex]
226    else:
227      self.domain = None
228    ##if self.cls == 'CORDEX':
229      ##self.fnPartsOkLen = [8,9]
230      ##self.fnPartsOkFixedLen = [8,]
231      ##self.fnPartsOkUnfixedLen = [9,]
232      ##checkTrangeLen = True
233    ##elif self.cls == 'SPECS':
234      ##self.fnPartsOkLen = [6,7]
235      ##self.fnPartsOkFixedLen = [6,]
236      ##self.fnPartsOkUnfixedLen = [7,]
237      ##checkTrangeLen = False
238
239    self.test( len(bits) in self.pcfg.fnPartsOkLen, 'File name not parsed in %s elements [%s]' % (str(self.pcfg.fnPartsOkLen),str(bits)), abort=True )
240
241    if self.pcfg.groupIndex != None:
242      self.group = self.fnParts[self.pcfg.groupIndex]
243    else:
244      self.group = None
245
246    if self.pcfg.freqIndex != None:
247      self.freq = self.fnParts[self.pcfg.freqIndex]
248    elif self.group == 'fx':
249      self.freq = 'fx'
250    else:
251      self.freq = None
252
253    ##if self.cls == 'CORDEX':
254      ##self.freq = self.fnParts[7]
255    ##elif self.cls == 'SPECS':
256      ##self.freq = self.fnParts[1]
257
258    self.var = self.fnParts[0]
259
260    self.isFixed = self.freq == 'fx'
261
262    self.checkId = '002'
263    if not self.isFixed:
264
265## test time segment
266      bits = string.split( self.fnParts[-1], '-' )
267      self.test( len(bits) == 2, 'File time segment [%s] will not parse into 2 elements' % (self.fnParts[-1] ), abort=True, part=True )
268
269      self.test(  len(bits[0]) == len(bits[1]), 'Start and end time specified in file name [%s] of unequal length' % (self.fnParts[-1] ), abort=True, part=True  )
270
271      for b in bits:
272        self.test( self.isInt(b), 'Time segment in filename [%s] contains non integer characters' % (self.fnParts[-1] ),  abort=True, part=True  )
273      self.log_pass()
274      self.fnTimeParts = bits[:]
275
276    self.checkId = '003'
277    if self.isFixed:
278      self.test( len(self.fnParts) in self.pcfg.fnPartsOkFixedLen, 'Number of file name elements not acceptable for fixed data' )
279
280    self.checkId, ok = ('004',True)
281    if len(self.fnParts) == 9 and self.pcfg.checkTrangeLen:
282      ltr = { 'mon':6, 'sem':6, 'day':8, '3hr':[10,12], '6hr':10 }
283      ok &=self.test( self.freq in ltr.keys(), 'Frequency [%s] not recognised' % self.freq, part=True )
284      if ok:
285        if type( ltr[self.freq] ) == type(0):
286          msg = 'Length of time range parts [%s,%s] not equal to required length [%s] for frequency %s' % (self.fnTimeParts[0],self.fnTimeParts[1],ltr[self.freq],self.freq)
287          ok &= self.test( len(self.fnTimeParts[0]) == ltr[self.freq], msg, part=True )
288        elif type( ltr[self.freq] ) in [type([]),type( () )]:
289          msg = 'Length of time range parts [%s,%s] not in acceptable list [%s] for frequency %s' % (self.fnTimeParts[0],self.fnTimeParts[1],str(ltr[self.freq]),self.freq)
290          ok &= self.test( len(self.fnTimeParts[0]) in ltr[self.freq], msg, part=True )
291
292      if ok:
293        self.log_pass()
294    self.completed = True
295
296class checkGlobalAttributes(checkBase):
297
298  def init(self):
299    self.id = 'C4.002'
300    self.checkId = 'unset'
301    self.step = 'Initialised'
302    self.checks = (self.do_check_ga,)
303
304  def check(self,globalAts, varAts,varName,varGroup, vocabs, fnParts):
305    self.errorCount = 0
306    assert type(varName) in [type('x'),type(u'x')], '1st argument to "check" method of checkGrids shound be a string variable name (not %s)' % type(varName)
307    self.var = varName
308    self.globalAts = globalAts
309    self.varAts = varAts
310    self.varGroup = varGroup
311    self.vocabs = vocabs
312    self.fnParts = fnParts
313    self.runChecks()
314
315  def getDrs( self ):
316    assert self.completed, 'method getDrs should not be called if checks have not been completed successfully'
317    ee = {}
318    for k in self.drsMappings:
319      if self.drsMappings[k] == '@var':
320        ee[k] = self.var
321      elif self.drsMappings[k] == '@ensemble':
322        ee[k] = "r%si%sp%s" % (self.globalAts["realization"],self.globalAts["initialization_method"],self.globalAts["physics_version"])
323      elif self.drsMappings[k] == '@forecast_reference_time':
324        x = self.globalAts.get("forecast_reference_time",'yyyy-mm-dd Thh:mm:ssZ' )
325        ee[k] = "%s%s%s" % (x[:4],x[5:7],x[8:10])
326      elif self.drsMappings[k] == '@mip_id':
327        ee[k] = string.split( self.globalAts["table_id"] )[1]
328      else:
329        ee[k] = self.globalAts[ self.drsMappings[k] ]
330
331    for k in ['creation_date','tracking_id']:
332      if k in self.globalAts.keys():
333        ee[k] = self.globalAts[k]
334
335    return ee
336
337  def do_check_ga(self):
338    varName = self.var
339    globalAts = self.globalAts
340    varAts = self.varAts
341    varGroup = self.varGroup
342    vocabs = self.vocabs
343    fnParts = self.fnParts
344
345    self.completed = False
346    self.checkId = '001'
347    m = []
348    for k in self.requiredGlobalAttributes:
349      if not globalAts.has_key(k):
350         m.append(k)
351         self.globalAts[k] = '__errorReported__'
352
353    if not self.test( len(m)  == 0, 'Required global attributes missing: %s' % str(m) ):
354      gaerr = True
355      for k in m:
356        self.parent.amapListDraft.append( '#@;%s=%s|%s=%s' % (k,'__absent__',k,'<insert attribute value and uncomment>') )
357
358    self.checkId = '002'
359
360    self.test( varAts.has_key( varName ), 'Expected variable [%s] not present' % varName, abort=True, part=True )
361    msg = 'Variable %s not in table %s' % (varName,varGroup)
362    self.test( vocabs['variable'].isInTable( varName, varGroup ), msg, abort=True, part=True )
363
364    self.checkId = '003'
365
366    mipType = vocabs['variable'].getAttr( varName, varGroup, 'type' )
367    thisType = {'real':'float32', 'integer':'int32' }.get( mipType, mipType )
368    self.test( mipType == None or varAts[varName]['_type'] == thisType, 'Variable [%s/%s] not of type %s [%s]' % (varName,varGroup,thisType,varAts[varName]['_type']) )
369
370    self.checkId = '004'
371    m = []
372    reqAts = self.requiredVarAttributes[:]
373    if varGroup != 'fx' and self.pcfg.project in ['CORDEX']:
374      reqAts.append( 'cell_methods' )
375    for k in reqAts + vocabs['variable'].lists(varName, 'addRequiredAttributes'):
376      if not varAts[varName].has_key(k):
377         m.append(k)
378    if not self.test( len(m)  == 0, 'Required variable attributes missing: %s' % str(m) ):
379      vaerr = True
380      for k in m:
381        self.parent.amapListDraft.append( '#@var=%s;%s=%s|%s=%s' % (varName,k,'__absent__',k,'<insert attribute value and uncomment>') )
382        print self.parent.amapListDraft[-1]
383    ##vaerr = not self.test( len(m)  == 0, 'Required variable attributes missing: %s' % str(m) )
384
385    ##if vaerr or gaerr:
386      ##self.log_abort()
387
388## need to insert a check that variable is present
389    self.checkId = '005'
390    ok = True
391    hm = varAts[varName].get( 'missing_value', None ) != None
392    hf = varAts[varName].has_key( '_FillValue' )
393    if hm or hf:
394      ok &= self.test( hm, 'missing_value must be present if _FillValue is [%s]' % varName )
395      ok &= self.test( hf, '_FillValue must be present if missing_value is [%s]' % varName )
396      if mipType == 'real':
397        if varAts[varName].has_key( 'missing_value' ):
398           msg = 'Variable [%s] has incorrect attribute missing_value=%s [correct: %s]' % (varName,varAts[varName]['missing_value'],self.missingValue)
399           ok &= self.test( varAts[varName]['missing_value'] == self.missingValue, msg, part=True )
400        if varAts[varName].has_key( '_FillValue' ):
401           msg = 'Variable [%s] has incorrect attribute _FillValue=%s [correct: %s]' % (varName,varAts[varName]['_FillValue'],self.missingValue)
402           ok &= self.test( varAts[varName]['_FillValue'] == self.missingValue, msg, part=True )
403
404    mm = []
405   
406    contAts = ['long_name', 'standard_name', 'units']
407    if varGroup != 'fx':
408      contAts.append( 'cell_methods' )
409    hcm = varAts[varName].has_key( "cell_methods" )
410    for k in contAts + vocabs['variable'].lists(varName,'addControlledAttributes'):
411      targ = varAts[varName].get( k, 'Attribute not present' )
412      val = vocabs['variable'].getAttr( varName, varGroup, k )
413
414      if k == "cell_methods":
415        if val != None:
416          parenthesies1 = []
417          targ0 = targ[:]
418          while string.find( targ, '(' ) != -1:
419            i0 = targ.index( '(' )
420            i1 = targ.index( ')' )
421            parenthesies1.append( targ[i0:i1+1] )
422            targ = targ[:i0-1] + targ[i1+1:]
423          parenthesies2 = []
424          val0 = val[:]
425          while string.find( val, '(' ) != -1:
426            i0 = val.index( '(' )
427            i1 = val.index( ')' )
428            parenthesies2.append( val[i0:i1+1] )
429            val = val[:i0-1] + val[i1+1:]
430          for p in parenthesies2:
431            if p not in parenthesies1:
432              mm.append( (k,parenthesies1,p) )
433          if string.find( targ, val):
434             mm.append( (k,targ,val) )
435      elif targ != 'Attribute not present' and targ != val:
436        mm.append( (k,targ,val) )
437
438    ok &= self.test( len(mm)  == 0, 'Variable [%s] has incorrect attributes: %s' % (varName, strmm3(mm)), part=True )
439    if len( mm  ) != 0:
440      if self.parent.amapListDraft == None:
441        self.parent.amapListDraft = []
442      for m in mm:
443          self.parent.amapListDraft.append( '@var=%s;%s=%s|%s=%s' % (varName,m[0],m[1],m[0],m[2]) )
444
445    if ok:
446       self.log_pass()
447
448    if varGroup != 'fx' and hcm:
449      self.isInstantaneous = string.find( varAts[varName]['cell_methods'], 'time: point' ) != -1
450    else:
451      self.isInstantaneous = True
452
453    self.checkId = '006'
454    m = []
455    for a in self.controlledGlobalAttributes:
456      if globalAts.has_key(a):
457        try:
458          if not vocabs[a].check( str(globalAts[a]) ):
459            m.append( (a,globalAts[a],vocabs[a].note) )
460        except:
461          print 'failed trying to check global attribute %s' % a
462          raise
463
464    if not self.test( len(m)  == 0, 'Global attributes do not match constraints: %s' % str(m) ):
465      for t in m:
466        self.parent.amapListDraft.append( '#@;%s=%s|%s=%s' % (t[0],str(t[1]),t[0],'<insert attribute value and uncomment>' + str(t[2]) ) )
467
468    self.checkId = '007'
469    m = []
470    for i in range(len(self.globalAttributesInFn)):
471       if self.globalAttributesInFn[i] != None:
472         targVal = fnParts[i]
473         if self.globalAttributesInFn[i][0] == "@":
474           if self.globalAttributesInFn[i][1:] == "mip_id":
475               thisVal = string.split( globalAts["table_id"] )[1]
476           elif self.globalAttributesInFn[i][1:] == "experiment_family":
477               thisVal = globalAts["experiment_id"][:-4]
478           elif self.globalAttributesInFn[i][1:] == "ensemble":
479               thisVal = "r%si%sp%s" % (globalAts["realization"],globalAts["initialization_method"],globalAts["physics_version"])
480           elif self.globalAttributesInFn[i][1:] == "forecast_reference_time":
481               x = self.globalAts.get("forecast_reference_time",'yyyy-mm-dd Thh:mm:ssZ' )
482               thisVal = "S%s%s%s" % (x[:4],x[5:7],x[8:10])
483           elif self.globalAttributesInFn[i][1:] == "series":
484               thisVal = 'series%s' % globalAts["series"]
485           elif self.globalAttributesInFn[i][1:] == "experiment_family":
486             thisVal = globalAts["experiment_id"][:-4]
487           else:
488               assert False, "Not coded to deal with this configuration: globalAttributesInFn[%s]=%s" % (i,self.globalAttributesInFn[i])
489           ##print "Generated text val: %s:: %s" % (self.globalAttributesInFn[i], thisVal)
490         
491         else:
492             thisVal = globalAts[self.globalAttributesInFn[i]]
493
494         if thisVal not in [targVal,'__errorReported__']:
495             m.append( (i,self.globalAttributesInFn[i]) )
496
497    self.test( len(m)  == 0,'File name segments do not match corresponding global attributes: %s' % str(m) )
498
499    self.completed = True
500       
501class checkStandardDims(checkBase):
502
503  def init(self):
504    self.id = 'C4.003'
505    self.checkId = 'unset'
506    self.step = 'Initialised'
507    self.checks = (self.do_check,)
508    self.plevRequired = self.pcfg.plevRequired
509    self.plevValues = self.pcfg.plevValues
510    self.heightRequired = self.pcfg.heightRequired
511    self.heightValues = self.pcfg.heightValues
512    self.heightRange = self.pcfg.heightRange
513
514  def check(self,varName,varGroup, da, va, isInsta):
515    self.errorCount = 0
516    assert type(varName) in [type('x'),type(u'x')], '1st argument to "check" method of checkGrids shound be a string variable name (not %s)' % type(varName)
517    self.var = varName
518    self.varGroup = varGroup
519    self.da = da
520    self.va = va
521    self.isInsta = isInsta
522    self.runChecks()
523
524  def do_check(self):
525    varName = self.var
526    varGroup = self.varGroup
527    da = self.da
528    va = self.va
529    isInsta = self.isInsta
530
531    self.errorCount = 0
532    self.completed = False
533    self.checkId = '001'
534    if varGroup != 'fx':
535      ok = True
536      self.test( 'time' in da.keys(), 'Time dimension not found' , abort=True, part=True )
537      if not isInsta:
538        ok &= self.test(  da['time'].get( 'bounds', 'xxx' ) == 'time_bnds', 'Required bounds attribute not present or not correct value', part=True )
539
540## is time zone designator needed?
541      tunits = da['time'].get( 'units', 'xxx' )
542      if self.project  == 'CORDEX':
543        ok &= self.test( tunits in ["days since 1949-12-01 00:00:00Z", "days since 1949-12-01 00:00:00", "days since 1949-12-01"],
544               'Time units [%s] attribute not set correctly to "days since 1949-12-01 00:00:00Z"' % tunits, part=True )
545      else:
546        ok &= self.test( tunits[:10] == "days since", 'time units [%s] attribute not set correctly to "days since ....."' % tunits, part=True )
547
548      ok &= self.test(  da['time'].has_key( 'calendar' ), 'Time: required attribute calendar missing', part=True )
549
550      ok &= self.test( da['time']['_type'] == "float64", 'Time: data type not float64', part=True )
551       
552      if ok:
553        self.log_pass()
554      self.calendar = da['time'].get( 'calendar', 'None' )
555    else:
556      self.calendar = 'None'
557    self.checkId = '002'
558    if varName in self.plevRequired:
559      ok = True
560      self.test( 'plev' in va.keys(), 'plev coordinate not found %s' % str(va.keys()), abort=True, part=True )
561
562      ok &= self.test( int( va['plev']['_data'][0] ) == self.plevValues[varName],  \
563                  'plev value [%s] does not match required [%s]' % (va['plev']['_data'],self.plevValues[varName] ), part=True )
564     
565      plevAtDict = {'standard_name':"air_pressure", \
566                    'long_name':"pressure", \
567                    'units':"Pa", \
568                    'positive':"down", \
569                    'axis':"Z" }
570
571      if varName in ['clh','clm','cll']:
572        plevAtDict['bounds']= "plev_bnds"
573
574      for k in plevAtDict.keys():
575        ok &= self.test( va['plev'].get( k, None ) == plevAtDict[k], 
576                     'plev attribute %s absent or wrong value (should be %s)' % (k,plevAtDict[k]), part=True )
577
578      if varName in ['clh','clm','cll']:
579         self.test( "plev_bnds" in va.keys(), 'plev_bnds variable not found %s' % str(va.keys()), abort=True, part=True )
580         mm = []
581         for k in plevAtDict.keys():
582            if k != 'bounds' and k in va['plev_bnds'].keys():
583               if va['plev_bnds'][k] != va['plev'][k]:
584                 mm.append(k)
585         ok &= self.test( len(mm) == 0, 'Attributes of plev_bnds do not match those of plev: %s' % str(mm), part=True )
586
587         bndsVals = {'clh':[44000, 0], 'clm':[68000, 44000], 'cll':[100000, 68000] }
588         res = self.test( len( va['plev_bnds']['_data'] ) == 2, 'plev_bnds array is of wrong length', part=True )
589         ok &= res
590         if res:
591            kk = 0
592            for i in [0,1]:
593               if int(va['plev_bnds']['_data'][i]) != bndsVals[varName][i]:
594                  kk+=1
595            ok &= self.test( kk == 0, 'plev_bnds values not correct: should be %s' % str(bndsVals[varName]), part=True )
596
597      if ok:
598        self.log_pass()
599
600    self.checkId = '003'
601    if varName in self.heightRequired:
602      heightAtDict = {'long_name':"height", 'standard_name':"height", 'units':"m", 'positive':"up", 'axis':"Z" }
603      ok = True
604      ok &= self.test( 'height' in va.keys(), 'height coordinate not found %s' % str(va.keys()), abort=True, part=True )
605      ##ok &= self.test( abs( va['height']['_data'] - self.heightValues[varName]) < 0.001, \
606                ##'height value [%s] does not match required [%s]' % (va['height']['_data'],self.heightValues[varName] ), part=True )
607
608      ok1 = self.test( len( va['height']['_data'] ) == 1, 'More height values (%s) than expected (1)' % (len( va['height']['_data'])), part=True )
609      if ok1:
610        r = self.heightRange[varName]
611        ok1 &= self.test( r[0] <= va['height']['_data'][0] <= r[1], \
612                'height value [%s] not in specified range [%s]' % (va['height']['_data'], (self.heightRange[varName] ) ), part=True )
613
614      ok &= ok1
615     
616      for k in heightAtDict.keys():
617        val =  va['height'].get( k, "none" )
618        if not self.test( val == heightAtDict[k], \
619                         'height attribute %s absent or wrong value (should be %s)' % (k,heightAtDict[k]), part=True ):
620          self.parent.amapListDraft.append( '@var=%s;%s=%s|%s=%s' % ('height',k,val,k,heightAtDict[k]) )
621          ok = False
622
623      if ok:
624        self.log_pass()
625
626    self.completed = True
627
628class checkGrids(checkBase):
629
630  def init(self):
631    self.id = 'C4.004'
632    self.checkId = 'unset'
633    self.step = 'Initialised'
634    self.checks = (self.do_check_rp,self.do_check_intd)
635
636  def check(self,varName, domain, da, va):
637    self.errorCount = 0
638    assert type(varName) in [type('x'),type(u'x')], '1st argument to "check" method of checkGrids shound be a string variable name (not %s)' % type(varName)
639    self.var = varName
640    self.domain = domain
641    self.da = da
642    self.va = va
643
644    self.runChecks()
645    ##for c in self.checks:
646      ##c()
647    ##self.do_check_rp()
648    ##self.do_check_intd()
649
650  def do_check_rp(self):
651    varName = self.var
652    domain = self.domain
653    da = self.da
654    va = self.va
655    if va[varName].get( 'grid_mapping', None ) == "rotated_pole":
656      self.checkId = '001'
657      atDict = { 'grid_mapping_name':'rotated_latitude_longitude' }
658      atDict['grid_north_pole_latitude'] = self.pcfg.rotatedPoleGrids[domain]['grid_np_lat']
659      if self.pcfg.rotatedPoleGrids[domain]['grid_np_lon'] != 'N/A':
660        atDict['grid_north_pole_longitude'] = self.pcfg.rotatedPoleGrids[domain]['grid_np_lon']
661
662      self.checkId = '002'
663      self.test( 'rlat' in da.keys() and 'rlon' in da.keys(), 'rlat and rlon not found (required for grid_mapping = rotated_pole )', abort=True, part=True )
664
665      atDict = {'rlat':{'long_name':"rotated latitude", 'standard_name':"grid_latitude", 'units':"degrees", 'axis':"Y", '_type':'float64'},
666                'rlon':{'long_name':"rotated longitude", 'standard_name':"grid_longitude", 'units':"degrees", 'axis':"X", '_type':'float64'} }
667      mm = []
668      for k in ['rlat','rlon']:
669        for k2 in atDict[k].keys():
670          if atDict[k][k2] != da[k].get(k2, None ):
671            mm.append( (k,k2) )
672            record = '#@ax=%s;%s=%s|%s=%s <uncomment if correct>' % (k,k2,da[k].get(k2, '__missing__'),k2,atDict[k][k2]   )
673            self.parent.amapListDraft.append( record )
674      self.test( len(mm) == 0, 'Required attributes of grid coordinate arrays not correct: %s' % str(mm) )
675
676      self.checkId = '003'
677      ok = True
678      for k in ['rlat','rlon']:
679        res = len(da[k]['_data']) == self.pcfg.rotatedPoleGrids[domain][ {'rlat':'nlat','rlon':'nlon' }[k] ]
680        if not res:
681          self.test( res, 'Size of %s dimension does not match specification (%s,%s)' % (k,a,b), part=True  )
682          ok = False
683
684      a = ( da['rlat']['_data'][0], da['rlat']['_data'][-1], da['rlon']['_data'][0], da['rlon']['_data'][-1] )
685      b = map( lambda x: self.pcfg.rotatedPoleGrids[domain][x], ['s','n','w','e'] )
686      mm = []
687      for i in range(4):
688        if abs(a[i] - b[i]) > self.pcfg.gridSpecTol:
689          mm.append( (a[i],b[i]) )
690
691      ok &= self.test( len(mm) == 0, 'Domain boundaries for rotated pole grid do not match %s within tolerance (%s)' % (str(mm),self.pcfg.gridSpecTol), part=True )
692
693      for k in ['rlat','rlon']:
694        ok &= self.test( cs.check( da[k]['_data'] ), '%s values not evenly spaced -- min/max delta = %s, %s' % (k,cs.dmn,cs.dmx), part=True )
695
696      if ok:
697        self.log_pass()
698
699  def do_check_intd(self):
700    varName = self.var
701    domain = self.domain
702    da = self.da
703    va = self.va
704    if domain[-1] == 'i':
705      self.checkId = '002'
706      self.test( 'lat' in da.keys() and 'lon' in da.keys(), 'lat and lon not found (required for interpolated data)', abort=True, part=True )
707
708      atDict = {'lat':{'long_name':"latitude", 'standard_name':"latitude", 'units':"degrees_north", '_type':'float64'},
709                'lon':{'long_name':"longitude", 'standard_name':"longitude", 'units':"degrees_east", '_type':'float64'} }
710      mm = []
711      for k in ['lat','lon']:
712        for k2 in atDict[k].keys():
713          if atDict[k][k2] != da[k].get(k2, None ):
714            mm.append( (k,k2) )
715            record = '#@ax=%s;%s=%s|%s=%s <uncomment if correct>' % (k,k2,da[k].get(k2, '__missing__'),k2,atDict[k][k2]   )
716            self.parent.amapListDraft.append( record )
717
718      self.test( len(mm) == 0,  'Required attributes of grid coordinate arrays not correct: %s' % str(mm), part=True )
719
720      ok = True
721      for k in ['lat','lon']:
722        res = len(da[k]['_data']) >= self.pcfg.interpolatedGrids[domain][ {'lat':'nlat','lon':'nlon' }[k] ]
723        if not res:
724          a,b =  len(da[k]['_data']), self.pcfg.interpolatedGrids[domain][ {'lat':'nlat','lon':'nlon' }[k] ]
725          self.test( res, 'Size of %s dimension does not match specification (%s,%s)' % (k,a,b), part=True )
726          ok = False
727
728      a = ( da['lat']['_data'][0], da['lat']['_data'][-1], da['lon']['_data'][0], da['lon']['_data'][-1] )
729      b = map( lambda x: self.pcfg.interpolatedGrids[domain][x], ['s','n','w','e'] )
730      rs = self.pcfg.interpolatedGrids[domain]['res']
731      c = [-rs,rs,-rs,rs]
732      mm = []
733      for i in range(4):
734        if a[i] != b[i]:
735          x = (a[i]-b[i])/c[i]
736          if x < 0 or abs( x - int(x) ) > 0.001:
737             skipThis = False
738             if self.project  == 'CORDEX':
739               if domain[:3] == 'ANT':
740                 if i == 2 and abs( a[i] - 0.25 ) < 0.001:
741                    skipThis = True
742                 elif i == 3 and abs( a[i] - 359.75 ) < 0.001:
743                    skipThis = True
744             if not skipThis:
745               mm.append( (a[i],b[i]) )
746
747      ok &= self.test( len(mm) == 0, 'Interpolated grid boundary error: File %s; Req. %s' % (str(a),str(b)), part=True )
748
749      for k in ['lat','lon']:
750        ok &= self.test( cs.check( da[k]['_data'] ), '%s values not evenly spaced -- min/max delta = %s, %s' % (k,cs.dmn,cs.dmx), part=True )
751      if ok:
752        self.log_pass()
753
754class mipVocab:
755
756  def __init__(self,pcfg,dummy=False):
757     project = pcfg.project
758     if dummy:
759       self.pcfg = pcfg
760       return self.dummyMipTable()
761     ##assert project in ['CORDEX','SPECS'],'Project %s not recognised' % project
762     ##if project == 'CORDEX':
763       ##dir = 'cordex_vocabs/mip/'
764       ##tl = ['fx','sem','mon','day','6h','3h']
765       ##vgmap = {'6h':'6hr','3h':'3hr'}
766       ##fnpat = 'CORDEX_%s'
767     ##elif project == 'SPECS':
768       ##dir = 'specs_vocabs/mip/'
769       ##tl = ['fx','Omon','Amon','Lmon','OImon','day','6hrLev']
770       ##vgmap = {}
771       ##fnpat = 'SPECS_%s'
772     dir, tl, vgmap, fnpat = pcfg.mipVocabPars
773     ms = mipTableScan()
774     self.varInfo = {}
775     self.varcons = {}
776     for f in tl:
777        vg = vgmap.get( f, f )
778        self.varcons[vg] = {}
779        fn = fnpat % f
780        ll = open( '%s%s' % (dir,fn) ).readlines()
781        ee = ms.scan_table(ll,None,asDict=True)
782        for v in ee.keys():
783## set global default: type float
784          eeee = { 'type':pcfg.defaults.get( 'variableDataType', 'float' ) }
785          ar = []
786          ac = []
787          for a in ee[v][1].keys():
788            eeee[a] = ee[v][1][a]
789          ##if 'positive' in eeee.keys():
790            ##ar.append( 'positive' )
791            ##ac.append( 'positive' )
792          self.varInfo[v] = {'ar':ar, 'ac':ac }
793          self.varcons[vg][v] = eeee
794           
795  def dummyMipTable(self):
796     self.varInfo = {}
797     self.varcons = {}
798     ee = { 'standard_name':'sn%s', 'long_name':'n%s', 'units':'1' }
799     dir, tl, vgmap, fnpat = self.pcfg.mipVocabPars
800     for f in tl:
801        vg = vgmap.get( f, f )
802        self.varcons[vg] = {}
803        for i in range(12):
804          v = 'v%s' % i
805          eeee = {}
806          eeee['standard_name'] = ee['standard_name'] % i
807          eeee['long_name'] = ee['long_name'] % i
808          eeee['cell_methods'] = 'time: point'
809          eeee['units'] = ee['units']
810          eeee['type'] = 'float'
811          ar = []
812          ac = []
813          self.varInfo[v] = {'ar':ar, 'ac':ac }
814          self.varcons[vg][v] = eeee
815
816  def lists( self, k, k2 ):
817     if k2 == 'addRequiredAttributes':
818       return self.varInfo[k]['ar']
819     elif k2 == 'addControlledAttributes':
820       return self.varInfo[k]['ac']
821     else:
822       raise 'mipVocab.lists called with bad list specifier %s' % k2
823
824  def isInTable( self, v, vg ):
825    assert vg in self.varcons.keys(), '%s not found in  self.varcons.keys() [%s]' % (vg,str(self.varcons.keys()) )
826    return (v in self.varcons[vg].keys())
827     
828  def getAttr( self, v, vg, a ):
829    assert vg in self.varcons.keys(), '%s not found in  self.varcons.keys()'
830    assert v in self.varcons[vg].keys(), '%s not found in self.varcons[%s].keys()' % (v,vg)
831     
832    return self.varcons[vg][v][a]
833     
834class patternControl:
835
836  def __init__(self,tag,pattern,list=None):
837    try:
838      self.re_pat = re.compile( pattern )
839    except:
840      print "Failed to compile pattern >>%s<< (%s)" % (pattern, tag)
841    self.pattern = pattern
842    self.list = list
843
844  def check(self,val):
845    self.note = '-'
846    m = self.re_pat.match( val )
847    if self.list == None:
848      self.note = "simple test"
849      return m != None
850    else:
851      if m == None:
852        self.note = "no match %s::%s" % (val,self.pattern)
853        return False
854      if not m.groupdict().has_key("val"):
855        self.note = "no 'val' in match"
856        return False
857      self.note = "val=%s" % m.groupdict()["val"]
858      return m.groupdict()["val"] in self.list
859   
860class listControl:
861  def __init__(self,tag,list,split=False,splitVal=None):
862    self.list = list
863    self.tag = tag
864    self.split = split
865    self.splitVal = splitVal
866
867  def check(self,val):
868    self.note = '-'
869    if len(self.list) < 4:
870      self.note = str( self.list )
871    else:
872      self.note = str( self.list[:4] )
873    if self.split:
874      if self.splitVal == None:
875        vs = string.split( val )
876      else:
877        vs = string.split( val, self.spliVal )
878      return all( map( lambda x: x in self.list, vs ) )
879    else:
880      return val in self.list
881
882
883class checkByVar(checkBase):
884
885  def init(self):
886    self.id = 'C5.001'
887    self.checkId = 'unset'
888    self.step = 'Initialised'
889    self.checks = (self.checkTrange,)
890
891  def setLogDict( self,fLogDict ):
892    self.fLogDict = fLogDict
893
894  def impt(self,flist):
895    ee = {}
896    for f in flist:
897      fn = string.split(f, '/' )[-1]
898      fnParts = string.split( fn[:-3], '_' )
899      ##if self.cls == 'CORDEX':
900        ##isFixed = fnParts[7] == 'fx'
901        ##group = fnParts[7]
902      ##elif self.cls == 'SPECS':
903        ##isFixed = fnParts[1] == 'fx'
904        ##group = fnParts[1]
905
906      if self.pcfg.freqIndex != None:
907        freq = fnParts[self.pcfg.freqIndex]
908      else:
909        freq = None
910
911      isFixed = freq == 'fx'
912      group = fnParts[ self.pcfg.groupIndex ]
913
914      if isFixed:
915        trange = None
916      else:
917        trange = string.split( fnParts[-1], '-' )
918      var = fnParts[0]
919      thisKey = string.join( fnParts[:-1], '.' )
920      if group not in ee.keys():
921        ee[group] = {}
922      if thisKey not in ee[group].keys():
923        ee[group][thisKey] = []
924      ee[group][thisKey].append( (f,fn,group,trange) )
925
926    nn = len(flist)
927    n2 = 0
928    for k in ee.keys():
929      for k2 in ee[k].keys():
930        n2 += len( ee[k][k2] )
931
932    assert nn==n2, 'some file lost!!!!!!'
933    self.info =  '%s files, %s frequencies' % (nn,len(ee.keys()) )
934    self.ee = ee
935
936  def check(self, recorder=None,calendar='None',norun=False):
937    self.errorCount = 0
938    self.recorder=recorder
939    self.calendar=calendar
940    if calendar == '360-day':
941      self.enddec = 30
942    else:
943      self.enddec = 31
944    mm = { 'enddec':self.enddec }
945    self.pats = {'mon':('(?P<d>[0-9]{3})101','(?P<e>[0-9]{3})012'), \
946            'sem':('(?P<d>[0-9]{3})(012|101)','(?P<e>[0-9]{3})(011|010)'), \
947            'day':('(?P<d>[0-9]{3}[16])0101','(?P<e>[0-9]{3}[50])12%(enddec)s' % mm), \
948            'subd':('(?P<d>[0-9]{4})0101(?P<h1>[0-9]{2})(?P<mm>[30]0){0,1}$', '(?P<e>[0-9]{4})12%(enddec)s(?P<h2>[0-9]{2})([30]0){0,1}$' % mm ), \
949            'subd2':('(?P<d>[0-9]{4})0101(?P<h1>[0-9]{2})', '(?P<e>[0-9]{4})010100' ) }
950
951    if not norun:
952      self.runChecks()
953
954  def checkTrange(self):
955    keys = self.ee.keys()
956    keys.sort()
957    for k in keys:
958      if k != 'fx':
959        keys2 = self.ee[k].keys()
960        keys2.sort()
961        for k2 in keys2:
962          self.checkThisTrange( self.ee[k][k2], k )
963
964  def checkThisTrange( self, tt, group):
965
966    if group in ['3hr','6hr']:
967       kg = 'subd'
968    else:
969       kg = group
970    ps = self.pats[kg]
971    rere = (re.compile( ps[0] ), re.compile( ps[1] ) )
972
973    n = len(tt)
974    self.checkId = '001'
975    for j in range(n):
976      if self.monitor != None:
977         nofh0 = self.monitor.get_open_fds()
978      t = tt[j]
979      fn = t[1]
980      isFirst = j == 0
981      isLast = j == n-1
982      lok = True
983      for i in [0,1]:
984        if not (i==0 and isFirst or i==1 and isLast):
985          x = rere[i].match( t[3][i] )
986          lok &= self.test( x != None, 'Cannot match time range %s: %s [%s/%s]' % (i,fn,j,n), part=True, appendLogfile=(self.fLogDict.get(fn,None),fn) )
987        if not lok:
988          ### print 'Cannot match time range %s:' % t[1]
989          if self.recorder != None:
990            self.recorder.modify( t[1], 'ERROR: time range' )
991      if self.monitor != None:
992         nofh9 = self.monitor.get_open_fds()
993         if nofh9 > nofh0:
994           print 'Open file handles: %s --- %s [%s]' % (nofh0, nofh9, j )
995
996### http://stackoverflow.com/questions/2023608/check-what-files-are-open-in-python
997class sysMonitor:
998
999  def __init__(self):
1000    self.fhCountMax = 0
1001
1002  def get_open_fds(self):
1003    '''
1004    return the number of open file descriptors for current process
1005    .. warning: will only work on UNIX-like os-es.
1006    '''
1007    import subprocess
1008    import os
1009
1010    pid = os.getpid()
1011    self.procs = subprocess.check_output( 
1012        [ "lsof", '-w', '-Ff', "-p", str( pid ) ] )
1013
1014    self.ps = filter( 
1015            lambda s: s and s[ 0 ] == 'f' and s[1: ].isdigit(),
1016            self.procs.split( '\n' ) )
1017    self.fhCountMax = max( self.fhCountMax, len(self.ps) )
1018    return len( self.ps )
Note: See TracBrowser for help on using the repository browser.