UserCode/RateMonShiftTool_dev/CheckPrescales.py

#!/usr/bin/env python

import sys
import os
import getopt

from DatabaseParser import ConnectDB

def usage():
    print sys.argv[0] + " [options] HLTKey GTKey GTRS Key"
    print "options:"
    print "-v                 Verbose Mode"
    print "--ignore=<cols>    list (comma-separated) of prescale columns to ignore"

def main():
    try:
        opt, args = getopt.getopt(sys.argv[1:],"v",["ignore="])
        
    except getopt.GetoptError, err:
        print str(err)
        usage()
        sys.exit(2)

    if len(args)!=3:
        usage()
        sys.exit(0)

    HLT_Key  = args[0]
    GT_Key   = args[1]
    GTRS_Key = args[2]
    Verbose = False
    PSColsToIgnore = []

    for o,a in opt:
        if o=="-v":
            Verbose = True
        elif o=="--ignore":            
            for c in a.split(','):
                try:
                    PSColsToIgnore.append(int(c))
                except:
                    print "\nERROR: %s is not a valid prescale column\n" % c
                    usage()
                    sys.exit(0)
    psTable = GetPrescaleTable(HLT_Key,GT_Key,GTRS_Key,PSColsToIgnore,True)

    if Verbose:
        firstPS = {}
        for trigger,prescales in psTable.iteritems():
            firstPed = firstPrescaled(prescales,PSColsToIgnore)
            if not firstPS.has_key(firstPed):
                firstPS[firstPed] = []
            firstPS[firstPed].append(trigger)

           
        for col,triggers in firstPS.iteritems():
            if col == -1:
                print "The following triggers are never prescaled:"
            else:
                print "The following triggers are first prescaled in col %d" % (col,)
            for trig in triggers: print "\t%s" % (trig,)
               
            
def GetPrescaleTable(HLT_Key,GT_Key,GTRS_Key,PSColsToIgnore,doPrint):
    curs = ConnectDB('hlt')

    ## Get the HLT seeds
    sqlquery ="""  
    SELECT I.NAME,A.VALUE
    FROM
    CMS_HLT.STRINGPARAMVALUES A,
    CMS_HLT.PARAMETERS B,
    CMS_HLT.SUPERIDPARAMETERASSOC C,
    CMS_HLT.MODULETEMPLATES D,
    CMS_HLT.MODULES E,
    CMS_HLT.PATHMODULEASSOC F,
    CMS_HLT.CONFIGURATIONPATHASSOC G,
    CMS_HLT.CONFIGURATIONS H,
    CMS_HLT.PATHS I
    WHERE
    A.PARAMID = C.PARAMID AND
    B.PARAMID = C.PARAMID AND
    B.NAME = 'L1SeedsLogicalExpression' AND
    C.SUPERID = F.MODULEID AND
    D.NAME = 'HLTLevel1GTSeed' AND
    E.TEMPLATEID = D.SUPERID AND
    F.MODULEID = E.SUPERID AND
    F.PATHID=G.PATHID AND
    I.PATHID=G.PATHID AND
    G.CONFIGID=H.CONFIGID AND
    H.CONFIGDESCRIPTOR='%s' 
    ORDER BY A.VALUE
        """ % (HLT_Key,)
    curs.execute(sqlquery)
    HLTSeed = {}
    for HLTPath,L1Seed in curs.fetchall():
        if not HLTSeed.has_key(HLTPath): ## this should protect us from L1_SingleMuOpen
            tmp = L1Seed.lstrip('"').rstrip('"') 
            HLTSeed[HLTPath] = tmp.rstrip(' ')
            
    HLTPrescales = GetHLTPrescaleMatrix(curs,HLT_Key)

    L1Names = {}
    ## get the L1 algo names associated with each algo bit
    AlgoNameQuery = """SELECT ALGO_INDEX, ALIAS FROM CMS_GT.L1T_MENU_ALGO_VIEW
    WHERE MENU_IMPLEMENTATION IN (SELECT L1T_MENU_FK FROM CMS_GT.GT_SETUP WHERE ID='%s')
    ORDER BY ALGO_INDEX""" % (GT_Key,)
    curs.execute(AlgoNameQuery)
    for index,name in curs.fetchall():
        L1Names[name] = index

    L1Prescales = GetL1AlgoPrescales(curs,GTRS_Key)

    FullPrescales = {}
    formatString = "%55s%30s%45s%45s%45s"
    if doPrint:
        print "List of triggers with non-sequential prescales:"
        print formatString % ("HLT Name","L1 Name","Total","HLT","L1",)
    for HLTName,L1Seeds in HLTSeed.iteritems():
        if HLTName.startswith('AlCa'): ## the results don't make sense for AlCa paths
            continue
        if L1Seeds.isdigit():  ## skip TT seeded paths
            continue
        thisL1PS = []
        for seed in L1Seeds.split(' OR '): ## unwind the OR of multiple seeds
            seed = seed.lstrip(' ').rstrip(' ')
            if seed.isdigit():
                continue
            if not L1Names.has_key(seed):
                print "WARNING: %s uses non-existant L1 seed: %s" % (HLTName,seed,)
            tmp = L1Prescales[L1Names[seed]]
            if len(thisL1PS)==0:
                thisL1PS = tmp ## just set it for the first one
            else:
                for i,a,b in zip(range(len(tmp)),thisL1PS,tmp):
                    if b<a:
                        thisL1PS[i] = b # choose the minimum PS for each column
        if len(thisL1PS)==0:
            continue  ## this probably means that the seeding was an OR of TTs
        if HLTPrescales.has_key(HLTName):   ## if the HLT path is totally unprescaled it won't be listed in the PS service
            thisHLTPS = HLTPrescales[HLTName]
        else:
            thisHLTPS = [1]*len(thisL1PS)
        if not len(thisHLTPS) == len(thisL1PS):
            print "Incompatible number of prescales columns for trigger %s" % HLTName
            continue
        prescales = []
        for hlt,l1 in zip(thisHLTPS,thisL1PS):
            prescales.append(hlt*l1)
        #print HLTName+" HLT: "+str(thisHLTPS)+" L1: "+str(thisL1PS)+" Total: "+str(prescales)
        if not isSequential(prescales,PSColsToIgnore) and doPrint:
            print formatString % (HLTName,L1Seeds,prescales,thisHLTPS,thisL1PS,)
        FullPrescales[HLTName] = prescales
    return FullPrescales
            
