Merge branch 'master-HLTJet-HypoViewPS' into 'master'

Preselect jets with view container as input to hypo alg

See merge request atlas/athena!40106

Reconstruction/Jet/JetRec/src/JetViewAlg.cxx

@@ -21,6 +21,7 @@ StatusCode JetViewAlg::initialize() {
 
   ATH_CHECK(m_input.initialize());
   ATH_CHECK(m_output.initialize());
+  ATH_CHECK(m_decorDeps.initialize(m_input, m_output) );
 
   ATH_MSG_DEBUG("Will select jets from " << m_input.key()
 		<< " and write them to " << m_output.key());
@@ -64,9 +65,18 @@ StatusCode JetViewAlg::execute(const EventContext& ctx) const {
   }
   ATH_MSG_DEBUG("Selected " << selected_jets->size() << " from input container of size " << inputHandle->size() );
 
+  // To use ShallowCopyDecorDeps, the input and output handle types have to be the same, i.e. JetContainer
+  // So create a new unique_ptr here using the pointer to the CDV converted to DV
+  std::unique_ptr<const xAOD::JetContainer> selected_jets_jetc(selected_jets.release()->asDataVector());
+
   // Write out JetContainer and JetAuxContainer
-  SG::WriteHandle<ConstDataVector<xAOD::JetContainer> > jetContHandle(m_output,ctx);
-  ATH_CHECK( jetContHandle.record( std::move(selected_jets) ) );
+  SG::WriteHandle<xAOD::JetContainer> jetContHandle(m_output,ctx);
+  // Can't record with const input ptr, hence put
+  if( jetContHandle.put( std::move(selected_jets_jetc) ) == nullptr) {
+    ATH_MSG_ERROR("Failed to record " << m_input.key() << " as const xAOD::JetContainer!");
+    return StatusCode::FAILURE;
+  }
+  ATH_CHECK( m_decorDeps.linkDecors (m_input,ctx) );
 
   return StatusCode::SUCCESS;
 }

Reconstruction/Jet/JetRec/src/JetViewAlg.h

@@ -24,6 +24,7 @@
 #include "xAODJet/Jet.h"
 #include "xAODJet/JetContainer.h"
 #include "AthContainers/ConstDataVector.h"
+#include "StoreGate/ShallowCopyDecorDeps.h"
 
 class JetViewAlg : public AthReentrantAlgorithm { 
 
@@ -48,7 +49,12 @@ private:
   Gaudi::Property<float> m_absetamax     {this, "AbsEtaMax", 10.0, "Max absolute eta"};
 
   SG::ReadHandleKey<xAOD::JetContainer>  m_input  = {this, "InputContainer",  "", "The input jet container name"};
-  SG::WriteHandleKey<ConstDataVector<xAOD::JetContainer> > m_output = {this, "OutputContainer", "", "The output jet container name"};
+  SG::WriteHandleKey<xAOD::JetContainer> m_output = {this, "OutputContainer", "", "The output jet container name"};
+
+  // Propagate a list of decorations from the owning container to the view, such that
+  // jet moments added by DecorHandles are visible on the view container
+  SG::ShallowCopyDecorDeps<xAOD::JetContainer> m_decorDeps { this, "DecorDeps", {},
+      "List of decorations to propagate through the view container." };
   
 }; 
 

Trigger/TrigHypothesis/TrigHLTJetHypo/src/TrigJetHypoAlgMT.cxx

