PhysicsAnalysis/JetTagging/FlavorTagDiscriminants/src/components/FlavorTagDiscriminants_entries.cxx

@@ -8,6 +8,7 @@
 #include "FlavorTagDiscriminants/BTagAugmenterTool.h"
 #include "FlavorTagDiscriminants/BTagMuonAugmenterTool.h"
 #include "FlavorTagDiscriminants/BTagDecoratorAlg.h"
+#include "FlavorTagDiscriminants/JetTagDecoratorAlg.h"
 #include "FlavorTagDiscriminants/BTagToJetLinkerAlg.h"
 #include "FlavorTagDiscriminants/JetToBTagLinkerAlg.h"
 #include "FlavorTagDiscriminants/BTagTrackLinkCopyAlg.h"
@@ -22,6 +23,7 @@ DECLARE_COMPONENT(DL2Tool)
 DECLARE_COMPONENT(BTagAugmenterTool)
 DECLARE_COMPONENT(BTagMuonAugmenterTool)
 DECLARE_COMPONENT(BTagDecoratorAlg)
+DECLARE_COMPONENT(JetTagDecoratorAlg)
 DECLARE_COMPONENT(BTagToJetLinkerAlg)
 DECLARE_COMPONENT(JetToBTagLinkerAlg)
 DECLARE_COMPONENT(BTagTrackLinkCopyAlg)

PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/BTagHighLevelAugmenterAlgConfig.py