def GetHLTPrescaleMatrix(cursor,HLT_Key):
    ## Get the config ID
    configIDQuery = "SELECT CONFIGID FROM CMS_HLT.CONFIGURATIONS WHERE CONFIGDESCRIPTOR='%s'" % (HLT_Key,)
    cursor.execute(configIDQuery)
    ConfigId, = cursor.fetchone()

    SequencePathQuery ="""
    SELECT F.SEQUENCENB,J.VALUE TRIGGERNAME
    FROM CMS_HLT.CONFIGURATIONSERVICEASSOC A
    , CMS_HLT.SERVICES B
    , CMS_HLT.SERVICETEMPLATES C
    , CMS_HLT.SUPERIDVECPARAMSETASSOC D
    , CMS_HLT.VECPARAMETERSETS E
    , CMS_HLT.SUPERIDPARAMSETASSOC F
    , CMS_HLT.PARAMETERSETS G
    , CMS_HLT.SUPERIDPARAMETERASSOC H
    , CMS_HLT.PARAMETERS I
    , CMS_HLT.STRINGPARAMVALUES J
    WHERE A.CONFIGID= %d
    AND A.SERVICEID=B.SUPERID
    AND B.TEMPLATEID=C.SUPERID
    AND C.NAME='PrescaleService'
    AND B.SUPERID=D.SUPERID
    AND D.VPSETID=E.SUPERID
    AND E.NAME='prescaleTable'
    AND D.VPSETID=F.SUPERID
    AND F.PSETID=G.SUPERID
    AND G.SUPERID=H.SUPERID
    AND I.PARAMID=H.PARAMID
    AND I.NAME='pathName'
    AND J.PARAMID=H.PARAMID
    ORDER BY F.SEQUENCENB
    """ % (ConfigId,)

    cursor.execute(SequencePathQuery)
    HLTSequenceMap = {}
    for seq,name in cursor.fetchall():
        name = name.lstrip('"').rstrip('"')
        HLTSequenceMap[seq]=name

    SequencePrescaleQuery="""
    SELECT F.SEQUENCENB,J.SEQUENCENB,J.VALUE
    FROM CMS_HLT.CONFIGURATIONSERVICEASSOC A
    , CMS_HLT.SERVICES B
    , CMS_HLT.SERVICETEMPLATES C
    , CMS_HLT.SUPERIDVECPARAMSETASSOC D
    , CMS_HLT.VECPARAMETERSETS E
    , CMS_HLT.SUPERIDPARAMSETASSOC F
    , CMS_HLT.PARAMETERSETS G
    , CMS_HLT.SUPERIDPARAMETERASSOC H
    , CMS_HLT.PARAMETERS I
    , CMS_HLT.VUINT32PARAMVALUES J
    WHERE A.CONFIGID=%d 
    AND A.SERVICEID=B.SUPERID
    AND B.TEMPLATEID=C.SUPERID
    AND C.NAME='PrescaleService'
    AND B.SUPERID=D.SUPERID
    AND D.VPSETID=E.SUPERID
    AND E.NAME='prescaleTable'
    AND D.VPSETID=F.SUPERID
    AND F.PSETID=G.SUPERID
    AND G.SUPERID=H.SUPERID
    AND I.PARAMID=H.PARAMID
    AND I.NAME='prescales'
    AND J.PARAMID=H.PARAMID
    ORDER BY F.SEQUENCENB,J.SEQUENCENB
    """ % (ConfigId,)

    #print HLTSequenceMap
    cursor.execute(SequencePrescaleQuery)
    HLTPrescaleTable= {}
    lastIndex=-1
    lastSeq=-1
    row = []
    for seq,index,val in cursor.fetchall():
        if lastIndex!=index-1:
            HLTPrescaleTable[HLTSequenceMap[seq-1]] = row
            row=[]
        lastSeq=seq
        lastIndex=index
        row.append(val)

    return HLTPrescaleTable