@@ -115,9 +115,10 @@ TrigJetHypoAlgMT::decide(const xAOD::JetContainer* jets,
       // Create a new Decision object to mirror this Jet.
       // Link it to its parent Decision object and attach the jet as a "feature"
       newDecision = TrigCompositeUtils::newDecisionIn(outputDecisions, previousDecision, TrigCompositeUtils::hypoAlgNodeName(), context);
-    
+
+      const xAOD::JetContainer* jetCont = static_cast<const xAOD::JetContainer*>(jet->container());
       ElementLink<xAOD::JetContainer> jetLink =
-	ElementLink<xAOD::JetContainer>(*jets, jet->index());
+	ElementLink<xAOD::JetContainer>(*jetCont, jet->index());
 
       newDecision->setObjectLink<xAOD::JetContainer>(TrigCompositeUtils::featureString(), jetLink);
       jetHypoInputs.push_back( std::make_pair(jet, newDecision) );

Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Jet/JetChainConfiguration.py

@@ -42,7 +42,15 @@ class JetChainConfiguration(ChainConfigurationBase):
 
         # expect that the L1 seed is the same for all jet parts, otherwise we have a problem
         jChainParts = jetChainParts(self.chainPart)
+        # Register if this is a performance chain, in which case the HLT should be exactly j0_perf
+        self.isPerf = False
         for p in jChainParts:
+            if p['addInfo'] == 'perf':
+                # Slightly awkward check but we want to permit any L1, while
+                # restricting HLT to have exactly this form and nothing else
+                if self.chainName != 'HLT_j0_perf_'+self.chainL1Item:
+                        raise RuntimeError(f'Invalid jet \'perf\' chain "{self.chainName}": Only "HLT_j0_perf_[L1]" is permitted!')
+                self.isPerf = True
             l1th = p['L1threshold']
             if self.L1Threshold != '' and self.L1Threshold != l1th:
                 log.error('Cannot configure a jet chain with different L1 thresholds')
@@ -71,15 +79,18 @@ class JetChainConfiguration(ChainConfigurationBase):
             else:
                 clustersKey, jetPreselStep = self.getJetCaloPreselChainStep()
                 chainSteps.append( jetPreselStep )
-            jetCollectionName, jetTrackingHypoStep = self.getJetTrackingHypoChainStep(clustersKey)
+            jetCollectionName, jetDef, jetTrackingHypoStep = self.getJetTrackingHypoChainStep(clustersKey)
             chainSteps.append( jetTrackingHypoStep )
         else:
-            jetCollectionName, jetCaloHypoStep = self.getJetCaloHypoChainStep()
+            jetCollectionName, jetDef, jetCaloHypoStep = self.getJetCaloHypoChainStep()
             chainSteps.append( jetCaloHypoStep )
 
         if "JetDS" in self.chainName:
-           TLAStep = self.getJetTLAChainStep(jetCollectionName)
-           chainSteps+= [TLAStep]
+            # Select the TLA jets from the full jet container
+            # rather than the filtered one seen by the hypo
+            # (No diff in practice if the TLA cut is higher than the hypo filter)
+            TLAStep = self.getJetTLAChainStep(jetDef.fullname())
+            chainSteps+= [TLAStep]
         
         myChain = self.buildChain(chainSteps)
 
@@ -95,11 +106,11 @@ class JetChainConfiguration(ChainConfigurationBase):
         stepName = "MainStep_jet_"+jetDefStr
         from AthenaConfiguration.AllConfigFlags import ConfigFlags
         from TriggerMenuMT.HLTMenuConfig.Jet.JetMenuSequences import jetCaloHypoMenuSequence
-        jetSeq = RecoFragmentsPool.retrieve( jetCaloHypoMenuSequence, 
-                                             ConfigFlags, **self.recoDict )
+        jetSeq, jetDef = RecoFragmentsPool.retrieve( jetCaloHypoMenuSequence, 
+                                                     ConfigFlags, isPerf=self.isPerf, **self.recoDict )
         jetCollectionName = str(jetSeq.hypo.Alg.Jets)
 
-        return jetCollectionName, ChainStep(stepName, [jetSeq], multiplicity=[1], chainDicts=[self.dict])
+        return jetCollectionName, jetDef ,ChainStep(stepName, [jetSeq], multiplicity=[1], chainDicts=[self.dict])
 
     def getJetTrackingHypoChainStep(self, clustersKey):
         jetDefStr = jetRecoDictToString(self.recoDict)
@@ -107,11 +118,12 @@ class JetChainConfiguration(ChainConfigurationBase):
         stepName = "MainStep_jet_"+jetDefStr
         from AthenaConfiguration.AllConfigFlags import ConfigFlags
         from TriggerMenuMT.HLTMenuConfig.Jet.JetMenuSequences import jetTrackingHypoMenuSequence
-        jetSeq = RecoFragmentsPool.retrieve( jetTrackingHypoMenuSequence,
-                                             ConfigFlags, clustersKey=clustersKey, **self.recoDict )
+        jetSeq, jetDef = RecoFragmentsPool.retrieve( jetTrackingHypoMenuSequence,
+                                                     ConfigFlags, clustersKey=clustersKey,
+                                                     isPerf=self.isPerf, **self.recoDict )
         jetCollectionName = str(jetSeq.hypo.Alg.Jets)
 
-        return jetCollectionName, ChainStep(stepName, [jetSeq], multiplicity=[1], chainDicts=[self.dict])
+        return jetCollectionName, jetDef, ChainStep(stepName, [jetSeq], multiplicity=[1], chainDicts=[self.dict])
 
     def getJetCaloRecoChainStep(self):
         stepName = "CaloRecoPTStep_jet_"+self.recoDict["clusterCalib"]
@@ -170,8 +182,8 @@ class JetChainConfiguration(ChainConfigurationBase):
         stepName = "PreselStep_jet_"+jetDefStr
         from AthenaConfiguration.AllConfigFlags import ConfigFlags
         from TriggerMenuMT.HLTMenuConfig.Jet.JetMenuSequences import jetCaloPreselMenuSequence
-        jetSeq, clustersKey = RecoFragmentsPool.retrieve( jetCaloPreselMenuSequence,
-                                                          ConfigFlags, **preselRecoDict )
+        jetSeq, jetDef, clustersKey = RecoFragmentsPool.retrieve( jetCaloPreselMenuSequence,
+                                                                  ConfigFlags, **preselRecoDict )
 
         return str(clustersKey), ChainStep(stepName, [jetSeq], multiplicity=[1], chainDicts=[preselChainDict])
 

Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Jet/JetMenuSequences.py

@@ -43,7 +43,7 @@ def jetCaloRecoSequences( configFlags, RoIs, **jetRecoDict ):
     jetRecoSeq, jetsOut, jetDef  = RecoFragmentsPool.retrieve(
         jetRecoSequence, configFlags, clustersKey=clustersKey, **jetRecoDict )
 
-    return [topoClusterSequence,jetRecoSeq], jetsOut, clustersKey
+    return [topoClusterSequence,jetRecoSeq], jetsOut, jetDef, clustersKey
 
 # This sets up the reconstruction where tracks are required.
 # Topoclustering will not be scheduled, we just pass in the name of the cluster collection.
@@ -63,7 +63,7 @@ def jetTrackingRecoSequences(configFlags, RoIs, clustersKey, **jetRecoDict):
         jetRecoSequence,
         configFlags, clustersKey=clustersKey, **trkcolls, **jetRecoDict )
 
