diff --git a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx index eb4be8cb27c1ef2dfdef59319ca17e024549c658..340a2d6adc5fcd5393ded3140c6d2ca0d9da4748 100644 --- a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx +++ b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx @@ -22,7 +22,7 @@ InputMakerForRoI:: InputMakerForRoI( const std::string& name, StatusCode InputMakerForRoI::initialize() { ATH_MSG_DEBUG("Will produce output RoI collections: " << m_RoIs); - CHECK( m_RoIs.initialize() ); + CHECK( m_RoIs.initialize( SG::AllowEmpty ) ); return StatusCode::SUCCESS; } @@ -35,7 +35,7 @@ StatusCode InputMakerForRoI::execute( const EventContext& context ) const { ATH_CHECK(outputHandle.isValid()); // Prepare Outputs - std::unique_ptr< TrigRoiDescriptorCollection > oneRoIColl( new TrigRoiDescriptorCollection() ); + std::unique_ptr<TrigRoiDescriptorCollection> oneRoIColl = std::make_unique<TrigRoiDescriptorCollection>(); // use also this: ElementLinkVector<xAOD::MuonRoIContainer> getMuonRoILinks = obj->objectCollectionLinks<xAOD::MuonRoIContainer>("ManyMuonRoIs"); std::vector <ElementLink<TrigRoiDescriptorCollection> > RoIsFromDecision; // used to check for duplicate features linked to different inputHandles @@ -70,11 +70,15 @@ StatusCode InputMakerForRoI::execute( const EventContext& context ) const { } // loop over decisions - // Finally, record output - ATH_MSG_DEBUG("Produced "<<oneRoIColl->size() <<" output RoIs"); - auto roi_outputHandle = SG::makeHandle(m_RoIs, context); - ATH_CHECK( roi_outputHandle.record(std::move(oneRoIColl)) ); - + // Finally, record output + if (m_RoIs.empty()) { + ATH_MSG_DEBUG("No concrete output ROI collection required from this InputMaker."); + } else { + ATH_MSG_DEBUG("Produced "<<oneRoIColl->size() <<" output RoIs"); + auto roi_outputHandle = SG::makeHandle(m_RoIs, context); + ATH_CHECK( roi_outputHandle.record(std::move(oneRoIColl)) ); + } + // call base class helper method to print some debug messages summarising the content of the outputHandles. if (msgLvl(MSG::DEBUG)) { debugPrintOut(context, outputHandle); diff --git a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h index fda2d2b0cc6a0f4668c589cb4f37f2cee27198a9..9f5119fd46c7a6a628a24efa4bd3ea233c0fd1ae 100644 --- a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h +++ b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h @@ -26,7 +26,8 @@ virtual StatusCode execute(const EventContext&) const override; private: - SG::WriteHandleKey<TrigRoiDescriptorCollection> m_RoIs {this,"RoIs", "Unspecified", "Name of the RoIs extracted from the decisions"}; + SG::WriteHandleKey<TrigRoiDescriptorCollection> m_RoIs {this,"RoIs", "", + "Name of the collection of ROI extrated from the input Decision Objects. Used as cocnrete starting handle for step's reconstruction."}; }; diff --git a/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py b/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py index c6bac567b7aec9ede80e13324458f5e34c710021..eedfbce25f172727b2c8c6829fc6f36bf992d505 100644 --- a/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py +++ b/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py @@ -5,9 +5,10 @@ from AthenaCommon.AlgScheduler import AlgScheduler from AthenaCommon.CFElements import parOR from AthenaCommon.Logging import logging from L1Decoder.L1DecoderConf import CTPUnpackingEmulationTool, RoIsUnpackingEmulationTool, L1Decoder - +from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import EmptyMenuSequence log = logging.getLogger('EmuStepProcessingConfig') + def thresholdToChains( chains ): """ Produces list "threshod : chain" for all chains passed. Uses the L1Thresholds/vseeds Chain property @@ -53,7 +54,7 @@ def generateL1DecoderAndChains(): # event 2: 2e+ 3mu : HLT_e5_e8_2mu6_L1EM3_EM5_L12MU6, HLT_mu6_e8_L1MU6_EM5 data['ctp'] [2] = 'HLT_mu6_L1MU6 HLT_mu8_L1MU10 HLT_mu10_L1MU10 HLT_mu8_1step_L1MU6 HLT_e20_L1EM10 HLT_e8_L1EM7 HLT_mu6_e8_L1MU6_EM5 HLT_mu6Comb_e8_L1MU6_EM5 HLT_e3_e5_L1EM3_EM5 HLT_2mu6_L12MU6 HLT_2mu6Comb_L12MU6 HLT_2mu4_bDimu_L12MU4 HLT_e5_e8_L1EM3_EM5 HLT_e5_e8_2mu6_L1EM3_EM5_L12MU6 HLT_mu6_mu6noL1_L1MU6' - data['l1emroi'][2] = '2,0.2,0,EM3,EM5, EM7,EM15,EM20,EM50,EM100; 1,-1.1,0,EM3,EM5,EM7,EM15,EM20,EM50;' + data['l1emroi'][2] = '2,0.2,0,EM3,EM5,EM7,EM15,EM20,EM50,EM100; 1,-1.1,0,EM3,EM5,EM7,EM15,EM20,EM50;' data['emclusters'][2]= 'eta:0.5,phi:0,et:120000; eta:1,phi:-1.2,et:65000;' data['l1muroi'][2] = '2,0.5,0,MU6,MU8; 3,0.5,0,MU6,MU8,MU10;2.2,0.6,0,MU6;' data['msmu'][2] = 'eta:-1.2,phi:0.7,pt:6500,pt2:8500; eta:-1.1,phi:0.6,pt:8500,pt2:8500;eta:-1.1,phi:0.6,pt:8500,pt2:8500;' @@ -167,6 +168,8 @@ def generateL1DecoderAndChains(): # combined chain if doCombo: + emptySeq1 = EmptyMenuSequence("step1EmptySeqence") + emptySeq2 = EmptyMenuSequence("step2EmptySeqence") if not doElectron: from TrigUpgradeTest.HLTSignatureConfig import elMenuSequence el11 = elMenuSequence(step="1",reconame="v1", hyponame="v1") @@ -185,7 +188,6 @@ def generateL1DecoderAndChains(): mu32 = muMenuSequence(step="3",reconame="v2", hyponame="v2") #step4 mu41 = muMenuSequence(step="4",reconame="v1", hyponame="v1") - from TrigUpgradeTest.HLTSignatureHypoTools import dimuDrComboHypoTool @@ -199,9 +201,9 @@ def generateL1DecoderAndChains(): CombChains =[ - - makeChain(name='HLT_mu6_e8_L1MU6_EM5', L1Thresholds=["MU6","EM5"], ChainSteps=[ ChainStep("Step1_mu_em", [mu11, el11], multiplicity=[1,1], comboToolConfs=[dimuDrComboHypoTool]), - ChainStep("Step2_mu_em", [mu21, el21], multiplicity=[1,1])] ), + # This is an example of a chain running in "serial" + makeChain(name='HLT_mu6_e8_L1MU6_EM5', L1Thresholds=["MU6","EM5"], ChainSteps=[ ChainStep("Step1_mu_em_serial", [mu11, emptySeq1], multiplicity=[1,1]), + ChainStep("Step2_mu_em_serial", [emptySeq2, el21], multiplicity=[1,1])] ), makeChain(name='HLT_mu6Comb_e8_L1MU6_EM5', L1Thresholds=["MU6","EM5"], ChainSteps=[ ChainStep("Step1_mu2_em", [mu12, el11], multiplicity=[1,1]), ChainStep("Step2_mu_em", [mu21, el21], multiplicity=[1,1])] ), @@ -238,7 +240,6 @@ def generateL1DecoderAndChains(): l1Decoder = L1Decoder( RoIBResult="", L1TriggerResult="" ) l1Decoder.L1DecoderSummaryKey = "L1DecoderSummary" - ctpUnpacker = CTPUnpackingEmulationTool( ForceEnableAllChains=False , InputFilename="ctp.dat" ) l1Decoder.ctpUnpacker = ctpUnpacker diff --git a/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py b/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py index 0922cc1392923e757bcaf846f9116ef407aa467b..eb705d0050f8e8bbffd497220eeb1120e858438c 100644 --- a/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py +++ b/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py @@ -1,3 +1,4 @@ + # Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration from AthenaConfiguration.ComponentFactory import CompFactory diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py index f24e9e05ac3913cec9b1e987931c9b65da525300..d9b38c02be58c63bfd59e6e8edc02131d08b221f 100644 --- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py +++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py @@ -4,20 +4,21 @@ from AthenaCommon.Logging import logging log = logging.getLogger( __name__ ) -from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import Chain, ChainStep +from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import Chain, ChainStep, EmptyMenuSequence from copy import deepcopy -def mergeChainDefs(listOfChainDefs, chainDict, strategy="parallel", offset=-1): +def mergeChainDefs(listOfChainDefs, chainDict): - log.debug("Combine by using %s merging", strategy) + strategy = chainDict["mergingStrategy"] + offset = chainDict["mergingOffset"] + log.info(chainDict['chainName']) + log.info("Combine by using %s merging", strategy) if strategy=="parallel": return mergeParallel(listOfChainDefs, offset) elif strategy=="serial": - #return mergeSerial(listOfChainDefs,offset) - log.error("Serial mergin not yet implemented.") - return -1 + return mergeSerial(listOfChainDefs) else: log.error("Merging failed for %s. Merging strategy '%s' not known.", (listOfChainDefs, strategy)) return -1 @@ -54,9 +55,9 @@ def mergeParallel(chainDefList, offset): myOrderedSteps = deepcopy(orderedSteps) combChainSteps =[] - for steps in myOrderedSteps: + for step_index, steps in enumerate(myOrderedSteps): mySteps = list(steps) - combStep = makeChainSteps(mySteps) + combStep = makeChainSteps(mySteps, step_index+1) combChainSteps.append(combStep) # check if all chain parts have the same number of steps @@ -68,24 +69,95 @@ def mergeParallel(chainDefList, offset): combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1Thresholds=l1Thresholds) - log.debug("Merged chain %s with these steps:", chainName) + log.info("Parallel merged chain %s with these steps:", chainName) for step in combinedChainDef.steps: log.debug(' %s', step) return combinedChainDef +def serial_zip(allSteps, chainName): + n_chains = len(allSteps) + newsteps = [] + for chain_index, chainsteps in enumerate(allSteps): + for step_index, step in enumerate(chainsteps): + log.info('chain_index: ' + str(chain_index) + " step_index: " + str(step_index)) + # create list of correct length + stepList = [None]*n_chains + + # put the step from the current sub-chain into the right place + stepList[chain_index] = step + log.info('Put step: ' + str(step)) + + # all other steps should contain an empty sequence + for step_index2, emptyStep in enumerate(stepList): + if emptyStep is None: + seqName = chainName + 'EmptySeq' + str(chain_index) + '_' + str(step_index+1) + emptySeq = EmptyMenuSequence(seqName) + stepList[step_index2] = ChainStep('Step' + str(step_index+1) + "_" + seqName, Sequences=[emptySeq], chainDicts=step.chainDicts) + + # first create a list of chain steps where each step is an empty sequence + #seqName = chainName + 'EmptySeq' + str(chain_index) + '_' + #emptySeqList = [EmptyMenuSequence(seqName + str(_x)) for _x in range(n_chains)] + #stepList = [ChainStep('Step_' + seqName, Sequences=[seq], chainDicts=step.chainDicts) for seq in emptySeqList] + # now overwrite one of these steps from the step in the current sub-chain + #stepList[chain_index] = step + + newsteps.append(stepList) + log.debug('After serial_zip') + for s in newsteps: + log.debug( s ) + return newsteps + +def mergeSerial(chainDefList): + allSteps = [] + nSteps = [] + chainName = '' + l1Thresholds = [] + + log.info('Merge chainDefList:') + log.info(chainDefList) + for cConfig in chainDefList: + if chainName == '': + chainName = cConfig.name + elif chainName != cConfig.name: + log.error("Something is wrong with the combined chain name: cConfig.name = %s while chainName = %s", cConfig.name, chainName) + + allSteps.append(cConfig.steps) + nSteps.append(len(cConfig.steps)) + l1Thresholds.extend(cConfig.vseeds) + + serialSteps = serial_zip(allSteps, chainName) + mySerialSteps = deepcopy(serialSteps) + combChainSteps =[] + for step_index, steps in enumerate(mySerialSteps): + mySteps = list(steps) + combStep = makeChainSteps(mySteps, step_index+1) + combChainSteps.append(combStep) + + # check if all chain parts have the same number of steps + sameNSteps = all(x==nSteps[0] for x in nSteps) + if sameNSteps is True: + log.info("All chain parts have the same number of steps") + else: + log.info("Have to deal with uneven number of chain steps, there might be none's appearing in sequence list => to be fixed") + + combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1Thresholds=l1Thresholds) + + log.info("Serial merged chain %s with these steps:", chainName) + for step in combinedChainDef.steps: + log.info(' %s', step) + + return combinedChainDef -def makeChainSteps(steps): +def makeChainSteps(steps, stepNumber): from copy import deepcopy from TrigCompositeUtils.TrigCompositeUtils import legName - stepName = '' + stepName = 'merged_Step' + str(stepNumber) stepSeq = [] stepMult = [] - stepNumber = '' log.verbose(" steps %s ", steps) - stepName = "merged" stepDicts = [] count = 0 comboHypoTools = [] @@ -93,9 +165,9 @@ def makeChainSteps(steps): for step in steps: if step is None: continue - log.debug(" step %s, multiplicity = %s", step.name, str(step.multiplicity)) + log.info(" step %s, multiplicity = %s", step.name, str(step.multiplicity)) if len(step.sequences): - log.debug(" with sequences = %s", ' '.join(map(str, [seq.name for seq in step.sequences]))) + log.info(" with sequences = %s", ' '.join(map(str, [seq.name for seq in step.sequences]))) # this function only works if the input chains are single-object chains (one menu seuqnce) if len(step.sequences) > 1: @@ -103,12 +175,9 @@ def makeChainSteps(steps): currentStep = step.name - stepNameParts = currentStep.split('_') - if stepNumber == '': - stepNumber = stepNameParts[0] # the step naming for combined chains needs to be revisted!! - stepName += '_' +step.name + stepName += '_' + currentStep if len(step.sequences): seq = step.sequences[0] stepSeq.append(seq) @@ -123,7 +192,7 @@ def makeChainSteps(steps): comboHypoTools = list(set(comboHypoTools)) theChainStep = ChainStep(stepName, Sequences=stepSeq, multiplicity=stepMult, chainDicts=stepDicts, comboToolConfs=comboHypoTools) - log.debug("Merged step: \n %s", theChainStep) + log.info("Merged step: \n %s", theChainStep) return theChainStep diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py index cd1cc1aa225bc8d3b3f4616913b6d9f231c73454..72387ca1dc292c2d1ec5a8398bf75764f6b5de3d 100755 --- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py +++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py @@ -304,7 +304,7 @@ class GenerateMenuMT(object): elif len(listOfChainConfigs)>1: log.debug("Merging strategy from dictionary: %s", mainChainDict["mergingStrategy"]) - theChainConfig = mergeChainDefs(listOfChainConfigs, mainChainDict, mainChainDict["mergingStrategy"], mainChainDict["mergingOffset"]) + theChainConfig = mergeChainDefs(listOfChainConfigs, mainChainDict) # This needs to be added for topological chains - needs implementation #doTopo = self.CheckIntraSignatureTopo(chainDicts) and chainDict["topo"] diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py index 724347f48ebc3bfafb3746e91bb68a93f5c4f0fb..533f10f729b8d6d0ff7dfcd88140043ab47d5305 100644 --- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py +++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py @@ -253,8 +253,10 @@ def matrixDisplay( allCFSeq ): for cfseq in cfseq_list: chains = __getHyposOfStep(cfseq.step) for seq in cfseq.step.sequences: - mx[stepNumber, seq.sequence.Alg.name()].extend(chains) - + if seq.name == "Empty": + mx[stepNumber, "Empty"].extend(chains) + else: + mx[stepNumber, seq.sequence.Alg.name()].extend(chains) # sort dictionary by fist key=step from collections import OrderedDict diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py index dd1b29d9edd5f7964dfa8c1bc8d1c21fdb1bc531..2c88fd2e5dccf5ab3625f2984ec5f25dc6784d10 100644 --- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py +++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py @@ -36,8 +36,10 @@ def setupMenu(): ChainProp(name='HLT_mu6_idperf_L1MU6', groups=SingleMuonGroup), ChainProp(name='HLT_mu24_idperf_L1MU20', groups=SingleMuonGroup), - #ATR-20049 + # Test chain for di-muon with full-scan, not yet working due to problem with FS seeding + #ChainProp(name='HLT_mu6_mu6noL1_L1MU6', l1SeedThresholds=['MU6','FSNOSEED'], mergingStrategy='serial', groups=MultiMuonGroup), + #ATR-20049 ChainProp(name='HLT_mu6fast_L1MU6', groups=SingleMuonGroup), ChainProp(name='HLT_mu6Comb_L1MU6', groups=SingleMuonGroup), ChainProp(name='HLT_mu6_L1MU6', groups=SingleMuonGroup), @@ -45,7 +47,7 @@ def setupMenu(): ChainProp(name='HLT_mu20_ivar_L1MU6', groups=SingleMuonGroup), ChainProp(name='HLT_mu6_ivarmedium_L1MU6', groups=SingleMuonGroup), ChainProp(name='HLT_mu6noL1_L1MU6', l1SeedThresholds=['FSNOSEED'], groups=SingleMuonGroup), -# ChainProp(name='HLT_mu6_mu6noL1_L1MU6', l1SeedThresholds=['MU6','FSNOSEED'], groups=MultiMuonGroup), + ChainProp(name='HLT_mu6_msonly_L1MU6', groups=SingleMuonGroup), ChainProp(name='HLT_2mu6_10invm70_L1MU6', groups=SingleMuonGroup), diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py index e3a954f71084993d73400fb3fb3bb0886d41f6d6..ade757ddfef7de1a6ee95abed975643f08a4295d 100644 --- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py +++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py @@ -1,4 +1,3 @@ - # Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration from AthenaCommon.Logging import logging @@ -131,6 +130,8 @@ def algColor(alg): return "cyan3" if isFilterAlg(alg): return "chartreuse3" + if isEmptyAlg(alg): + return "peachpuff3" if isComboHypoAlg(alg): return "darkorange" return "cadetblue1" @@ -294,7 +295,10 @@ def isHypoBase(alg): if 'HypoInputDecisions' in alg.__class__.__dict__: return True prop = alg.__class__.__dict__.get('_properties') - return ('HypoInputDecisions' in prop) + if type(prop) is dict: + return ('HypoInputDecisions' in prop) + else: + return False def isInputMakerBase(alg): return ('InputMakerInputDecisions' in alg.__class__.__dict__) @@ -302,13 +306,88 @@ def isInputMakerBase(alg): def isFilterAlg(alg): return isinstance(alg, RoRSeqFilter) +def isEmptyAlg(alg): + if alg is None: + return True + else: + return False + def isComboHypoAlg(alg): return isinstance(alg, ComboHypo) + ########################################################## -# NOW sequences and chains +# Now sequences and chains ########################################################## +from DecisionHandling.DecisionHandlingConf import InputMakerForRoI + +class EmptyMenuSequence(object): + """ Class to emulate reco sequences with no Hypo""" + """ By construction it has no Hypo;""" + + def __init__(self, name): + Maker = InputMakerForRoI("IM"+name) + self._name = name + self._maker = InputMakerNode( Alg = Maker ) + self._seed='' + self._sequence = Node( Alg = seqAND(name, [Maker])) + + @property + def sequence(self): + return self._sequence + + @property + def seed(self): + return self._seed + + @property + def name(self): + return self._name + + @property + def __maker(self): + return self._maker + + def getOutputList(self): + return self.__maker.readOutputList() # Only one since it's merged + + def connectToFilter(self, outfilter): + """ Connect filter to the InputMaker""" + self.__maker.addInput(outfilter) + + def createHypoTools(self, chainDict): + log.debug("This sequence is empty. No Hypo to conficure") + + def addToSequencer(self, stepReco, seqAndView, already_connected): + # menu sequence empty do not add to athena sequencer + log.debug("This sequence is empty. Adding Maker node only to athena sequencer") + ath_sequence = self.sequence.Alg + name = ath_sequence.name() + if name in already_connected: + log.debug("AthSequencer %s already in the Tree, not added again",name) + return stepReco, seqAndView, already_connected + else: + already_connected.append(name) + stepReco += ath_sequence + return stepReco, seqAndView, already_connected + + def buildCFDot(self, cfseq_algs, all_hypos, isCombo, last_step_hypo_nodes, file): + file.write(" %s[fillcolor=%s]\n"%("none", algColor(None))) + return cfseq_algs, all_hypos, last_step_hypo_nodes + + def getTools(self): + # No tools for empty sequences - needs to return empty list? + log.debug("No tools for empty menu sequences") + + def setSeed( self, seed ): + self._seed = seed + + def __repr__(self): + return "MenuSequence::%s \n Hypo::%s \n Maker::%s \n Sequence::%s \n HypoTool::%s\n"\ + %("Empty", "Empty", "Empty", "Empty", None) + + class MenuSequence(object): """ Class to group reco sequences with the Hypo""" @@ -366,18 +445,22 @@ class MenuSequence(object): HypoAlg::%s.output=%s",\ self.hypo.Alg.name(), input_maker_output, self.hypo.Alg.name(), self.hypo.readOutputList()[0]) + @property def seed(self): return self._seed + @property def name(self): return self._name + @property def sequence(self): return self._sequence + @property def maker(self): return self._maker @@ -556,7 +639,6 @@ class CAMenuSequence(MenuSequence): return self._hypo - class Chain(object): """Basic class to define the trigger menu """ __slots__='name','steps','vseeds','L1decisions'