UserCode/RateMonShiftTool_dev/CheckPrescales.py

#!/usr/bin/env python

import sys
import os
from DatabaseParser import ConnectDB

def usage():
    print sys.argv[0] + " HLTKey GTKey GTRS Key"

def main():

    if not len(sys.argv) == 4:
        usage()
        sys.exit(0)

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