-    return [jetTrkSeq,jetRecoSeq], jetsOut
+    return [jetTrkSeq,jetRecoSeq], jetsOut, jetDef
 
 ###############################################################################################
 # Functions defining the MenuSequence that will be placed into ChainSteps
@@ -107,7 +107,7 @@ def makeMenuSequence(jetSeq,IMAlg,jetsIn,jetDefString,hypoType=JetHypoAlgType.ST
 # For the preselection step before running tracking (step 1)
 def jetCaloPreselMenuSequence(configFlags, **jetRecoDict):
     InputMakerAlg = getInitialInputMaker()
-    jetSequences, jetsIn, clustersKey = RecoFragmentsPool.retrieve(
+    jetSequences, jetsIn, jetDef, clustersKey = RecoFragmentsPool.retrieve(
         jetCaloRecoSequences,
         configFlags, RoIs=caloFSRoI, **jetRecoDict)
 
@@ -115,7 +115,7 @@ def jetCaloPreselMenuSequence(configFlags, **jetRecoDict):
     jetAthSeq = seqAND("jetSeqCaloPresel_"+jetDefString,[InputMakerAlg]+jetSequences)
 
     return makeMenuSequence(jetAthSeq,InputMakerAlg,jetsIn,jetDefString,
-                            hypoType=JetHypoAlgType.PRESEL), clustersKey
+                            hypoType=JetHypoAlgType.PRESEL), jetDef, clustersKey
 
 # A null preselection, which will only run the cluster making (step 1)
 def jetCaloRecoMenuSequence(configFlags, clusterCalib):
@@ -131,27 +131,32 @@ def jetCaloRecoMenuSequence(configFlags, clusterCalib):
                             hypoType=JetHypoAlgType.PASSTHROUGH), clustersKey
 
 # A full hypo selecting only on calo jets (step 1)