def GetL1AlgoPrescales(curs, GTRS_Key):
    L1PrescalesQuery= """
    SELECT
    PRESCALE_FACTOR_ALGO_000,PRESCALE_FACTOR_ALGO_001,PRESCALE_FACTOR_ALGO_002,PRESCALE_FACTOR_ALGO_003,PRESCALE_FACTOR_ALGO_004,PRESCALE_FACTOR_ALGO_005,
    PRESCALE_FACTOR_ALGO_006,PRESCALE_FACTOR_ALGO_007,PRESCALE_FACTOR_ALGO_008,PRESCALE_FACTOR_ALGO_009,PRESCALE_FACTOR_ALGO_010,PRESCALE_FACTOR_ALGO_011,
    PRESCALE_FACTOR_ALGO_012,PRESCALE_FACTOR_ALGO_013,PRESCALE_FACTOR_ALGO_014,PRESCALE_FACTOR_ALGO_015,PRESCALE_FACTOR_ALGO_016,PRESCALE_FACTOR_ALGO_017,
    PRESCALE_FACTOR_ALGO_018,PRESCALE_FACTOR_ALGO_019,PRESCALE_FACTOR_ALGO_020,PRESCALE_FACTOR_ALGO_021,PRESCALE_FACTOR_ALGO_022,PRESCALE_FACTOR_ALGO_023,
    PRESCALE_FACTOR_ALGO_024,PRESCALE_FACTOR_ALGO_025,PRESCALE_FACTOR_ALGO_026,PRESCALE_FACTOR_ALGO_027,PRESCALE_FACTOR_ALGO_028,PRESCALE_FACTOR_ALGO_029,
    PRESCALE_FACTOR_ALGO_030,PRESCALE_FACTOR_ALGO_031,PRESCALE_FACTOR_ALGO_032,PRESCALE_FACTOR_ALGO_033,PRESCALE_FACTOR_ALGO_034,PRESCALE_FACTOR_ALGO_035,
    PRESCALE_FACTOR_ALGO_036,PRESCALE_FACTOR_ALGO_037,PRESCALE_FACTOR_ALGO_038,PRESCALE_FACTOR_ALGO_039,PRESCALE_FACTOR_ALGO_040,PRESCALE_FACTOR_ALGO_041,
    PRESCALE_FACTOR_ALGO_042,PRESCALE_FACTOR_ALGO_043,PRESCALE_FACTOR_ALGO_044,PRESCALE_FACTOR_ALGO_045,PRESCALE_FACTOR_ALGO_046,PRESCALE_FACTOR_ALGO_047,
    PRESCALE_FACTOR_ALGO_048,PRESCALE_FACTOR_ALGO_049,PRESCALE_FACTOR_ALGO_050,PRESCALE_FACTOR_ALGO_051,PRESCALE_FACTOR_ALGO_052,PRESCALE_FACTOR_ALGO_053,
    PRESCALE_FACTOR_ALGO_054,PRESCALE_FACTOR_ALGO_055,PRESCALE_FACTOR_ALGO_056,PRESCALE_FACTOR_ALGO_057,PRESCALE_FACTOR_ALGO_058,PRESCALE_FACTOR_ALGO_059,
    PRESCALE_FACTOR_ALGO_060,PRESCALE_FACTOR_ALGO_061,PRESCALE_FACTOR_ALGO_062,PRESCALE_FACTOR_ALGO_063,PRESCALE_FACTOR_ALGO_064,PRESCALE_FACTOR_ALGO_065,
    PRESCALE_FACTOR_ALGO_066,PRESCALE_FACTOR_ALGO_067,PRESCALE_FACTOR_ALGO_068,PRESCALE_FACTOR_ALGO_069,PRESCALE_FACTOR_ALGO_070,PRESCALE_FACTOR_ALGO_071,
    PRESCALE_FACTOR_ALGO_072,PRESCALE_FACTOR_ALGO_073,PRESCALE_FACTOR_ALGO_074,PRESCALE_FACTOR_ALGO_075,PRESCALE_FACTOR_ALGO_076,PRESCALE_FACTOR_ALGO_077,
    PRESCALE_FACTOR_ALGO_078,PRESCALE_FACTOR_ALGO_079,PRESCALE_FACTOR_ALGO_080,PRESCALE_FACTOR_ALGO_081,PRESCALE_FACTOR_ALGO_082,PRESCALE_FACTOR_ALGO_083,
    PRESCALE_FACTOR_ALGO_084,PRESCALE_FACTOR_ALGO_085,PRESCALE_FACTOR_ALGO_086,PRESCALE_FACTOR_ALGO_087,PRESCALE_FACTOR_ALGO_088,PRESCALE_FACTOR_ALGO_089,
    PRESCALE_FACTOR_ALGO_090,PRESCALE_FACTOR_ALGO_091,PRESCALE_FACTOR_ALGO_092,PRESCALE_FACTOR_ALGO_093,PRESCALE_FACTOR_ALGO_094,PRESCALE_FACTOR_ALGO_095,
    PRESCALE_FACTOR_ALGO_096,PRESCALE_FACTOR_ALGO_097,PRESCALE_FACTOR_ALGO_098,PRESCALE_FACTOR_ALGO_099,PRESCALE_FACTOR_ALGO_100,PRESCALE_FACTOR_ALGO_101,
    PRESCALE_FACTOR_ALGO_102,PRESCALE_FACTOR_ALGO_103,PRESCALE_FACTOR_ALGO_104,PRESCALE_FACTOR_ALGO_105,PRESCALE_FACTOR_ALGO_106,PRESCALE_FACTOR_ALGO_107,
    PRESCALE_FACTOR_ALGO_108,PRESCALE_FACTOR_ALGO_109,PRESCALE_FACTOR_ALGO_110,PRESCALE_FACTOR_ALGO_111,PRESCALE_FACTOR_ALGO_112,PRESCALE_FACTOR_ALGO_113,
    PRESCALE_FACTOR_ALGO_114,PRESCALE_FACTOR_ALGO_115,PRESCALE_FACTOR_ALGO_116,PRESCALE_FACTOR_ALGO_117,PRESCALE_FACTOR_ALGO_118,PRESCALE_FACTOR_ALGO_119,
    PRESCALE_FACTOR_ALGO_120,PRESCALE_FACTOR_ALGO_121,PRESCALE_FACTOR_ALGO_122,PRESCALE_FACTOR_ALGO_123,PRESCALE_FACTOR_ALGO_124,PRESCALE_FACTOR_ALGO_125,
    PRESCALE_FACTOR_ALGO_126,PRESCALE_FACTOR_ALGO_127
    FROM CMS_GT.GT_FDL_PRESCALE_FACTORS_ALGO A, CMS_GT.GT_RUN_SETTINGS_PRESC_VIEW B
    WHERE A.ID=B.PRESCALE_FACTORS_ALGO_FK AND B.ID='%s'
    """ % (GTRS_Key,)
    curs.execute(L1PrescalesQuery)
    ## This is pretty horrible, but this how you get them!!
    tmp = curs.fetchall()
    L1PrescaleTable = []
    for ps in tmp[0]: #build the prescale table initially
        L1PrescaleTable.append([ps])
    for line in tmp[1:]: # now fill it
        for ps,index in zip(line,range(len(line))):
            L1PrescaleTable[index].append(ps)
    return L1PrescaleTable

