MTCalibPebConfig Namespace Reference

Classes
class	MTCalibPebHypoOptions

Functions
	set_flags (flags, options=default_options)
	l1_seq_cfg (flags, options=default_options)
	make_hypo_alg (name)
	make_hypo_tool (name, options=default_options)
	make_all_hypo_algs (num_chains, concurrent=False)
	hlt_result_cfg (flags, hypo_algs)
	make_summary_algs (hypo_algs)
	hlt_seq_cfg (flags, num_chains, concurrent=False, hypo_algs=None)
	write_dummy_menu_json (flags, chains, chain_to_streams)

Variables
	log = logging.getLogger('MTCalibPebConfig.py')
str	_menu_name = 'MTCalibPeb'
str	_menu_file_name = 'HLTMenu_{:s}.json'.format(_menu_name)
list	rob_list
dict	rob_access_dict
	default_options = MTCalibPebHypoOptions()
	flags = initConfigFlags()
	acc = l1_seq_cfg(flags)
	withDetails

Function Documentation

hlt_result_cfg()

MTCalibPebConfig.hlt_result_cfg	(		flags,
			hypo_algs )

Definition at line 209 of file MTCalibPebConfig.py.

def hlt_result_cfg(flags, hypo_algs):
    from TrigEDMConfig.DataScoutingInfo import getFullHLTResultID
    from TrigEDMConfig.TriggerEDMRun3 import EDMDetailsRun3
    from TrigEDMConfig.TriggerEDM import getRawTriggerEDMList
    from TrigOutputHandling.TrigOutputHandlingConfig import TriggerEDMSerialiserToolCfg, StreamTagMakerToolCfg, TriggerBitsMakerToolCfg
 
    # Tool serialising EDM objects to fill the HLT result
    serialiser = TriggerEDMSerialiserToolCfg(flags, 'Serialiser')
    # Add some framework EDM to the output, but skip the ones in EDMDetailsRun3 to avoid the fuss
    serialiser.addCollectionListToMainResult([
        coll[0] for coll in getRawTriggerEDMList(flags, runVersion=3) if 'BS' in coll[1] and coll[2]=='Steer' and not coll[0].split('#')[0] in EDMDetailsRun3
    ])
    for hypo in hypo_algs:
        serialiser.addCollectionListToMainResult([
            'xAOD::TrigCompositeContainer#%s' % hypo.HypoOutputDecisions,
            'xAOD::TrigCompositeAuxContainer#%sAux.' % hypo.HypoOutputDecisions,
        ])
 
    # Data scouting example
    resultList = [getFullHLTResultID(), 1]
    collections = set()
    chain_names = []
    for hypo in hypo_algs:
        for hypo_tool in hypo.HypoTools:
            chain_names.append(hypo_tool.name)
            if hasattr(hypo_tool,'CreateRandomData'):
                for coll_name in hypo_tool.CreateRandomData.keys():
                    collections.add(coll_name)
    for coll_name in collections:
        serialiser.addCollectionListToResults([
            'xAOD::TrigCompositeContainer#{:s}'.format(coll_name),
            'xAOD::TrigCompositeAuxContainer#{:s}Aux.'.format(coll_name)
        ], resultList)
 
    # StreamTag definitions
    streamPhysicsMain = {
        'name': 'Main',
        'type': 'physics',
        'obeyLB': True,
        'forceFullEventBuilding': True
    }
    streamExamplePEB = {
        'name': 'ExamplePEB',
        'type': 'calibration',
        'obeyLB': True,
        'forceFullEventBuilding': False
    }
    streamExampleDataScoutingPEB = {
        'name': 'ExampleDataScoutingPEB',
        'type': 'physics',
        'obeyLB': True,
        'forceFullEventBuilding': False
    }
    chain_to_streams = {}
    for counter, ch in enumerate(chain_names, start=1):
        if counter % 3 == 1:
            chain_to_streams[ch] = [streamPhysicsMain]
        elif counter % 3 == 2:
            chain_to_streams[ch] = [streamExamplePEB]
        elif counter % 3 == 0:
            chain_to_streams[ch] = [streamExampleDataScoutingPEB]
 
    menu_json = write_dummy_menu_json(flags, chain_to_streams.keys(), chain_to_streams)
 
    acc = ComponentAccumulator()
 
    # Give the menu json name to HLTConfigSvc
    from TrigConfigSvc.TrigConfigSvcCfg import HLTConfigSvcCfg
    hltConfigSvcCfg = HLTConfigSvcCfg(flags)
    hltConfigSvcCfg.getService("HLTConfigSvc").HLTJsonFileName = menu_json
    acc.merge(hltConfigSvcCfg)
 
    # Tool adding stream tags to HLT result
    stmaker = StreamTagMakerToolCfg()
    stmaker.ChainDecisions = 'HLTNav_Summary'
    stmaker.PEBDecisionKeys = [str(hypo.HypoOutputDecisions) for hypo in hypo_algs]
 
    # Tool adding HLT bits to HLT result
    bitsmaker = TriggerBitsMakerToolCfg()
    bitsmaker.ChainDecisions = 'HLTNav_Summary'
 
    # Configure the HLT result maker to use the above tools
    from TrigServices.TrigServicesConfig import TrigServicesCfg
    trigServicesCfg = TrigServicesCfg(flags)
    hltEventLoopMgr = trigServicesCfg.getPrimary()
    hltEventLoopMgr.ResultMaker.StreamTagMaker = stmaker
    hltEventLoopMgr.ResultMaker.MakerTools = [bitsmaker, serialiser]
    acc.merge(trigServicesCfg)
 
    return acc
 
 