-def jetCaloHypoMenuSequence(configFlags, **jetRecoDict):
+# Passing isPerf = True disables the hypo
+def jetCaloHypoMenuSequence(configFlags, isPerf, **jetRecoDict):
     InputMakerAlg = getInitialInputMaker()
-    jetSequences, jetsIn, clustersKey = RecoFragmentsPool.retrieve(
+    jetSequences, jetsIn, jetDef, clustersKey = RecoFragmentsPool.retrieve(
         jetCaloRecoSequences,
         configFlags, RoIs=caloFSRoI, **jetRecoDict)
     jetDefString = jetRecoDictToString(jetRecoDict)
     jetAthSeq = seqAND("jetSeqCaloHypo_"+jetDefString,[InputMakerAlg]+jetSequences)
 
-    return makeMenuSequence(jetAthSeq,InputMakerAlg,jetsIn,jetDefString)
+    hypoType = JetHypoAlgType.STANDARD
+    if isPerf: hypoType = JetHypoAlgType.PASSTHROUGH
+    return makeMenuSequence(jetAthSeq,InputMakerAlg,jetsIn,jetDefString,hypoType) ,jetDef
 
 # A full hypo selecting on jets with track reco (step 2)
 # To combine either with a presel or a passthrough sequence
 # As this does not run topoclustering, the cluster collection
 # name needs to be passed in
-def jetTrackingHypoMenuSequence(configFlags, clustersKey, **jetRecoDict):
+def jetTrackingHypoMenuSequence(configFlags, clustersKey, isPerf, **jetRecoDict):
     InputMakerAlg = getTrackingInputMaker()
-    jetSequences, jetsIn = RecoFragmentsPool.retrieve(
+    jetSequences, jetsIn, jetDef = RecoFragmentsPool.retrieve(
         jetTrackingRecoSequences,
         configFlags, RoIs=trkFSRoI, clustersKey=clustersKey, **jetRecoDict)
 
     jetDefString = jetRecoDictToString(jetRecoDict)
     jetAthSeq = seqAND("jetSeqTrkHypo_"+jetDefString,[InputMakerAlg]+jetSequences)
 
-    return makeMenuSequence(jetAthSeq,InputMakerAlg,jetsIn,jetDefString)
+    hypoType = JetHypoAlgType.STANDARD
+    if isPerf: hypoType = JetHypoAlgType.PASSTHROUGH
+    return makeMenuSequence(jetAthSeq,InputMakerAlg,jetsIn,jetDefString,hypoType), jetDef

Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Jet/JetRecoSequences.py

@@ -168,7 +168,6 @@ def standardJetRecoSequence( configFlags, dataSource, clustersKey, **jetRecoDict
     # Get the calibration tool if desired. 
     jetDef = jetDefNoCalib.clone()
     jetDef.suffix = jetDefNoCalib.suffix.replace("nojcalib",jetRecoDict["jetCalib"])
-    jetsOut = jetDef.fullname()
 
     rhoKey = "auto"
     if "sub" in jetRecoDict["jetCalib"]:
@@ -184,13 +183,24 @@ def standardJetRecoSequence( configFlags, dataSource, clustersKey, **jetRecoDict
     # If we need JVT, just rerun the JVT modifier
     doesTracking = jetRecoDict["trkopt"] != "notrk"
     isPFlow = jetRecoDict["constitType"] == "pf"
+    decorList = JetRecoConfiguration.getDecorList(doesTracking,isPFlow)
     if doesTracking:
         jetDef.modifiers.append("JVT:"+jetRecoDict["trkopt"])
-    decorList = JetRecoConfiguration.getDecorList(doesTracking,isPFlow)
+        decorList += ["Jvt"]
     copyCalibAlg = JetRecConfig.getJetCopyAlg(jetsin=jetsNoCalib,jetsoutdef=jetDef,decorations=decorList)
-
     recoSeq += copyCalibAlg
 
+    jetPtMin = 10 # 10 GeV minimum pt for jets to be seen by hypo
+    from JetRec.JetRecConf import JetViewAlg
+    filteredJetsName = jetDef.fullname()+"_pt{}".format(jetPtMin)
+    recoSeq += JetViewAlg("jetview_"+filteredJetsName,
+                          InputContainer=jetDef.fullname(),
+                          OutputContainer=filteredJetsName,
+                          PtMin=jetPtMin,
+                          DecorDeps=decorList
+    )
+    jetsOut = filteredJetsName
+
     # End of basic jet reco
     return recoSeq, jetsOut, jetDef
 
@@ -242,7 +252,7 @@ def reclusteredJetRecoSequence( configFlags, dataSource, clustersKey, **jetRecoD
 
     basicJetRecoDict = dict(jetRecoDict)
     basicJetRecoDict["recoAlg"] = "a4" # Standard size for reclustered
-    (basicJetRecoSequence,basicJetsName, basicJetDef) = RecoFragmentsPool.retrieve(
+    (basicJetRecoSequence,basicJetsFiltered, basicJetDef) = RecoFragmentsPool.retrieve(
         standardJetRecoSequence,
         configFlags, dataSource=dataSource, clustersKey=clustersKey,
         **basicJetRecoDict)
@@ -250,13 +260,14 @@ def reclusteredJetRecoSequence( configFlags, dataSource, clustersKey, **jetRecoD
 
     rcJetPtMin = 15e3 # 15 GeV minimum pt for jets to be reclustered
     from JetRec.JetRecConf import JetViewAlg
-    filteredJetsName = basicJetsName+"_pt15"
+    filteredJetsName = basicJetDef.fullname()+"_pt15"
     recoSeq += JetViewAlg("jetview_"+filteredJetsName,
-                          InputContainer=basicJetsName,
+                          InputContainer=basicJetDef.fullname(),
                           OutputContainer=filteredJetsName,
                           PtMin=rcJetPtMin)
 
     rcJetDef = JetRecoConfiguration.defineReclusteredJets(jetRecoDict, filteredJetsName)
+
     rcJetsFullName = jetNamePrefix+rcJetDef.basename+"Jets_"+jetRecoDict["jetCalib"]
     rcModList = [] # Could set substructure mods
     rcJetDef.modifiers = rcModList

Trigger/TriggerCommon/TriggerMenuMT/share/full_menu_cf.py

@@ -116,7 +116,7 @@ def generateChains():
     def jetCaloHypoMenuSequenceFromString(jet_def_str):
         jetRecoDict = jetRecoDictFromString(jet_def_str)
         from TriggerMenuMT.HLTMenuConfig.Jet.JetMenuSequences import jetCaloHypoMenuSequence
-        return jetCaloHypoMenuSequence(ConfigFlags, **jetRecoDict)
+        return jetCaloHypoMenuSequence(ConfigFlags, isPerf=False, **jetRecoDict)
 
     def jetCaloPreselMenuSequenceFromString(jet_def_str):
         jetRecoDict = jetRecoDictFromString(jet_def_str)
@@ -126,28 +126,28 @@ def generateChains():
     def jetTrackingHypoMenuSequenceFromString(jet_def_str,clustersKey):
         jetRecoDict = jetRecoDictFromString(jet_def_str)
         from TriggerMenuMT.HLTMenuConfig.Jet.JetMenuSequences import jetTrackingHypoMenuSequence
-        return jetTrackingHypoMenuSequence(ConfigFlags, clustersKey=clustersKey, **jetRecoDict)
+        return jetTrackingHypoMenuSequence(ConfigFlags, clustersKey=clustersKey, isPerf=False, **jetRecoDict)
 
     if opt.doJetSlice is True:
 
         # small-R jets
-        jetSeq_a4_tc_em = jetCaloHypoMenuSequenceFromString("a4_tc_em_subjesIS")
+        jetSeq_a4_tc_em, jetDef = jetCaloHypoMenuSequenceFromString("a4_tc_em_subjesIS")
         step_a4_tc_em = makeChainStep("Step_jet_a4_tc_em", [jetSeq_a4_tc_em])
         
         # large-R jets
-        jetSeq_a10_tc_lcw_subjes = jetCaloHypoMenuSequenceFromString("a10_tc_lcw_subjes")
+        jetSeq_a10_tc_lcw_subjes, jetDef = jetCaloHypoMenuSequenceFromString("a10_tc_lcw_subjes")
         step_a10_tc_lcw_subjes = makeChainStep("Step_jet_a10_subjes_tc_lcw", [jetSeq_a10_tc_lcw_subjes])
         
-        jetSeq_a10r = jetCaloHypoMenuSequenceFromString("a10r_tc_em_subjesIS")
+        jetSeq_a10r, jetDef = jetCaloHypoMenuSequenceFromString("a10r_tc_em_subjesIS")
         step_a10r = makeChainStep("Step_jet_a10r", [jetSeq_a10r])
 
-        jetSeq_a10t = jetCaloHypoMenuSequenceFromString("a10t_tc_lcw_jes")
+        jetSeq_a10t, jetDef = jetCaloHypoMenuSequenceFromString("a10t_tc_lcw_jes")
         step_a10t = makeChainStep("Step_jet_a10t", [jetSeq_a10t])
         
         # Jet chains with tracking
-        jetSeq_a4_tc_em_presel, emclusters = jetCaloPreselMenuSequenceFromString("a4_tc_em_subjesIS")
+        jetSeq_a4_tc_em_presel, jetDef, emclusters = jetCaloPreselMenuSequenceFromString("a4_tc_em_subjesIS")
         step_a4_tc_em_presel = makeChainStep("Step_jet_a4_tc_em_presel", [jetSeq_a4_tc_em_presel])
-        jetSeq_a4_pf_em_ftf = jetTrackingHypoMenuSequenceFromString("a4_tc_em_subresjesgscIS_ftf",emclusters)
+        jetSeq_a4_pf_em_ftf, jetDef = jetTrackingHypoMenuSequenceFromString("a4_tc_em_subresjesgscIS_ftf",emclusters)
         step_a4_pf_em_ftf = makeChainStep("Step_jet_a4_pf_em_ftf", [jetSeq_a4_pf_em_ftf])
 
         jetChains  = [
@@ -173,8 +173,8 @@ def generateChains():
     if opt.doBjetSlice is True:
         from TriggerMenuMT.HLTMenuConfig.Bjet.BjetSequenceSetup import getBJetSequence
 
-        jetSeq_a4_tc_em_presel, emclusters = jetCaloPreselMenuSequenceFromString("a4_tc_em_subjesIS")
-        jetSeq_a4_tc_em_gsc_ftf = jetTrackingHypoMenuSequenceFromString("a4_tc_em_subjesgscIS_ftf",emclusters)
+        jetSeq_a4_tc_em_presel, jetDef, emclusters = jetCaloPreselMenuSequenceFromString("a4_tc_em_subjesIS")
+        jetSeq_a4_tc_em_gsc_ftf, jetDef = jetTrackingHypoMenuSequenceFromString("a4_tc_em_subjesgscIS_ftf",emclusters)
         
         step1 = makeChainStep("Step_jet_a4_tc_em_presel", [jetSeq_a4_tc_em_presel])
         step2 = makeChainStep("Step_jet_a4_tc_em_gsc_ftf", [jetSeq_a4_tc_em_gsc_ftf])