def isSequential(row,ignore):
    seq = True
    lastEntry=999999999999
    for i,entry in enumerate(row):
        if i in ignore:
            continue
        if entry > lastEntry and lastEntry!=0:
            seq = False
            break
        lastEntry = entry
    return seq


def firstPrescaled(row,ignore):
    row.reverse()
    for i,val in enumerate(row):
        if len(row)-1-i in ignore:
            continue
        if val!=1: # prescaled
            return len(row)-1-i
    return -1

if __name__=='__main__':
    main()
Revision:	1.5
Committed:	Fri Apr 6 15:09:18 2012 UTC (13 years ago) by amott
Content type:	text/x-python
Branch:	MAIN
CVS Tags:	V00-02-05, V00-02-04, V00-02-03, V00-02-01, V00-01-10, V-00-01-10, V00-01-09, V00-01-08, V00-01-07, V00-01-06, V00-01-05, V00-01-04, V00-01-03, V00-01-02, V00-01-01, V00-00-34, V00-00-33, MenuAnalyzer_V00-00-02, MenuAnalyzer_V00-00-01, MenuAnalyzer_V1, V00-00-32, V00-00-31, V00-00-30, V00-00-29, V00-00-28, V00-00-27, V00-00-26
Changes since 1.4:	+3 -1 lines
Log Message:	updated to fix crash when there are extra spaces in the prescale modules
#	User	Rev	Content
1	amott	1.1	#!/usr/bin/env python
2
3			import sys
4			import os
5	amott	1.4	import getopt
6
7	amott	1.1	from DatabaseParser import ConnectDB
8
9			def usage():
10	amott	1.4	print sys.argv[0] + " [options] HLTKey GTKey GTRS Key"
11			print "options:"
12			print "-v Verbose Mode"
13			print "--ignore=<cols> list (comma-separated) of prescale columns to ignore"
14	amott	1.1
15			def main():
16	amott	1.4	try:
17			opt, args = getopt.getopt(sys.argv[1:],"v",["ignore="])
18
19			except getopt.GetoptError, err:
20			print str(err)
21			usage()
22			sys.exit(2)
23	amott	1.1
24	amott	1.4	if len(args)!=3:
25	amott	1.1	usage()
26			sys.exit(0)
27
28	amott	1.4	HLT_Key = args[0]
29			GT_Key = args[1]
30			GTRS_Key = args[2]
31			Verbose = False
32	amott	1.2	PSColsToIgnore = []
33	amott	1.3
34	amott	1.4	for o,a in opt:
35			if o=="-v":
36			Verbose = True
37			elif o=="--ignore":
38			for c in a.split(','):
39			try:
40			PSColsToIgnore.append(int(c))
41			except:
42			print "\nERROR: %s is not a valid prescale column\n" % c
43			usage()
44			sys.exit(0)
45			psTable = GetPrescaleTable(HLT_Key,GT_Key,GTRS_Key,PSColsToIgnore,True)
46
47			if Verbose:
48			firstPS = {}
49			for trigger,prescales in psTable.iteritems():
50			firstPed = firstPrescaled(prescales,PSColsToIgnore)
51			if not firstPS.has_key(firstPed):
52			firstPS[firstPed] = []
53			firstPS[firstPed].append(trigger)
54
55
56			for col,triggers in firstPS.iteritems():
57			if col == -1:
58			print "The following triggers are never prescaled:"
59			else:
60			print "The following triggers are first prescaled in col %d" % (col,)
61			for trig in triggers: print "\t%s" % (trig,)
62
63
64
65	amott	1.3	def GetPrescaleTable(HLT_Key,GT_Key,GTRS_Key,PSColsToIgnore,doPrint):
66	amott	1.1	curs = ConnectDB('hlt')
67
68			## Get the HLT seeds
69			sqlquery ="""
70			SELECT I.NAME,A.VALUE
71			FROM
72			CMS_HLT.STRINGPARAMVALUES A,
73			CMS_HLT.PARAMETERS B,
74			CMS_HLT.SUPERIDPARAMETERASSOC C,
75			CMS_HLT.MODULETEMPLATES D,
76			CMS_HLT.MODULES E,
77			CMS_HLT.PATHMODULEASSOC F,
78			CMS_HLT.CONFIGURATIONPATHASSOC G,
79			CMS_HLT.CONFIGURATIONS H,
80			CMS_HLT.PATHS I
81			WHERE
82			A.PARAMID = C.PARAMID AND
83			B.PARAMID = C.PARAMID AND
84			B.NAME = 'L1SeedsLogicalExpression' AND
85			C.SUPERID = F.MODULEID AND
86			D.NAME = 'HLTLevel1GTSeed' AND
87			E.TEMPLATEID = D.SUPERID AND
88			F.MODULEID = E.SUPERID AND
89			F.PATHID=G.PATHID AND
90			I.PATHID=G.PATHID AND
91			G.CONFIGID=H.CONFIGID AND
92			H.CONFIGDESCRIPTOR='%s'
93			ORDER BY A.VALUE
94			""" % (HLT_Key,)
95			curs.execute(sqlquery)
96			HLTSeed = {}
97			for HLTPath,L1Seed in curs.fetchall():
98			if not HLTSeed.has_key(HLTPath): ## this should protect us from L1_SingleMuOpen
99	amott	1.5	tmp = L1Seed.lstrip('"').rstrip('"')
100			HLTSeed[HLTPath] = tmp.rstrip(' ')
101	amott	1.1
102			HLTPrescales = GetHLTPrescaleMatrix(curs,HLT_Key)
103
104			L1Names = {}
105			## get the L1 algo names associated with each algo bit
106			AlgoNameQuery = """SELECT ALGO_INDEX, ALIAS FROM CMS_GT.L1T_MENU_ALGO_VIEW
107			WHERE MENU_IMPLEMENTATION IN (SELECT L1T_MENU_FK FROM CMS_GT.GT_SETUP WHERE ID='%s')
108			ORDER BY ALGO_INDEX""" % (GT_Key,)
109			curs.execute(AlgoNameQuery)
110			for index,name in curs.fetchall():
111			L1Names[name] = index
112
113			L1Prescales = GetL1AlgoPrescales(curs,GTRS_Key)
114
115			FullPrescales = {}
116	amott	1.4	formatString = "%55s%30s%45s%45s%45s"
117	amott	1.3	if doPrint:
118			print "List of triggers with non-sequential prescales:"
119			print formatString % ("HLT Name","L1 Name","Total","HLT","L1",)
120	amott	1.1	for HLTName,L1Seeds in HLTSeed.iteritems():
121			if HLTName.startswith('AlCa'): ## the results don't make sense for AlCa paths
122			continue
123			if L1Seeds.isdigit(): ## skip TT seeded paths
124			continue
125			thisL1PS = []
126			for seed in L1Seeds.split(' OR '): ## unwind the OR of multiple seeds
127	amott	1.5	seed = seed.lstrip(' ').rstrip(' ')
128	amott	1.1	if seed.isdigit():
129			continue
130			if not L1Names.has_key(seed):
131			print "WARNING: %s uses non-existant L1 seed: %s" % (HLTName,seed,)
132			tmp = L1Prescales[L1Names[seed]]
133			if len(thisL1PS)==0:
134			thisL1PS = tmp ## just set it for the first one
135			else:
136			for i,a,b in zip(range(len(tmp)),thisL1PS,tmp):
137			if b<a:
138			thisL1PS[i] = b # choose the minimum PS for each column
139			if len(thisL1PS)==0:
140			continue ## this probably means that the seeding was an OR of TTs
141			if HLTPrescales.has_key(HLTName): ## if the HLT path is totally unprescaled it won't be listed in the PS service
142			thisHLTPS = HLTPrescales[HLTName]
143			else:
144			thisHLTPS = [1]*len(thisL1PS)
145			if not len(thisHLTPS) == len(thisL1PS):
146			print "Incompatible number of prescales columns for trigger %s" % HLTName
147			continue
148			prescales = []
149			for hlt,l1 in zip(thisHLTPS,thisL1PS):
150			prescales.append(hlt*l1)
151			#print HLTName+" HLT: "+str(thisHLTPS)+" L1: "+str(thisL1PS)+" Total: "+str(prescales)
152	amott	1.3	if not isSequential(prescales,PSColsToIgnore) and doPrint:
153	amott	1.1	print formatString % (HLTName,L1Seeds,prescales,thisHLTPS,thisL1PS,)
154			FullPrescales[HLTName] = prescales
155	amott	1.3	return FullPrescales
156	amott	1.1
157			def GetHLTPrescaleMatrix(cursor,HLT_Key):
158			## Get the config ID
159			configIDQuery = "SELECT CONFIGID FROM CMS_HLT.CONFIGURATIONS WHERE CONFIGDESCRIPTOR='%s'" % (HLT_Key,)
160			cursor.execute(configIDQuery)
161			ConfigId, = cursor.fetchone()
162
163			SequencePathQuery ="""
164			SELECT F.SEQUENCENB,J.VALUE TRIGGERNAME
165			FROM CMS_HLT.CONFIGURATIONSERVICEASSOC A
166			, CMS_HLT.SERVICES B
167			, CMS_HLT.SERVICETEMPLATES C
168			, CMS_HLT.SUPERIDVECPARAMSETASSOC D
169			, CMS_HLT.VECPARAMETERSETS E
170			, CMS_HLT.SUPERIDPARAMSETASSOC F
171			, CMS_HLT.PARAMETERSETS G
172			, CMS_HLT.SUPERIDPARAMETERASSOC H
173			, CMS_HLT.PARAMETERS I
174			, CMS_HLT.STRINGPARAMVALUES J
175			WHERE A.CONFIGID= %d
176			AND A.SERVICEID=B.SUPERID
177			AND B.TEMPLATEID=C.SUPERID
178			AND C.NAME='PrescaleService'
179			AND B.SUPERID=D.SUPERID
180			AND D.VPSETID=E.SUPERID
181			AND E.NAME='prescaleTable'
182			AND D.VPSETID=F.SUPERID
183			AND F.PSETID=G.SUPERID
184			AND G.SUPERID=H.SUPERID
185			AND I.PARAMID=H.PARAMID
186			AND I.NAME='pathName'
187			AND J.PARAMID=H.PARAMID
188			ORDER BY F.SEQUENCENB
189			""" % (ConfigId,)
190
191			cursor.execute(SequencePathQuery)
192			HLTSequenceMap = {}
193			for seq,name in cursor.fetchall():
194			name = name.lstrip('"').rstrip('"')
195			HLTSequenceMap[seq]=name
196
197			SequencePrescaleQuery="""
198			SELECT F.SEQUENCENB,J.SEQUENCENB,J.VALUE
199			FROM CMS_HLT.CONFIGURATIONSERVICEASSOC A
200			, CMS_HLT.SERVICES B
201			, CMS_HLT.SERVICETEMPLATES C
202			, CMS_HLT.SUPERIDVECPARAMSETASSOC D
203			, CMS_HLT.VECPARAMETERSETS E
204			, CMS_HLT.SUPERIDPARAMSETASSOC F
205			, CMS_HLT.PARAMETERSETS G
206			, CMS_HLT.SUPERIDPARAMETERASSOC H
207			, CMS_HLT.PARAMETERS I
208			, CMS_HLT.VUINT32PARAMVALUES J
209			WHERE A.CONFIGID=%d
210			AND A.SERVICEID=B.SUPERID
211			AND B.TEMPLATEID=C.SUPERID
212			AND C.NAME='PrescaleService'
213			AND B.SUPERID=D.SUPERID
214			AND D.VPSETID=E.SUPERID
215			AND E.NAME='prescaleTable'
216			AND D.VPSETID=F.SUPERID
217			AND F.PSETID=G.SUPERID
218			AND G.SUPERID=H.SUPERID
219			AND I.PARAMID=H.PARAMID
220			AND I.NAME='prescales'
221			AND J.PARAMID=H.PARAMID
222			ORDER BY F.SEQUENCENB,J.SEQUENCENB
223			""" % (ConfigId,)
224
225			#print HLTSequenceMap
226			cursor.execute(SequencePrescaleQuery)
227			HLTPrescaleTable= {}
228			lastIndex=-1
229			lastSeq=-1
230			row = []
231			for seq,index,val in cursor.fetchall():
232			if lastIndex!=index-1:
233			HLTPrescaleTable[HLTSequenceMap[seq-1]] = row
234			row=[]
235			lastSeq=seq
236			lastIndex=index
237			row.append(val)
238
239			return HLTPrescaleTable
240
241			def GetL1AlgoPrescales(curs, GTRS_Key):
242			L1PrescalesQuery= """
243			SELECT
244			PRESCALE_FACTOR_ALGO_000,PRESCALE_FACTOR_ALGO_001,PRESCALE_FACTOR_ALGO_002,PRESCALE_FACTOR_ALGO_003,PRESCALE_FACTOR_ALGO_004,PRESCALE_FACTOR_ALGO_005,
245			PRESCALE_FACTOR_ALGO_006,PRESCALE_FACTOR_ALGO_007,PRESCALE_FACTOR_ALGO_008,PRESCALE_FACTOR_ALGO_009,PRESCALE_FACTOR_ALGO_010,PRESCALE_FACTOR_ALGO_011,
246			PRESCALE_FACTOR_ALGO_012,PRESCALE_FACTOR_ALGO_013,PRESCALE_FACTOR_ALGO_014,PRESCALE_FACTOR_ALGO_015,PRESCALE_FACTOR_ALGO_016,PRESCALE_FACTOR_ALGO_017,
247			PRESCALE_FACTOR_ALGO_018,PRESCALE_FACTOR_ALGO_019,PRESCALE_FACTOR_ALGO_020,PRESCALE_FACTOR_ALGO_021,PRESCALE_FACTOR_ALGO_022,PRESCALE_FACTOR_ALGO_023,
248			PRESCALE_FACTOR_ALGO_024,PRESCALE_FACTOR_ALGO_025,PRESCALE_FACTOR_ALGO_026,PRESCALE_FACTOR_ALGO_027,PRESCALE_FACTOR_ALGO_028,PRESCALE_FACTOR_ALGO_029,
249			PRESCALE_FACTOR_ALGO_030,PRESCALE_FACTOR_ALGO_031,PRESCALE_FACTOR_ALGO_032,PRESCALE_FACTOR_ALGO_033,PRESCALE_FACTOR_ALGO_034,PRESCALE_FACTOR_ALGO_035,
250			PRESCALE_FACTOR_ALGO_036,PRESCALE_FACTOR_ALGO_037,PRESCALE_FACTOR_ALGO_038,PRESCALE_FACTOR_ALGO_039,PRESCALE_FACTOR_ALGO_040,PRESCALE_FACTOR_ALGO_041,
251			PRESCALE_FACTOR_ALGO_042,PRESCALE_FACTOR_ALGO_043,PRESCALE_FACTOR_ALGO_044,PRESCALE_FACTOR_ALGO_045,PRESCALE_FACTOR_ALGO_046,PRESCALE_FACTOR_ALGO_047,
252			PRESCALE_FACTOR_ALGO_048,PRESCALE_FACTOR_ALGO_049,PRESCALE_FACTOR_ALGO_050,PRESCALE_FACTOR_ALGO_051,PRESCALE_FACTOR_ALGO_052,PRESCALE_FACTOR_ALGO_053,
253			PRESCALE_FACTOR_ALGO_054,PRESCALE_FACTOR_ALGO_055,PRESCALE_FACTOR_ALGO_056,PRESCALE_FACTOR_ALGO_057,PRESCALE_FACTOR_ALGO_058,PRESCALE_FACTOR_ALGO_059,
254			PRESCALE_FACTOR_ALGO_060,PRESCALE_FACTOR_ALGO_061,PRESCALE_FACTOR_ALGO_062,PRESCALE_FACTOR_ALGO_063,PRESCALE_FACTOR_ALGO_064,PRESCALE_FACTOR_ALGO_065,
255			PRESCALE_FACTOR_ALGO_066,PRESCALE_FACTOR_ALGO_067,PRESCALE_FACTOR_ALGO_068,PRESCALE_FACTOR_ALGO_069,PRESCALE_FACTOR_ALGO_070,PRESCALE_FACTOR_ALGO_071,
256			PRESCALE_FACTOR_ALGO_072,PRESCALE_FACTOR_ALGO_073,PRESCALE_FACTOR_ALGO_074,PRESCALE_FACTOR_ALGO_075,PRESCALE_FACTOR_ALGO_076,PRESCALE_FACTOR_ALGO_077,
257			PRESCALE_FACTOR_ALGO_078,PRESCALE_FACTOR_ALGO_079,PRESCALE_FACTOR_ALGO_080,PRESCALE_FACTOR_ALGO_081,PRESCALE_FACTOR_ALGO_082,PRESCALE_FACTOR_ALGO_083,
258			PRESCALE_FACTOR_ALGO_084,PRESCALE_FACTOR_ALGO_085,PRESCALE_FACTOR_ALGO_086,PRESCALE_FACTOR_ALGO_087,PRESCALE_FACTOR_ALGO_088,PRESCALE_FACTOR_ALGO_089,
259			PRESCALE_FACTOR_ALGO_090,PRESCALE_FACTOR_ALGO_091,PRESCALE_FACTOR_ALGO_092,PRESCALE_FACTOR_ALGO_093,PRESCALE_FACTOR_ALGO_094,PRESCALE_FACTOR_ALGO_095,
260			PRESCALE_FACTOR_ALGO_096,PRESCALE_FACTOR_ALGO_097,PRESCALE_FACTOR_ALGO_098,PRESCALE_FACTOR_ALGO_099,PRESCALE_FACTOR_ALGO_100,PRESCALE_FACTOR_ALGO_101,
261			PRESCALE_FACTOR_ALGO_102,PRESCALE_FACTOR_ALGO_103,PRESCALE_FACTOR_ALGO_104,PRESCALE_FACTOR_ALGO_105,PRESCALE_FACTOR_ALGO_106,PRESCALE_FACTOR_ALGO_107,
262			PRESCALE_FACTOR_ALGO_108,PRESCALE_FACTOR_ALGO_109,PRESCALE_FACTOR_ALGO_110,PRESCALE_FACTOR_ALGO_111,PRESCALE_FACTOR_ALGO_112,PRESCALE_FACTOR_ALGO_113,
263			PRESCALE_FACTOR_ALGO_114,PRESCALE_FACTOR_ALGO_115,PRESCALE_FACTOR_ALGO_116,PRESCALE_FACTOR_ALGO_117,PRESCALE_FACTOR_ALGO_118,PRESCALE_FACTOR_ALGO_119,
264			PRESCALE_FACTOR_ALGO_120,PRESCALE_FACTOR_ALGO_121,PRESCALE_FACTOR_ALGO_122,PRESCALE_FACTOR_ALGO_123,PRESCALE_FACTOR_ALGO_124,PRESCALE_FACTOR_ALGO_125,
265			PRESCALE_FACTOR_ALGO_126,PRESCALE_FACTOR_ALGO_127
266			FROM CMS_GT.GT_FDL_PRESCALE_FACTORS_ALGO A, CMS_GT.GT_RUN_SETTINGS_PRESC_VIEW B
267			WHERE A.ID=B.PRESCALE_FACTORS_ALGO_FK AND B.ID='%s'
268			""" % (GTRS_Key,)
269			curs.execute(L1PrescalesQuery)
270			## This is pretty horrible, but this how you get them!!
271			tmp = curs.fetchall()
272			L1PrescaleTable = []
273			for ps in tmp[0]: #build the prescale table initially
274			L1PrescaleTable.append([ps])
275			for line in tmp[1:]: # now fill it
276			for ps,index in zip(line,range(len(line))):
277			L1PrescaleTable[index].append(ps)
278			return L1PrescaleTable
279
280	amott	1.2	def isSequential(row,ignore):
281	amott	1.1	seq = True
282	amott	1.2	lastEntry=999999999999
283			for i,entry in enumerate(row):
284			if i in ignore:
285			continue
286	amott	1.1	if entry > lastEntry and lastEntry!=0:
287			seq = False
288			break
289			lastEntry = entry
290			return seq
291	amott	1.4
292
293			def firstPrescaled(row,ignore):
294			row.reverse()
295			for i,val in enumerate(row):
296			if len(row)-1-i in ignore:
297			continue
298			if val!=1: # prescaled
299			return len(row)-1-i
300			return -1
301
302	amott	1.1	if __name__=='__main__':
303			main()