hlt_seq_cfg()

MTCalibPebConfig.hlt_seq_cfg	(		flags,
			num_chains,
			concurrent = False,
			hypo_algs = None )

Definition at line 316 of file MTCalibPebConfig.py.

def hlt_seq_cfg(flags, num_chains, concurrent=False, hypo_algs=None):
    acc = ComponentAccumulator()
 
    # Load these objects from StoreGate
    loadFromSG = [('xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
                  ('TrigConf::L1Menu','DetectorStore+L1TriggerMenu'),
                  ('TrigConf::HLTMenu','DetectorStore+HLTTriggerMenu')]
 
    from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
    acc.merge(SGInputLoaderCfg(flags, loadFromSG))
 
    # Sequences need to ensure that summary algs run after all hypos
    acc.addSequence(seqOR('hltTop'))
    acc.addSequence(parOR('hltHypoSeq'), parentName='hltTop')
    acc.addSequence(parOR('hltEndSeq'), parentName='hltTop')
 
    if not hypo_algs:
        hypo_algs = make_all_hypo_algs(num_chains, concurrent)
    summary_algs = make_summary_algs(hypo_algs)
    hlt_result_ca = hlt_result_cfg(flags, hypo_algs)
 
    acc.addEventAlgo(hypo_algs, sequenceName='hltHypoSeq')
    acc.addEventAlgo(summary_algs, sequenceName='hltEndSeq')
    acc.merge(hlt_result_ca)
 
    return acc
 
 

l1_seq_cfg()

MTCalibPebConfig.l1_seq_cfg	(		flags,
			options = default_options )

Definition at line 131 of file MTCalibPebConfig.py.

def l1_seq_cfg(flags, options=default_options):
    from HLTSeeding.HLTSeedingConfig import HLTSeedingCfg
    acc = HLTSeedingCfg(flags)
 
    l1_decoder_alg = acc.getEventAlgo('HLTSeeding')
    l1_decoder_alg.prescaler = CompFactory.PrescalingEmulationTool()
 
    # Generate L1 menu
    from TrigConfigSvc.TrigConfigSvcCfg import generateL1Menu
    generateL1Menu(flags)
 
    # Need to set HLT menu file name here to avoid conflict when merging with HLT sequence CA
    acc.getService("HLTConfigSvc").HLTJsonFileName = _menu_file_name
 
    return acc
 
 

make_all_hypo_algs()

MTCalibPebConfig.make_all_hypo_algs	(		num_chains,
			concurrent = False )

Definition at line 172 of file MTCalibPebConfig.py.

def make_all_hypo_algs(num_chains, concurrent=False):
    hypo_tools = []
    for chain_index in range(1, 1+num_chains):
        # Default hypo tool for chains 1, 4, 7, 10, ...
        hypoTool = make_hypo_tool('HLT_MTCalibPeb{:d}'.format(chain_index))
        hypoTool.PEBROBList = rob_list
        hypoTool.PEBSubDetList = []
        # Hypo for chains 2, 5, 8, 11, ...
        if chain_index % 3 == 2:
            hypoTool.PEBROBList = [0x420024, 0x420025, 0x420026, 0x420027]  # example LAr EMB ROBs
            hypoTool.PEBSubDetList = [0x53, 0x54]  # TILECAL_EXT A and C
        # Hypo for chains 3, 6, 9, 12, ...
        elif chain_index % 3 == 0:
            hypoTool.CreateRandomData = {
                'ExampleCollection_{:d}_1'.format(chain_index): 5,
                'ExampleCollection_{:d}_2'.format(chain_index): 3,
            }
            hypoTool.PEBROBList = [0x420034, 0x420035, 0x420036, 0x420037]  # example LAr EMB ROBs
            hypoTool.PEBROBList.extend([0x7c0001])  # extra HLT result for data scouting
        hypo_tools.append(hypoTool)
 
    # Add the hypo tools to algorithm(s)
    hypo_algs = []
    if concurrent:
        for tool in hypo_tools:
            hypo = make_hypo_alg('HypoAlg{:d}'.format(len(hypo_algs)+1))
            hypo.HypoTools += [tool]
            hypo_algs.append(hypo)
    else:
        hypo = make_hypo_alg('HypoAlg1')
        for tool in hypo_tools:
            hypo.HypoTools += [tool]
        hypo_algs.append(hypo)
 
    return hypo_algs
 
 

make_hypo_alg()

MTCalibPebConfig.make_hypo_alg

(

name

)

Definition at line 148 of file MTCalibPebConfig.py.

def make_hypo_alg(name):
    hypo = CompFactory.MTCalibPebHypoAlg(name)
    hypo.HypoInputDecisions = 'HLTSeedingSummary'
    hypo.HypoOutputDecisions = 'MTCalibPebDecisions_'+name
    return hypo
 
 

make_hypo_tool()

MTCalibPebConfig.make_hypo_tool	(		name,
			options = default_options )

Definition at line 155 of file MTCalibPebConfig.py.

def make_hypo_tool(name, options=default_options):
    hypo_tool = CompFactory.MTCalibPebHypoTool(name)
    hypo_tool.UseRandomSeed             = options.UseRandomSeed
    hypo_tool.RandomAcceptRate          = options.RandomAcceptRate
    hypo_tool.BurnTimePerCycleMillisec  = options.BurnTimePerCycleMillisec
    hypo_tool.NumBurnCycles             = options.NumBurnCycles
    hypo_tool.BurnTimeRandomly          = options.BurnTimeRandomly
    hypo_tool.Crunch                    = options.Crunch
    hypo_tool.CheckDataConsistency      = options.CheckDataConsistency
    hypo_tool.ROBAccessDict             = options.ROBAccessDict
    hypo_tool.TimeBetweenROBReqMillisec = options.TimeBetweenROBReqMillisec
    hypo_tool.PEBROBList                = options.PEBROBList
    hypo_tool.PEBSubDetList             = options.PEBSubDetList
    hypo_tool.CreateRandomData          = options.CreateRandomData
    return hypo_tool
 
 

make_summary_algs()

MTCalibPebConfig.make_summary_algs

(

hypo_algs

)

Definition at line 301 of file MTCalibPebConfig.py.

def make_summary_algs(hypo_algs):
    summary = CompFactory.TriggerSummaryAlg('TriggerSummaryAlg')
    summary.InputDecision = 'HLTSeedingSummary'
    summary.FinalDecisions = [str(hypo.HypoOutputDecisions) for hypo in hypo_algs]
 
    summMaker = CompFactory.DecisionSummaryMakerAlg()
    summMaker.FinalDecisionKeys = [str(hypo.HypoOutputDecisions) for hypo in hypo_algs]
    summMaker.FinalStepDecisions = {}
    for hypo in hypo_algs:
        for tool in hypo.HypoTools:
            summMaker.FinalStepDecisions[tool.getName()] = [str(hypo.HypoOutputDecisions)]
    log.info('summMaker = %s', summMaker)
    return [summary, summMaker]
 
 

set_flags()

MTCalibPebConfig.set_flags	(		flags,
			options = default_options )

Definition at line 110 of file MTCalibPebConfig.py.

def set_flags(flags, options=default_options):
    flags.Common.isOnline = True
    flags.Input.Files = []
    flags.Input.Format = Format.BS
    flags.Input.isMC = False
    flags.Trigger.doHLT = True
    flags.Trigger.EDMVersion = 3
    flags.Trigger.Online.isPartition = True
    flags.Trigger.triggerMenuSetup = 'Dev_pp_run3_v1'
    flags.Trigger.forceEnableAllChains = True
    flags.Trigger.ROBPrefetchingOptions = [] # workaround for ATR-26307
    # Disable signature-specific detector configuration parts
    flags.Trigger.doID = False
    flags.Trigger.doCalo = False
    flags.Trigger.doMuon = False
    # Disable L1 data decoding (except for CTP)
    flags.Trigger.L1.doMuon = False
    flags.Trigger.L1.doCalo = False
    flags.Trigger.L1.doTopo = False
 
 

write_dummy_menu_json()

MTCalibPebConfig.write_dummy_menu_json	(		flags,
			chains,
			chain_to_streams )

Definition at line 344 of file MTCalibPebConfig.py.

def write_dummy_menu_json(flags, chains, chain_to_streams):
    import json
    from TrigConfHLTUtils.HLTUtils import string2hash
    from TrigConfigSvc.TrigConfigSvcCfg import getHLTPrescalesSetFileName
    menu_dict = dict([
        ("filetype", "hltmenu"),
        ("name", _menu_name),
        ("chains", dict()),
        ("streams", dict()),
        ("sequencers", dict())
    ])
    hlt_ps_dict = dict([
        ("filetype", "hltprescale"),
        ("name", _menu_name),
        ("prescales", dict())
    ])
    counter = 0
    for chain in chains:
        # Prepare information for stream list and fill separate dictionary
        chain_streams = []
        for stream in chain_to_streams[chain]:
            stream_name = stream['name']
            chain_streams.append(stream_name)
            # If not already listed, add stream details to stream dictionary
            if stream_name not in menu_dict["streams"]:
                menu_dict["streams"][stream_name] = dict([
                    ("name", stream_name),
                    ("type", stream['type']),
                    ("obeyLB", stream['obeyLB']),
                    ("forceFullEventBuilding", stream['forceFullEventBuilding'])
                ])
 
        menu_dict["chains"][chain] = dict([
            ("counter", counter),
            ("nameHash", string2hash(chain)),
            ("legMultiplicities", [1]),
            ("l1item", ''),
            ("l1thresholds", ['FSNOSEED']),
            ("groups", []),
            ("streams", chain_streams),
            ("sequencers", [] )
        ])
        hlt_ps_dict["prescales"][chain] = dict([
            ("counter", counter),
            ("hash", string2hash(chain)),
            ("prescale", 1),
            ("enabled", True),
        ])
 
        counter += 1
 
    log.info('Writing trigger menu to %s', _menu_file_name)
    with open(_menu_file_name, 'w') as json_file:
        json.dump(menu_dict, json_file, indent=4, sort_keys=False)
 
    hlt_ps_file_name = getHLTPrescalesSetFileName(flags)
    log.info('Writing HLT prescales to %s', hlt_ps_file_name)
    with open(hlt_ps_file_name, 'w') as json_file:
        json.dump(hlt_ps_dict, json_file, indent=4, sort_keys=False)
 
    return _menu_file_name
 
 
# unit test

Variable Documentation

_menu_file_name

str MTCalibPebConfig._menu_file_name = 'HLTMenu_{:s}.json'.format(_menu_name)

protected

Definition at line 13 of file MTCalibPebConfig.py.

_menu_name

str MTCalibPebConfig._menu_name = 'MTCalibPeb'

protected

Definition at line 12 of file MTCalibPebConfig.py.

acc

MTCalibPebConfig.acc = l1_seq_cfg(flags)

Definition at line 414 of file MTCalibPebConfig.py.

default_options

MTCalibPebConfig.default_options = MTCalibPebHypoOptions()

Definition at line 107 of file MTCalibPebConfig.py.

flags

MTCalibPebConfig.flags = initConfigFlags()

Definition at line 410 of file MTCalibPebConfig.py.

log

MTCalibPebConfig.log = logging.getLogger('MTCalibPebConfig.py')

Definition at line 10 of file MTCalibPebConfig.py.

rob_access_dict

dict MTCalibPebConfig.rob_access_dict

Initial value:

=  {
  '01 :ADDGET:RND20:': rob_list,  # Prefetch+Retrieve  20 random ROBs from rob_list
  '02 :GET:RND10:   ': rob_list,  # Retrieve           10 random ROBs from rob_list
  '03 :GET:RND5:    ': rob_list,  # Retrieve            5 random ROBs from rob_list
  '04 :ADD:RND10:   ': rob_list,  # Prefetch           10 random ROBs from rob_list
  '05 :ADD:RND20:   ': rob_list,  # Prefetch           20 random ROBs from rob_list
  '06 :ADDGET:RND50:': rob_list,  # Prefetch+Retrieve  50 random ROBs from rob_list
  '07 :ADDGET:RND10:': rob_list,  # Prefetch+Retrieve  10 random ROBs from rob_list
  '08 :ADDGET:RND5: ': rob_list,  # Prefetch+Retrieve   5 random ROBs from rob_list
  '09 :GET:RND20:   ': rob_list,  # Retrieve           20 random ROBs from rob_list
  '10 :ADDGET:RND20:': rob_list,  # Prefetch+Retrieve  20 random ROBs from rob_list
  '11 :GET:RND10:   ': rob_list,  # Retrieve           10 random ROBs from rob_list
  '12 :ADDGET:RND10:': rob_list   # Prefetch+Retrieve  10 random ROBs from rob_list
}

Definition at line 76 of file MTCalibPebConfig.py.

rob_list

list MTCalibPebConfig.rob_list

Definition at line 17 of file MTCalibPebConfig.py.

withDetails

MTCalibPebConfig.withDetails

Definition at line 416 of file MTCalibPebConfig.py.