CMS 3D CMS Logo

Functions | Variables

lumiValidate Namespace Reference

Functions

def getValidationData
def insertupdateValidationData
def main
 ######################## ## ## ################## ## ## ## ## Main Program ## ## ## ## ################## ## ## ######################## ##

Variables

string VERSION = '1.00'

Function Documentation

def lumiValidate::getValidationData (   dbsession,
  run = None,
  cmsls = None 
)
retrieve validation data per run or all
input: runnum, if not runnum, retrive all
output: {run:[[cmslsnum,flag,comment]]}

Definition at line 9 of file lumiValidate.py.

00010                                                     :
00011     '''retrieve validation data per run or all
00012     input: runnum, if not runnum, retrive all
00013     output: {run:[[cmslsnum,flag,comment]]}
00014     '''
00015     result={}
00016     try:
00017         dbsession.transaction().start(True)
00018         schema=dbsession.nominalSchema()
00019         queryHandle=dbsession.nominalSchema().newQuery()
00020         result=lumiQueryAPI.validation(queryHandle,run,cmsls)
00021         del queryHandle
00022         dbsession.transaction().commit()
00023     except Exception, e:
00024         dbsession.transaction().rollback()
00025         del dbsession
00026         raise Exception, 'lumiValidate.getValidationData:'+str(e)
00027     return result

def lumiValidate::insertupdateValidationData (   dbsession,
  data 
)
input: data {run:[[ls,status,comment]]}

Definition at line 28 of file lumiValidate.py.

00029                                               :
00030     '''
00031     input: data {run:[[ls,status,comment]]}
00032     '''
00033     toreplacenocomment=[]#[[('RUNNUM',runnum),('CMSLSNUM',cmslsnum),('FLAG',flag)],[]]
00034     toreplacewcomment=[]#[[('RUNNUM',runnum),('CMSLSNUM',cmslsnum),('FLAG',flag),('COMMENT',comment)],[]]
00035     toinsert=[] #[[('RUNNUM',runnum),('CMSLSNUM',cmslsnum),('FLAG',flag),('COMMENT',comment)],[]]
00036     try:
00037         dbsession.transaction().start(True)
00038         dbutil=dbUtil.dbUtil(dbsession.nominalSchema())
00039         for run,alllsdata in data.items():
00040             lsselection=[]
00041             if len(alllsdata)==0:#cross query lumisummary to get all the cmslsnum for this run,then insert all to default
00042                 queryHandle=dbsession.nominalSchema().newQuery()
00043                 lumisummaryData=lumiQueryAPI.lumisummaryByrun(queryHandle,run,'0001')
00044                 del queryHandle
00045                 for lumisummary in lumisummaryData:
00046                     if lumisummary[-1]==1:#cmsalive
00047                         lsselection.append([lumisummary[0],'UNKNOWN','NA'])
00048             else:
00049                 lsselection=alllsdata
00050             if len(lsselection)==0:
00051                 print 'no LS found for run '+str(run)+' do nothing'
00052                 continue
00053             for lsdata in lsselection:
00054                 condition='RUNNUM=:runnum AND CMSLSNUM=:cmslsnum'
00055                 conditionDefDict={}
00056                 conditionDefDict['runnum']='unsigned int'
00057                 conditionDefDict['cmslsnum']='unsigned int'
00058                 conditionDict={}
00059                 conditionDict['runnum']=run
00060                 conditionDict['cmslsnum']=lsdata[0]
00061                 if dbutil.existRow(nameDealer.lumivalidationTableName(),condition,conditionDefDict,conditionDict):
00062                     if len(lsdata)>2 and lsdata[2]:
00063                         toreplacewcomment.append([('runnum',run),('cmslsnum',lsdata[0]),('flag',lsdata[1]),('comment',lsdata[2])])
00064                     else: 
00065                         toreplacenocomment.append([('runnum',run),('cmslsnum',lsdata[0]),('flag',lsdata[1]),('comment','')])
00066                 else:
00067                     if len(lsdata)>2 and lsdata[2]:
00068                         toinsert.append([('RUNNUM',run),('CMSLSNUM',lsdata[0]),('FLAG',lsdata[1]),('COMMENT',lsdata[2])])
00069                     else:
00070                         toinsert.append([('RUNNUM',run),('CMSLSNUM',lsdata[0]),('FLAG',lsdata[1]),('COMMENT','N/A')])
00071         dbsession.transaction().commit()
00072         #print 'toreplace with comment ',toreplacewcomment
00073         #print 'toreplace without comment ',toreplacenocomment
00074         #print 'toinsert ',toinsert
00075         #perform insert
00076         if len(toinsert)!=0:
00077             dbsession.transaction().start(False)
00078             dbutil=dbUtil.dbUtil(dbsession.nominalSchema())
00079             tabrowDef=[]
00080             tabrowDef.append(('RUNNUM','unsigned int'))
00081             tabrowDef.append(('CMSLSNUM','unsigned int'))
00082             tabrowDef.append(('FLAG','string'))
00083             tabrowDef.append(('COMMENT','string'))
00084             dbutil.bulkInsert(nameDealer.lumivalidationTableName(),tabrowDef,toinsert)
00085             dbsession.transaction().commit()
00086         #perform update with comment
00087         if len(toreplacewcomment)!=0:
00088             dbsession.transaction().start(False)
00089             dbutil=dbUtil.dbUtil(dbsession.nominalSchema())
00090             updateAction='FLAG=:flag,COMMENT=:comment'
00091             updateCondition='RUNNUM=:runnum and CMSLSNUM=:cmslsnum'
00092             bindvarDef=[]        
00093             bindvarDef.append(('flag','string'))
00094             bindvarDef.append(('comment','string'))
00095             bindvarDef.append(('runnum','unsigned int'))
00096             bindvarDef.append(('cmslsnum','unsigned int'))
00097             dbutil.updateRows(nameDealer.lumivalidationTableName(),updateAction,updateCondition,bindvarDef,toreplacewcomment)
00098             dbsession.transaction().commit()
00099         #perform update with NO comment
00100         if len(toreplacenocomment)!=0:
00101             dbsession.transaction().start(False)
00102             dbutil=dbUtil.dbUtil(dbsession.nominalSchema())
00103             updateAction='FLAG=:flag'
00104             updateCondition='RUNNUM=:runnum and CMSLSNUM=:cmslsnum'
00105             bindvarDef=[]        
00106             bindvarDef.append(('flag','string'))
00107             bindvarDef.append(('runnum','unsigned int'))
00108             bindvarDef.append(('cmslsnum','unsigned int'))
00109             dbutil.updateRows(nameDealer.lumivalidationTableName(),updateAction,updateCondition,bindvarDef,toreplacenocomment)
00110             dbsession.transaction().commit()
00111     except Exception, e:
00112         dbsession.transaction().rollback()
00113         del dbsession
00114         raise Exception, 'lumiValidate.insertupdateValidationData:'+str(e)
    