@@ -16,8 +16,8 @@ def BTagHighLevelAugmenterAlgCfg(ConfigFlags, JetCollection, BTagCollection, Ass
 
     decorAlg = CompFactory.FlavorTagDiscriminants.BTagDecoratorAlg(
         name=f'{name}_alg',
-        btagContainer=BTagCollection,
-        trackContainer=TrackCollection,
+        container=BTagCollection,
+        constituentContainer=TrackCollection,
         decorator=btagAug,
     )
     # -- create the augmentation algorithm

PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/HighLevelBTagAlgConfig.py

@@ -89,8 +89,8 @@ def HighLevelBTagAlgCfg(ConfigFlags, BTaggingCollection, TrackCollection, NNFile
 
     decorAlg = CompFactory.FlavorTagDiscriminants.BTagDecoratorAlg(
         name=name,
-        btagContainer=BTaggingCollection,
-        trackContainer=TrackCollection,
+        container=BTaggingCollection,
+        constituentContainer=TrackCollection,
         decorator=dl2,
         undeclaredReadDecorKeys=sorted(veto_list),
     )

Projects/AthDataQuality/version.txt

-22.0.46
+22.0.47

Projects/AthSimulation/version.txt

-22.0.46
+22.0.47

Projects/Athena/version.txt

-22.0.46
+22.0.47

Projects/DetCommon/version.txt

-22.0.46
+22.0.47

Projects/VP1Light/version.txt

-22.0.46
+22.0.47

Reconstruction/Jet/JetMomentTools/JetMomentTools/JetForwardJvtTool.h

@@ -81,6 +81,7 @@
     Gaudi::Property<double> m_jetScaleFactor{this, "JetScaleFactor", 0.4, "Jet scale factor"};
     Gaudi::Property<double> m_fjvtThresh{this, "FjvtThresh", 15e3, "FJVT threshold"}; //15GeV->92%,11GeV->85%
     Gaudi::Property<bool> m_tightOP{this, "UseTightOP", false, "Use tight (true) or loose (false)"};
+    Gaudi::Property<bool> m_recalculateFjvt{this, "RecalculateFjvt", true, "Recalculate Fjvt or use stored value"}; 
     mutable std::vector<TVector2> m_pileupMomenta;
     mutable size_t m_pvind = 0UL;
     void getPV() const;

Reconstruction/Jet/JetMomentTools/Root/JetForwardJvtTool.cxx

@@ -74,10 +74,10 @@
     SG::WriteDecorHandle<xAOD::JetContainer, float> fjvtDecHandle(m_fjvtDecKey);
 
     getPV();
-    if (jetCont.size() > 0) calculateVertexMomenta(&jetCont);
+    if (m_recalculateFjvt && jetCont.size() > 0) calculateVertexMomenta(&jetCont);
     for(const auto jetF : jetCont) {
       outHandle(*jetF) = 1;
-      fjvtDecHandle(*jetF) = 0;
+      if(m_recalculateFjvt) fjvtDecHandle(*jetF) = 0;
       if (!forwardJet(jetF)) continue;
       double fjvt = getFJVT(jetF)/jetF->pt();
       if (fjvt>m_fjvtThresh) outHandle(*jetF) = 0;
@@ -87,6 +87,11 @@
   }
 
   float JetForwardJvtTool::getFJVT(const xAOD::Jet *jet) const {
+    if(!m_recalculateFjvt){
+      SG::WriteDecorHandle<xAOD::JetContainer, float> fjvtDecHandle(m_fjvtDecKey);
+      return fjvtDecHandle(*jet);
+    } 
+
     TVector2 fjet(-jet->pt()*cos(jet->phi()),-jet->pt()*sin(jet->phi()));
     double fjvt = 0;
     for (size_t pui = 0; pui < m_pileupMomenta.size(); pui++) {

Reconstruction/Jet/JetMonitoring/JetMonitoring/EfficiencyResponseHistos.h

@@ -37,6 +37,10 @@ protected:
   TProfile* m_etres_eta;
   TProfile* m_etres_pt;
 
+  TH1F* m_etres_noShift;
+  TProfile* m_etres_noShift_eta;
+  TProfile* m_etres_noShift_pt;
+
   TH1F* m_deltaRclosest;
 
 };

Reconstruction/Jet/JetMonitoring/Root/EfficiencyResponseHistos.cxx

@@ -46,6 +46,10 @@ int EfficiencyResponseHistos::buildHistos(){
   m_etres_eta =bookHisto( hbuilder.build<TProfile>("erhResponseVsEta") );
   m_etres_pt =bookHisto( hbuilder.build<TProfile>("erhResponseVsPt") );
 
+  m_etres_noShift = bookHisto( hbuilder.build<TH1F>("erhResponse_noShift") );
+  m_etres_noShift_eta =bookHisto( hbuilder.build<TProfile>("erhResponseVsEta_noShift") );
+  m_etres_noShift_pt =bookHisto( hbuilder.build<TProfile>("erhResponseVsPt_noShift") );
+
   m_deltaRclosest = bookHisto( hbuilder.build<TH1F>("erhDeltaR") );
 
 
@@ -85,11 +89,18 @@ int EfficiencyResponseHistos::fillHistosFromContainer(const xAOD::JetContainer &
 
     if( dr < 0.3) {
       double relDiff = -999;
-      if (refPt > 0.) relDiff = ( matched->pt()* toGeV - refPt )/refPt;
+      double response = -999;
+      if (refPt > 0.){
+	relDiff = ( matched->pt()* toGeV - refPt )/refPt;
+	response = (matched->pt()* toGeV)/refPt;
+      }
       m_etres->Fill( relDiff, weight );
       m_etres_eta->Fill( refjet->eta(), relDiff, weight);
       m_etres_pt->Fill( refPt, relDiff, weight);
 
+      m_etres_noShift->Fill( response, weight );
+      m_etres_noShift_eta->Fill( refjet->eta(), response, weight);
+      m_etres_noShift_pt->Fill( refPt, response, weight);
     }
 
   }

Reconstruction/Jet/JetMonitoring/python/JetHistoTools.py

@@ -218,6 +218,10 @@ jhm.addTool( EfficiencyResponseHistos("effresponse",
     hdef('erhResponseVsEta', "Jet p_{T} Response vs #eta;#eta of jet;#frac{p_{T}^{Jet} - p_{T}^{Truth}}{p_{T}^{Truth}}",50,-5,5 ),
     hdef('erhResponseVsPt', "Jet p_{T} Response vs p_{T};p_{T}^{Truth} of jet;#frac{p_{T}^{Jet} - p_{T}^{Truth}}{p_{T}^{Truth}}",50,0,1000 ),
 
+    hdef('erhResponse_noShift', "Jet p_{T} Response;#frac{p_{T}^{Jet}}{p_{T}^{Truth}};Number of jets",50,0,2 ),
+    hdef('erhResponseVsEta_noShift', "Jet p_{T} Response vs #eta;#eta of jet;#frac{p_{T}^{Jet}}{p_{T}^{Truth}}",50,-5,5 ),
+    hdef('erhResponseVsPt_noShift', "Jet p_{T} Response vs p_{T};p_{T}^{Truth} of jet;#frac{p_{T}^{Jet}}{p_{T}^{Truth}}",50,0,1000 ),
+
     hdef('erhDeltaR', "#DeltaR between Jet and closest Truth Jet;#DeltaR;Number of jets",50,0,4 ),
 
     ]

Reconstruction/Jet/JetUncertainties/Root/FFJetSmearingTool.cxx

@@ -435,7 +435,7 @@ StatusCode FFJetSmearingTool::getMatchedTruthJet(xAOD::Jet& jet_reco, xAOD::Jet&
 
     //Loop over the truth jets in the event to match
     const xAOD::Jet* close_jet = nullptr;
-    for (const auto& jet_truth : *jets_truth) {
+    for (const auto jet_truth : *jets_truth) {
         float dR_Test = jet_reco.p4().DeltaR(jet_truth->p4());
         if ( dR_Test < dRmax_truthJet){
             if(dR_Test < dRmin){

Reconstruction/egamma/egammaAlgs/python/egammaLargeClusterMakerAlg.py

@@ -21,7 +21,8 @@ egammaLargeClusterMakerAlg = AlgFactory(
     SaveUncalibratedSignalState=False,
     ClustersOutputName=egammaKeys.EgammaLargeClustersKey(),
     ClusterMakerTools=FcnWrapper(clusMakerTools),
-    ClusterCorrectionTools=make_CaloSwCorrections("ele7_11",
-                                                  suffix="Nocorr",
-                                                  version="none",
-                                                  cells_name=egammaKeys.caloCellKey()))
+    ClusterCorrectionTools=make_CaloSwCorrections(
+        "ele7_11",
+        suffix="Nocorr",
+        version="none",
+        cells_name=egammaKeys.caloCellKey()))

Reconstruction/egamma/egammaAlgs/python/egammaLargeClusterMakerAlgConfig.py

@@ -9,7 +9,8 @@ from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 from AthenaConfiguration.ComponentFactory import CompFactory
 from egammaTools.egammaLargeClusterMakerConfig import (
     egammaLargeClusterMakerCfg)
-from CaloClusterCorrection.CaloSwCorrections import make_CaloSwCorrections
+from CaloClusterCorrection.CaloSwCorrections import (
+    make_CaloSwCorrectionsCfg)
 
 
 def egammaLargeClusterMakerAlgCfg(
@@ -17,24 +18,24 @@ def egammaLargeClusterMakerAlgCfg(
         name="egammaLargeClusterMaker",
         **kwargs):
 
-    acc = ComponentAccumulator
+    acc = ComponentAccumulator()
 
     kwargs.setdefault("SaveUncalibratedSignalState", False)
     kwargs.setdefault("ClustersOutputName",
                       flags.Egamma.Keys.Output.EgammaLargeClusters)
 
     if "ClusterMakerTools" not in kwargs:
-        toolAcc = egammaLargeClusterMakerCfg(flags)
-        kwargs["ClusterMakerTools"] = [toolAcc.popPrivateTools()]
-        acc.merge(toolAcc)
+        tool = egammaLargeClusterMakerCfg(flags)
+        kwargs["ClusterMakerTools"] = [acc.popToolsAndMerge(tool)]
 
-    kwargs.setdefault(
-        "ClusterCorrectionTools",
-        make_CaloSwCorrections(
+    if "ClusterCorrectionTools" not in kwargs:
+        tools = make_CaloSwCorrectionsCfg(
+            flags,
             "ele7_11",
             suffix="Nocorr",
             version="none",
-            cells_name=flags.Egamma.Keys.Input.CaloCells))
+            cells_name=flags.Egamma.Keys.Input.CaloCells)
+        kwargs["ClusterCorrectionTools"] = acc.popToolsAndMerge(tools)
 
     acc.addEventAlgo(CompFactory.CaloClusterMaker(name, **kwargs))
     return acc

Reconstruction/egamma/egammaAlgs/python/egammaLargeFWDClusterMakerAlgConfig.py

@@ -8,15 +8,16 @@ from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 from AthenaConfiguration.ComponentFactory import CompFactory
 from egammaTools.egammaLargeFWDClusterMakerConfig import (
     egammaLargeFWDClusterMakerCfg)
-from CaloClusterCorrection.CaloSwCorrections import make_CaloSwCorrections
+from CaloClusterCorrection.CaloSwCorrections import (
+    make_CaloSwCorrectionsCfg)
 
 
 def egammaLargeFWDClusterMakerAlgCfg(
         flags,
-        name="egammaLargeClusterMaker",
+        name="egammaLargeFWDClusterMaker",
         **kwargs):
 
-    acc = ComponentAccumulator
+    acc = ComponentAccumulator()
 
     kwargs.setdefault("SaveUncalibratedSignalState", False)
     kwargs.setdefault("ClustersOutputName",
@@ -27,13 +28,14 @@ def egammaLargeFWDClusterMakerAlgCfg(
         kwargs["ClusterMakerTools"] = [toolAcc.popPrivateTools()]
         acc.merge(toolAcc)
 
-    kwargs.setdefault(
-        "ClusterCorrectionTools",
-        make_CaloSwCorrections(
+    if "ClusterCorrectionTools" not in kwargs:
+        tools = make_CaloSwCorrectionsCfg(
+            flags,
             "FWDele6_6",
             suffix="Nocorr",
             version="none",
-            cells_name=flags.Egamma.Keys.Input.CaloCells))
+            cells_name=flags.Egamma.Keys.Input.CaloCells)
+        kwargs["ClusterCorrectionTools"] = acc.popToolsAndMerge(tools)
 
     acc.addEventAlgo(CompFactory.CaloClusterMaker(name, **kwargs))
     return acc

Reconstruction/egamma/egammaConfig/python/egammaBuilderConfig.py

@@ -17,30 +17,13 @@ def EGammaReconstructionCfg(flags, name="EGammaReconstruction"):
 
     acc = ComponentAccumulator()
 
-    # Depending on what is availabe we might want
-    # to disable certain things
-
-    # without calo no egamma
-    if not flags.Detector.EnableCalo:
-        flags.Egamma.enabled = False
-        flags.Egamma.doCaloSeeded = False
-        flags.Egamma.doForwardSeeded = False
-
-    # Tracking
-    if not flags.Detector.EnableID:
-        flags.Egamma.doGSF = False
-        flags.Egamma.doConversionBuilding = False
-
-    # MC Truth
-    if not flags.Input.isMC:
-        flags.Egamma.doTruthAssociation = False
-
     # if not enabled add nothing
     if not flags.Egamma.enabled:
         return acc
 
-    # Add algorithms
+    # Add e/gamma tracking algorithms
     if flags.Egamma.doGSF:
+
         from egammaAlgs.egammaSelectedTrackCopyConfig import (
             egammaSelectedTrackCopyCfg)
         acc.merge(egammaSelectedTrackCopyCfg(flags))
@@ -53,30 +36,55 @@ def EGammaReconstructionCfg(flags, name="EGammaReconstruction"):
             EMGSFCaloExtensionBuilderCfg)
         acc.merge(EMGSFCaloExtensionBuilderCfg(flags))
 
+    # Add e/gamma conversion finding
     if flags.Egamma.doConversionBuilding:
-        from egammaAlgs.EMVertexBuilderConfig import EMVertexBuilderCfg
+
+        from egammaAlgs.EMVertexBuilderConfig import (
+            EMVertexBuilderCfg)
         acc.merge(EMVertexBuilderCfg(flags))
 
+    # Add calo seeded central algorithms
     if flags.Egamma.doCaloSeeded:
-        from egammaAlgs.egammaRecBuilderConfig import egammaRecBuilderCfg
+
+        from egammaAlgs.egammaRecBuilderConfig import (
+            egammaRecBuilderCfg)
         acc.merge(egammaRecBuilderCfg(flags))
+
         from egammaAlgs.egammaSuperClusterBuilderConfig import (
             electronSuperClusterBuilderCfg, photonSuperClusterBuilderCfg)
         acc.merge(electronSuperClusterBuilderCfg(flags))
         acc.merge(photonSuperClusterBuilderCfg(flags))
-        from egammaAlgs.topoEgammaBuilderConfig import topoEgammaBuilderCfg
+
+        from egammaAlgs.topoEgammaBuilderConfig import (
+            topoEgammaBuilderCfg)
         acc.merge(topoEgammaBuilderCfg(flags))
 
+        from egammaAlgs.egammaLargeClusterMakerAlgConfig import (
+            egammaLargeClusterMakerAlgCfg)
+        acc.merge(egammaLargeClusterMakerAlgCfg(flags))
+
+    # Add calo seeded forward algorithms
     if flags.Egamma.doForwardSeeded:
+
         from egammaAlgs.egammaForwardBuilderConfig import (
             egammaForwardBuilderCfg)
         acc.merge(egammaForwardBuilderCfg(flags))
 
+    # Add truth association
     if flags.Egamma.doTruthAssociation:
+
         from egammaAlgs.egammaTruthAssociationConfig import (
             egammaTruthAssociationCfg)
         acc.merge(egammaTruthAssociationCfg(flags))
 
+    # Add e/gamma track thinning
+    # (although we call the Alg slimming)
+    if flags.Egamma.doTrackThinning:
+
+        from egammaAlgs.egammaTrackSlimmerConfig import (
+            egammaTrackSlimmerCfg)
+        acc.merge(egammaTrackSlimmerCfg(flags))
+
     mlog.info("EGamma reconstruction configured")
 
     return acc
@@ -89,6 +97,7 @@ if __name__ == "__main__":
     from AthenaConfiguration.TestDefaults import defaultTestFiles
     from AthenaConfiguration.MainServicesConfig import MainServicesCfg
     flags.Input.Files = defaultTestFiles.RDO
+    flags.Output.doWriteAOD = True  # To test the AOD parts
 
     acc = MainServicesCfg(flags)
     acc.merge(EGammaReconstructionCfg(flags))

Reconstruction/egamma/egammaConfig/python/egammaConfigFlags.py

@@ -13,19 +13,27 @@ def createEgammaConfigFlags():
     egcf.addFlag("Egamma.enabled", True)
 
     # do standard cluster-based egamma algorithm
-    egcf.addFlag("Egamma.doCaloSeeded", True)
+    egcf.addFlag("Egamma.doCaloSeeded",
+                 lambda prevFlags: prevFlags.Detector.EnableCalo)
 
     # do forward egamma
-    egcf.addFlag("Egamma.doForwardSeeded", True)
+    egcf.addFlag("Egamma.doForwardSeeded",
+                 lambda prevFlags: prevFlags.Detector.EnableCalo)
 
     # do egamma truth association when running on MC
-    egcf.addFlag("Egamma.doTruthAssociation", True)
+    egcf.addFlag("Egamma.doTruthAssociation",
+                 lambda prevFlags: prevFlags.Input.isMC)
 
-    # run the GSF refitting
-    egcf.addFlag("Egamma.doGSF", True)
+    # run the GSF refitting /egamma Tracking
+    egcf.addFlag("Egamma.doGSF", lambda prevFlags: prevFlags.Detector.EnableID)
 
-    # build conversion vertices
-    egcf.addFlag("Egamma.doConversionBuilding", True)
+    # build photon conversion vertices
+    egcf.addFlag("Egamma.doConversionBuilding",
+                 lambda prevFlags: prevFlags.Detector.EnableID)
+
+    # Do e/gamma track thinning (Although we call the alg slimming...)
+    egcf.addFlag("Egamma.doTrackThinning",
+                 lambda prevFlags: prevFlags.Output.doWriteAOD)
 
     # The cluster corrections/calib
     egcf.addFlag("Egamma.Calib.ClusterCorrectionVersion",

Reconstruction/egamma/egammaTools/python/egammaLargeClusterMakerConfig.py

@@ -16,7 +16,8 @@ def egammaLargeClusterMakerCfg(flags, name="egammaLCMakerTool",  **kwargs):
     kwargs.setdefault("CellsName", flags.Egamma.Keys.Input.CaloCells)
     kwargs.setdefault("InputClusterCollection",
                       flags.Egamma.Keys.Output.CaloClusters)
-
+    kwargs.setdefault("InputClusterCollection",
+                      flags.Egamma.Keys.Output.CaloClusters)
     acc.setPrivateTools(CompFactory.egammaLargeClusterMaker(name, **kwargs))
 
     return acc