def lumiValidate::main ( )

######################## ## ## ################## ## ## ## ## Main Program ## ## ## ## ################## ## ## ######################## ##

Definition at line 123 of file lumiValidate.py.

00124           :
00125     parser = argparse.ArgumentParser(prog=os.path.basename(sys.argv[0]),description = "Lumi Validation",formatter_class=argparse.ArgumentDefaultsHelpFormatter)
00126     allowedActions = ['batchupdate','update','dump']
00127     allowedFlags = ['UNKNOWN','GOOD','BAD','SUSPECT']
00128     # parse arguments
00129     parser.add_argument('action',choices=allowedActions,help='command actions')
00130     parser.add_argument('-c',dest='connect',action='store',required=True,help='connect string to lumiDB')
00131     parser.add_argument('-P',dest='authpath',action='store',required=True,help='path to authentication file')
00132     parser.add_argument('-i',dest='inputfile',action='store',help='lumi range selection file,required for batchupdate action')
00133     parser.add_argument('-o',dest='outputfile',action='store',help='output to csv file')
00134     parser.add_argument('-r',dest='runnumber',action='store',type=int,help='run number,optional')
00135     parser.add_argument('-runls',dest='runls',action='store',help='selection string,optional. Example [1234:[],4569:[1,1],[2,100]]')
00136     parser.add_argument('-flag',dest='flag',action='store',default='UNKNOWN',help='flag string,optional')
00137     parser.add_argument('--verbose',dest='verbose',action='store_true',help='verbose mode for printing' )
00138     parser.add_argument('--debug',dest='debug',action='store_true',help='debug')
00139     options=parser.parse_args()
00140     if options.flag.upper() not in allowedFlags:
00141         print 'unrecognised flag ',options.flag.upper()
00142         raise
00143     os.environ['CORAL_AUTH_PATH'] = options.authpath
00144     connectstring=options.connect
00145     svc = coral.ConnectionService()
00146     msg=coral.MessageStream('')
00147     if options.debug:
00148         msg.setMsgVerbosity(coral.message_Level_Debug)
00149     else:
00150         msg.setMsgVerbosity(coral.message_Level_Error)
00151     session=svc.connect(connectstring,accessMode=coral.access_Update)
00152     session.typeConverter().setCppTypeForSqlType("unsigned int","NUMBER(10)")
00153     session.typeConverter().setCppTypeForSqlType("unsigned long long","NUMBER(20)")
00154     
00155     result={}#parsing result {run:[[ls,status,comment]]}
00156     if options.debug :
00157         msg=coral.MessageStream('')
00158         msg.setMsgVerbosity(coral.message_Level_Debug)
00159     
00160     if options.action=='batchupdate':
00161         #populate from csv file, require -i argument
00162         if not options.inputfile:
00163             print 'inputfile -i option is required for batchupdate'
00164             raise
00165         csvReader=csv.reader(open(options.inputfile),delimiter=',')
00166         for row in csvReader:
00167             if len(row)==0:
00168                 continue
00169             fieldrun=str(row[0]).strip()
00170             fieldls=str(row[1]).strip()
00171             fieldstatus=row[2]
00172             fieldcomment=row[3]
00173             if not result.has_key(int(fieldrun)):
00174                 result[int(fieldrun)]=[]
00175             result[int(fieldrun)].append([int(fieldls),fieldstatus,fieldcomment])
00176         insertupdateValidationData(session,result)
00177     if options.action=='update':
00178         #update flag interactively, require -runls argument
00179         #runls={run:[]} populate all CMSLSNUM found in LUMISUMMARY
00180         #runls={run:[[1,1],[2,5]],run:[[1,1],[2,5]]}
00181         #default value
00182         if not options.runls and not options.runnumber:
00183             print 'option -runls or -r is required for update'
00184             raise
00185         if not options.flag:
00186             print 'option -flag is required for update'
00187             raise
00188         if options.flag.upper() not in allowedFlags:
00189             print 'unrecognised flag ',options.flag
00190             raise
00191         if options.runnumber:
00192             runlsjson='{"'+str(options.runnumber)+'":[]}'
00193         elif options.runls:
00194             runlsjson=CommonUtil.tolegalJSON(options.runls)
00195         sparser=selectionParser.selectionParser(runlsjson)
00196         runsandls=sparser.runsandls()
00197         commentStr='NA'
00198         statusStr=options.flag
00199         for run,lslist in runsandls.items():
00200             if not result.has_key(run):
00201                 result[run]=[]
00202             for ls in lslist:
00203                 result[run].append([ls,statusStr,commentStr])
00204         insertupdateValidationData(session,result)
00205     if options.action=='dump':
00206         if options.runls or options.inputfile:
00207             if options.runls:
00208                 runlsjson=CommonUtil.tolegalJSON(options.runls)
00209                 sparser=selectionParser.selectionParser(runlsjson)
00210                 runsandls=sparser.runsandls()
00211             if options.inputfile:
00212                 p=inputFilesetParser.inputFilesetParser(options.inputfile)
00213                 runsandls=p.runsandls()
00214             for runnum,lslist in runsandls.items():
00215                 dataperrun=getValidationData(session,run=runnum,cmsls=lslist)
00216                 if dataperrun.has_key(runnum):
00217                     result[runnum]=dataperrun[runnum]
00218                 else:
00219                     result[runnum]=[]
00220         else:
00221             result=getValidationData(session,run=options.runnumber)
00222         runs=result.keys()
00223         runs.sort()
00224         if options.outputfile:
00225             r=csvReporter.csvReporter(options.outputfile)
00226             for run in runs:
00227                 for perrundata in result[run]:
00228                     r.writeRow([str(run),str(perrundata[0]),perrundata[1],perrundata[2]])
00229         else:
00230             for run in runs:
00231                 print '== ='
00232                 if len(result[run])==0:
00233                     print str(run),'no validation data'
00234                     continue
00235                 for lsdata in result[run]:
00236                     print str(run)+','+str(lsdata[0])+','+lsdata[1]+','+lsdata[2]
00237                 
00238     del session
    del svc

Variable Documentation

string lumiValidate::VERSION = '1.00'

Definition at line 2 of file lumiValidate.py.