'CMakeLists.txt' (DerivationFrameworkHiggs-00-03-67)

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/CMakeLists.txt

+################################################################################
+# Package: DerivationFrameworkHiggs
+################################################################################
+
+# Declare the package name:
+atlas_subdir( DerivationFrameworkHiggs )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+                          Control/AthenaBaseComps
+                          Event/xAOD/xAODEgamma
+                          Event/xAOD/xAODJet
+                          Event/xAOD/xAODMuon
+                          PhysicsAnalysis/DerivationFramework/DerivationFrameworkInterfaces
+                          Trigger/TrigAnalysis/TrigDecisionTool
+                          PRIVATE
+                          Event/xAOD/xAODEventInfo
+                          Event/xAOD/xAODTracking
+                          GaudiKernel )
+
+# External dependencies:
+find_package( CLHEP )
+
+# Component(s) in the package:
+atlas_add_library( DerivationFrameworkHiggsLib
+                   src/*.cxx
+                   PUBLIC_HEADERS DerivationFrameworkHiggs
+                   PRIVATE_INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS}
+                   PRIVATE_DEFINITIONS ${CLHEP_DEFINITIONS}
+                   LINK_LIBRARIES AthenaBaseComps xAODEgamma xAODJet xAODMuon TrigDecisionToolLib
+                   PRIVATE_LINK_LIBRARIES ${CLHEP_LIBRARIES} xAODEventInfo xAODTracking GaudiKernel )
+
+atlas_add_component( DerivationFrameworkHiggs
+                     src/components/*.cxx
+                     INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS}
+                     LINK_LIBRARIES ${CLHEP_LIBRARIES} AthenaBaseComps xAODEgamma xAODJet xAODMuon TrigDecisionToolLib xAODEventInfo xAODTracking GaudiKernel DerivationFrameworkHiggsLib )
+
+# Install files from the package:
+atlas_install_python_modules( python/*.py )
+atlas_install_joboptions( share/*.py )
+

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/DerivationFrameworkHiggs/SkimmingToolHIGG1.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SkimmingToolHIGG1.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_SKIMMINGTOOLHSG1_H
+#define DERIVATIONFRAMEWORK_SKIMMINGTOOLHSG1_H 1
+ 
+#include <string>
+#include <vector>
+#include <algorithm>
+
+// Gaudi & Athena basics
+#include "AthenaBaseComps/AthAlgTool.h"
+
+// DerivationFramework includes
+#include "DerivationFrameworkInterfaces/ISkimmingTool.h"
+
+// xAOD header files
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+#include "xAODJet/JetContainer.h"
+#include "xAODMuon/MuonContainer.h"
+
+#include "TrigDecisionTool/TrigDecisionTool.h"
+
+
+
+namespace DerivationFramework {
+
+  /** @class SkimmingToolHIGG1
+      @author jsaxon@cern.ch 
+      @author magdac@cern.ch
+     */
+  class SkimmingToolHIGG1 : public AthAlgTool, public ISkimmingTool {
+
+    public: 
+      /** Constructor with parameters */
+      SkimmingToolHIGG1( const std::string& t, const std::string& n, const IInterface* p );
+
+      /** Destructor */
+      ~SkimmingToolHIGG1();
+
+      // Athena algtool's Hooks
+      StatusCode  initialize();
+      StatusCode  finalize();
+
+      /** Check that the current event passes this filter */
+      virtual bool eventPassesFilter() const;
+
+    private:
+
+      ///////////////
+      ///// TOOLS 
+
+      ToolHandle<Trig::TrigDecisionTool> m_trigDecisionTool;
+
+      ///////////////
+      ///// SETTINGS
+
+      std::string m_photonSGKey;
+      std::string m_electronSGKey;
+      std::string m_muonSGKey;
+
+      // CUTS TO APPLY OR NOT
+      bool m_reqGRL;
+      bool m_reqLArError;
+      bool m_reqTrigger;
+      bool m_reqPreselection;
+      bool m_incSingleElectron;
+      bool m_incDoubleElectron;
+      bool m_incSingleMuon;
+      bool m_reqKinematic;
+      bool m_reqQuality;
+      bool m_reqIsolation;
+      bool m_reqInvariantMass;
+
+
+      // CUT VALUES/SETTINGS
+
+      std::string m_goodRunList;
+
+      std::string m_defaultTrigger;
+      std::vector<std::string> m_triggers;
+
+      mutable bool m_isMC;
+
+      double m_minPhotonPt;
+      bool   m_removeCrack;
+      double m_maxEta;
+
+      bool   m_relativePtCuts;
+      double m_leadingPhotonPt;
+      double m_subleadingPhotonPt;
+
+      double m_minInvariantMass;
+      double m_maxInvariantMass;
+
+      double m_minElectronPt;
+      double m_minMuonPt;
+      double m_maxMuonEta;
+
+      ////////////////
+      ///// FUNCTIONS
+
+      // Cuts
+      bool   SubcutGoodRunList() const;
+      bool   SubcutLArError() const;
+      bool   SubcutTrigger() const;
+      bool   SubcutPreselect() const;
+      bool   SubcutOnePhotonOneElectron() const;
+      bool   SubcutTwoElectrons() const;
+      bool   SubcutOnePhotonOneMuon() const;
+      bool   SubcutKinematic() const;
+      bool   SubcutQuality() const;
+      bool   SubcutIsolation() const;
+      bool   SubcutInvariantMass() const;
+
+      // Calculators
+      bool   PhotonPreselect(const xAOD::Photon *ph) const;
+      bool   ElectronPreselect(const xAOD::Electron *el) const;
+      bool   MuonPreselect(const xAOD::Muon *mu) const;
+      void   CalculateInvariantMass() const;
+      void   GetDiphotonVertex() const;
+      double CorrectedEnergy(const xAOD::Photon *ph) const;
+      double CorrectedEta(const xAOD::Photon *ph) const;
+      double ReturnRZ_1stSampling_cscopt2(double eta1) const;
+
+      ///////////////
+      ///// COUNTERS
+
+      mutable unsigned int n_tot;
+      mutable unsigned int n_passGRL;
+      mutable unsigned int n_passLArError;
+      mutable unsigned int n_passTrigger;
+      mutable unsigned int n_passPreselect;
+      mutable unsigned int n_passSingleElectronPreselect;
+      mutable unsigned int n_passDoubleElectronPreselect;
+      mutable unsigned int n_passSingleMuonPreselect;
+      mutable unsigned int n_passKinematic;
+      mutable unsigned int n_passQuality;
+      mutable unsigned int n_passIsolation;
+      mutable unsigned int n_passInvariantMass;
+      mutable unsigned int n_pass;
+
+
+      /////////////////////////////
+      ///// EVENT LEVEL QUANTITIES
+
+      mutable std::vector<const xAOD::Photon*> e_leadingPhotons;
+
+      mutable TLorentzVector leadPhotonLV;
+      mutable TLorentzVector sublPhotonLV;
+
+      mutable bool e_tot;
+      mutable bool e_passGRL;
+      mutable bool e_passLArError;
+      mutable bool e_passTrigger;
+      mutable bool e_passPreselect;
+      mutable bool e_passSingleElectronPreselect;
+      mutable bool e_passDoubleElectronPreselect;
+      mutable bool e_passSingleMuonPreselect;
+      mutable bool e_passKinematic;
+      mutable bool e_passQuality;
+      mutable bool e_passIsolation;
+      mutable bool e_passInvariantMass;
+      mutable bool e_pass;
+
+      mutable int    ph_pos_lead, ph_pos_subl;
+      mutable double ph_pt_lead, ph_eta_lead, ph_phi_lead, ph_e_lead;
+      mutable double ph_pt_subl, ph_eta_subl, ph_phi_subl, ph_e_subl;
+
+      mutable int    ph_tight_lead, ph_tight_subl;
+      mutable int    ph_iso_lead, ph_iso_subl;
+
+      mutable double e_invariantMass;
+      mutable double e_diphotonZ;
+
+      /////////////////////////////
+      ///// FUNCTIONS
+
+      static const double s_MZ;
+
+  }; 
+
+}
+
+#endif // DERIVATIONFRAMEWORK_SKIMMINGTOOLEXAMPLE_H

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/DerivationFrameworkHiggs/SkimmingToolHIGG2.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SkimmingToolHIGG2.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_SKIMMINGTOOLHSG2_H
+#define DERIVATIONFRAMEWORK_SKIMMINGTOOLHSG2_H 1
+
+#include<string>
+#include<vector>
+#include<map>
+
+// Gaudi & Athena basics
+#include "AthenaBaseComps/AthAlgTool.h"
+
+// DerivationFramework includes
+#include "DerivationFrameworkInterfaces/ISkimmingTool.h"
+
+// xAOD header files
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+#include "xAODJet/JetContainer.h"
+#include "xAODMuon/MuonContainer.h"
+
+#include "TrigDecisionTool/TrigDecisionTool.h"
+
+namespace DerivationFramework {
+
+  /** @class SkimmingToolHIGG2
+      @author Susumu.Oda@cern.ch
+     */
+  class SkimmingToolHIGG2 : public AthAlgTool, public ISkimmingTool {
+    
+  public: 
+    /** Constructor with parameters */
+    SkimmingToolHIGG2( const std::string& t, const std::string& n, const IInterface* p );
+    
+    /** Destructor */
+    ~SkimmingToolHIGG2();
+    
+    // Athena algtool's Hooks
+    StatusCode  initialize();
+    StatusCode  finalize();
+    
+    /** Check that the current event passes this filter */
+    virtual bool eventPassesFilter() const;
+    
+  private:
+    enum {
+      NUMBER_OF_MERGED_JET_TYPES = 3
+    };
+
+    ToolHandle<Trig::TrigDecisionTool> m_trigDecisionTool;
+
+    mutable unsigned int m_ntot;
+    mutable unsigned int m_npass;
+
+    bool m_skipTriggerRequirement;
+
+    mutable std::vector<const xAOD::Electron*> m_goodElectrons;
+    mutable std::vector<const xAOD::Muon*> m_goodMuons;
+    mutable std::vector<const xAOD::Jet*> m_goodJets;
+    mutable std::vector<const xAOD::Jet*> m_goodMergedJets[NUMBER_OF_MERGED_JET_TYPES];
+    mutable std::vector<const xAOD::Photon*> m_goodPhotons;
+    mutable std::vector<const xAOD::TrackParticle*> m_goodTracks;
+
+    std::string m_filterType;
+
+    std::string m_electronSGKey;
+    std::string m_muonSGKey;
+    std::string m_jetSGKey;
+    std::string m_mergedJetSGKey[NUMBER_OF_MERGED_JET_TYPES];
+    std::string m_photonSGKey;
+    std::string m_trackSGKey;
+
+    unsigned int m_nLeptons;
+    unsigned int m_nElectrons;
+    unsigned int m_nMuons;
+    unsigned int m_nJets;
+    unsigned int m_nMergedJets[NUMBER_OF_MERGED_JET_TYPES];
+    unsigned int m_nPhotons;
+    unsigned int m_nTracks;
+
+    std::string m_electronQual;
+    std::string m_muonQual;
+    std::string m_tightMuonQual;
+    std::string m_tightElectronQual;
+    std::string m_jetQual;
+    std::string m_mergedJetQual[NUMBER_OF_MERGED_JET_TYPES];
+    std::string m_photonQual;
+
+    std::string m_primaryElectronQual4L;
+
+    std::vector<std::string> m_trigger2L;
+    std::vector<std::string> m_triggerTP;
+    std::vector<std::string> m_trigger2L2Q;
+    std::vector<std::string> m_triggerJPSI;
+    std::vector<std::string> m_triggerPHI;
+
+    double m_electronEtCut;
+    double m_muonPtCut;
+    double m_tightElectronEtCut;
+    double m_tightMuonPtCut;
+    double m_jetPtCut;
+    double m_mergedJetPtCut[NUMBER_OF_MERGED_JET_TYPES];
+    double m_photonPtCut;
+    double m_trackPtCut;
+
+    double m_electronEtaCut;
+    double m_muonEtaCut;
+    double m_caloMuonEtaCut;
+    double m_jetEtaCut;
+    double m_mergedJetEtaCut[NUMBER_OF_MERGED_JET_TYPES];
+    double m_photonEtaCut;
+
+    double m_invariantMassCut;
+    double m_invariantMassJpsiLowCut;
+    double m_invariantMassJpsiUpCut;
+    double m_invariantMassUpsilonLowCut;
+    double m_invariantMassUpsilonUpCut;
+    double m_invariantMassPhiLowCut;
+    double m_invariantMassPhiUpCut;
+
+    double m_leadingElectronEtCut;
+    double m_leadingMuonPtCut;
+
+    double m_dRElectronJetCut;
+
+    bool m_checkLArError;
+    bool m_defaultElectronFourMomentum; 
+
+    //    bool m_DFCommonElectronFourMomentum; 
+    //    mutable std::map<const xAOD::Electron*, unsigned int> m_mapElectrons;
+    //    mutable const std::vector<float> *m_DFCommonElectrons_pt;
+    //    mutable const std::vector<float> *m_DFCommonElectrons_eta;
+    //    mutable const std::vector<float> *m_DFCommonElectrons_phi;
+
+    bool m_DFCommonJetFourMomentum; 
+
+    bool m_requireTightLeptons;
+
+    bool checkElectronQuality(const xAOD::Electron *el, const bool isTight=false) const;
+    bool checkMuonQuality(const xAOD::Muon *mu, const bool isTight=false) const;
+    bool checkJetQuality(const xAOD::Jet *jet) const;
+    bool checkMergedJetQuality(const xAOD::Jet *jet, const unsigned int type) const;
+    bool checkPhotonQuality(const xAOD::Photon *ph) const;
+    bool checkTrackQuality(const xAOD::TrackParticle *trk) const;
+
+    bool check2L() const;
+    bool check4L() const;
+    bool checkTP() const;
+    bool check2L2Q() const;
+    bool checkJPSI() const;
+    bool checkPHI() const;
+
+    TLorentzVector electronFourMomentum(const xAOD::Electron *el) const;
+    TLorentzVector muonFourMomentum(const xAOD::Muon *mu) const;
+    TLorentzVector jetFourMomentum(const xAOD::Jet *jet) const;
+
+    double getDeltaR(const double eta1, const double phi1, const double eta2, const double phi2) const; 
+
+    static const double s_MZ;
+    static const double s_MKplus;
+  }; 
+  
+}
+
+#endif // DERIVATIONFRAMEWORK_SKIMMINGTOOLEXAMPLE_H

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/DerivationFrameworkHiggs/SkimmingToolHIGG5VBF.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SkimmingToolHIGG5VBF.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_SKIMMINGTOOLHSG5VBF_H
+#define DERIVATIONFRAMEWORK_SKIMMINGTOOLHSG5VBF_H
+
+#include<string>
+#include<vector>
+
+// Gaudi & Athena basics
+#include "AthenaBaseComps/AthAlgTool.h"
+
+// DerivationFramework includes
+#include "DerivationFrameworkInterfaces/ISkimmingTool.h"
+
+// xAOD header files
+#include "xAODJet/JetContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+#include "TrigDecisionTool/TrigDecisionTool.h"
+
+class TLoretzVector;
+
+namespace DerivationFramework {
+
+
+  /** @class SkimmingToolHIGG5VBF
+      @author Yasuyuki.Okumura@cern.ch
+     */
+  class SkimmingToolHIGG5VBF : public AthAlgTool, public ISkimmingTool {
+    
+  public:
+    /** Constructor with parameters */
+    SkimmingToolHIGG5VBF( const std::string& t, const std::string& n, const IInterface* p );
+    
+    /** Destructor */
+    ~SkimmingToolHIGG5VBF();
+
+    // Athena algtool's Hooks
+    StatusCode  initialize();
+    StatusCode  finalize();
+    
+    /** Check that the current event passes this filter */
+    virtual bool eventPassesFilter() const;
+    
+  private:
+    bool m_debug;
+
+    ToolHandle<Trig::TrigDecisionTool> m_trigDecisionTool;
+    
+    mutable unsigned int m_ntot;
+    mutable unsigned int m_npass;
+    
+    mutable std::vector<TLorentzVector> m_goodAllJets;
+    mutable std::vector<TLorentzVector> m_goodCentralJets;
+    
+    std::string m_jetSGKey;
+    std::string m_calibedJetMomKey;
+    
+    // for jet multiplicity
+    bool         m_reqNAllJets;
+    unsigned int m_nAllJets;
+    double       m_allJetPtCut;
+    double       m_allJetEtaCut;
+
+    bool         m_reqNCentralJets;
+    unsigned int m_nCentralJets;
+    double       m_centralJetPtCut;
+    double       m_centralJetEtaCut;
+
+    // for trigger
+    bool                     m_reqTrigger;
+    std::vector<std::string> m_triggers;
+    
+    // for Mjj
+    bool   m_reqVbfMjj;
+    double m_vbfMjjCut;
+    
+    bool checkAllJetQuality(const TLorentzVector& jet) const;
+    bool checkCentralJetQuality(const TLorentzVector& jet) const;
+    TLorentzVector getCalibedJets(const xAOD::Jet* jet) const;
+    
+    //for photon (p. rose)
+    std::string m_phSGKey;
+    bool m_reqPh;
+    double m_phPtCut;
+    double m_centralPhEtaCut;
+  };
+  
+}
+
+#endif // #ifndef DERIVATIONFRAMEWORK_SKIMMINGTOOLHSG5VBF_H

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/cmt/requirements

+package DerivationFrameworkHiggs
+author James Catmore <james.catmore@cern.ch>
+
+#################################################################
+# public use statements
+use AtlasPolicy                   AtlasPolicy-*
+use AthenaBaseComps               AthenaBaseComps-*               Control
+use DerivationFrameworkInterfaces DerivationFrameworkInterfaces-* PhysicsAnalysis/DerivationFramework
+use TrigDecisionTool              TrigDecisionTool-*              Trigger/TrigAnalysis
+use xAODEgamma                    xAODEgamma-*                    Event/xAOD
+use xAODJet                       xAODJet-*                       Event/xAOD
+use xAODMuon                      xAODMuon-*                      Event/xAOD
+
+private
+use AtlasCLHEP                    AtlasCLHEP-*                    External
+use GaudiInterface                GaudiInterface-*                External
+use xAODEventInfo                 xAODEventInfo-*                 Event/xAOD
+use xAODTracking                  xAODTracking-*                  Event/xAOD
+
+#################################################################
+#
+public
+
+## declare the directories CMT should know about
+branches python share src
+
+apply_pattern dual_use_library files= " *.cxx "
+apply_pattern declare_joboptions files=" *.py"
+apply_pattern declare_python_modules files="*.py"

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG2D1ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#Content included in addition to the Smart Slimming Content
+
+HIGG2D1ExtraContent=[
+    "egammaClusters.rawE.phi_sampl.calM",
+    "GSFTrackParticles.expectNextToInnermostPixelLayerHit.numberOfNextToInnermostPixelLayerHits.numberOfNextToInnermostPixelLayerOutliers",
+    "Muons.quality.etcone20.ptconecoreTrackPtrCorrection",
+    "ExtrapolatedMuonTrackParticles.numberOfTRTHits.numberOfTRTOutliers",
+    "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m"
+    ]
+
+HIGG2D1ExtraContentTruth=[
+    ]
+
+HIGG2D1ExtraContainers=[
+    "MuonClusterCollection",
+    "MET_Track",
+    "CaloCalTopoClusters"]
+
+HIGG2D1ExtraContainersTruth=[
+    "TruthEvents",
+    "TruthParticles",
+    "TruthVertices",
+    "AntiKt4TruthJets",
+    "MuonTruthParticles"]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG2D2ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#Content included in addition to the Smart Slimming Content
+
+HIGG2D2ExtraContent=[
+    "egammaClusters.rawE.phi_sampl.calM",
+    "GSFTrackParticles.expectNextToInnermostPixelLayerHit.numberOfNextToInnermostPixelLayerHits.numberOfNextToInnermostPixelLayerOutliers",
+    "Muons.quality.etcone20.ptconecoreTrackPtrCorrection",
+    "ExtrapolatedMuonTrackParticles.numberOfTRTHits.numberOfTRTOutliers",
+    "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m"
+    ]
+
+HIGG2D2ExtraContentTruth=[
+    ]
+
+HIGG2D2ExtraContainers=[
+    "MuonClusterCollection",
+    "MET_Track",
+    "CaloCalTopoClusters"]
+
+HIGG2D2ExtraContainersTruth=[
+    "TruthEvents",
+    "TruthParticles",
+    "TruthVertices",
+    "AntiKt4TruthJets",
+    "MuonTruthParticles"]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG2D3ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#Content included in addition to the Smart Slimming Content
+
+HIGG2D3ExtraContent=[
+    "egammaClusters.rawE.phi_sampl.calM",
+    "GSFTrackParticles.expectNextToInnermostPixelLayerHit.numberOfNextToInnermostPixelLayerHits.numberOfNextToInnermostPixelLayerOutliers",
+    "Muons.quality.etcone20",
+    "ExtrapolatedMuonTrackParticles.numberOfTRTHits.numberOfTRTOutliers",
+    "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m"
+    ]
+
+HIGG2D3ExtraContentTruth=[
+    ]
+
+HIGG2D3ExtraContainers=[
+    "MET_Track"]
+
+HIGG2D3ExtraContainersTruth=[
+    "TruthEvents",
+    "TruthParticles",
+    "TruthVertices",
+    "AntiKt4TruthJets",
+    "MuonTruthParticles"]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG2D4ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#Content included in addition to the Smart Slimming Content
+
+HIGG2D4ExtraContent=[
+    "egammaClusters.rawE.phi_sampl.calM",
+    "GSFTrackParticles.expectNextToInnermostPixelLayerHit.numberOfNextToInnermostPixelLayerHits.numberOfNextToInnermostPixelLayerOutliers",
+    "Muons.quality.etcone20.etcone30.etcone40",
+    "ExtrapolatedMuonTrackParticles.numberOfTRTHits.numberOfTRTOutliers",
+    "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m.GhostTrackCount.TrackWidthPt500",
+    "AntiKt4EMTopoJets.DFCommonJets_Calib_pt.DFCommonJets_Calib_eta.DFCommonJets_Calib_phi.DFCommonJets_Calib_m",
+    "AntiKt4LCTopoJets.TrackWidthPt500.TrackCount.GhostTrackCount"]
+
+HIGG2D4ExtraContentTruth=[
+    ]
+
+HIGG2D4ExtraContainers=[
+    "BTagging_AntiKt3Track",
+    "BTagging_AntiKt2Track"]
+
+HIGG2D4ExtraContainersTruth=[
+    "TruthEvents",
+    "TruthParticles",
+    "TruthVertices",
+    "MuonTruthParticles"]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG2D5ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#Content included in addition to the Smart Slimming Content
+
+HIGG2D5ExtraContent=[
+    "egammaClusters.rawE.phi_sampl.calM",
+    "GSFTrackParticles.expectNextToInnermostPixelLayerHit.numberOfNextToInnermostPixelLayerHits.numberOfNextToInnermostPixelLayerOutliers",
+    "Muons.quality.etcone20",
+    "ExtrapolatedMuonTrackParticles.numberOfTRTHits.numberOfTRTOutliers",
+    "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m"
+    ]
+
+HIGG2D5ExtraContentTruth=[
+    ]
+
+HIGG2D5ExtraContainers=[
+    "MET_Track"]
+
+HIGG2D5ExtraContainersTruth=[
+    "TruthEvents",
+    "TruthParticles",
+    "TruthVertices",
+    "AntiKt4TruthJets",
+    "MuonTruthParticles"]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG3D1ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+
+# The additional HIGG3D1 content lists
+
+HIGG3D1ExtraVariables = [ "GSFTrackParticles.z0.vz",
+                          "CombinedMuonTrackParticles.z0.vz",
+                          "ExtrapolatedMuonTrackParticles.z0.vz",
+                          "Muons.clusterLink.extrapolatedMuonSpectrometerTrackParticleLink",
+                          "Electrons.author",
+                          "AntiKt4LCTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m.Jvt.JvtJvfcorr.JvtRpt",
+                          "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m.Jvt.JvtJvfcorr.JvtRpt",
+                          "AntiKt4PV0TrackJets.pt.eta.phi.m.constituentLinks.constituentWeights.btaggingLink",
+                          "AntiKt2PV0TrackJets.pt.eta.phi.m.constituentLinks.constituentWeights.btaggingLink"]
+
+HIGG3D1ExtraTruthVariables = [ "Electrons.truthOrigin.truthType.truthParticleLink.bkgTruthType.bkgMotherPdgId.bkgTruthOrigin",
+                               "AntiKt4LCTopoJets.ConeTruthLabelID.PartonTruthLabelID",
+                               "AntiKt4EMTopoJets.ConeTruthLabelID.PartonTruthLabelID",
+                               "InDetTrackParticles.truthOrigin.truthType",
+                               "AntiKt4PV0TrackJets.TruthLabelDeltaR_B.TruthLabelDeltaR_C.TruthLabelDeltaR_T.GhostTruth.GhostTruthCount.GhostTruthPt.HadronConeExclTruthLabelID.PartonTruthLabelID.ConeTruthLabelID",
+                               "AntiKt2PV0TrackJets.TruthLabelDeltaR_B.TruthLabelDeltaR_C.TruthLabelDeltaR_T.GhostTruth.GhostTruthCount.GhostTruthPt.HadronConeExclTruthLabelID.PartonTruthLabelID.ConeTruthLabelID"]
+
+HIGG3D1ExtraContainers = [ ]
+
+HIGG3D1ExtraTruthContainers = [ "TruthEvents",
+                                "TruthParticles",
+                                "TruthVertices",
+                                "AntiKt4TruthJets",
+                                "MuonTruthParticles" ]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG3D2ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+
+# The additional HIGG3D2 content lists
+
+HIGG3D2ExtraVariables = [ "PrimaryVertices.vertexType" ]
+
+HIGG3D2ExtraTruthContainers = [ "TruthEvents",
+                                "AntiKt4TruthJets",
+                                "TruthParticles" ]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG3D3ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+
+# The additional HIGG3D3 content lists
+
+HIGG3D3ExtraVariables = [ "GSFTrackParticles.z0.vz",
+                          "CombinedMuonTrackParticles.z0.vz",
+                          "ExtrapolatedMuonTrackParticles.z0.vz",
+                          "Muons.clusterLink.extrapolatedMuonSpectrometerTrackParticleLink",
+                          "Electrons.author",
+                          "AntiKt4LCTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m.Jvt.JvtJvfcorr.JvtRpt",
+                          "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m.Jvt.JvtJvfcorr.JvtRpt" ]
+
+HIGG3D3ExtraTruthVariables = [ "Electrons.truthOrigin.truthType.truthParticleLink",
+                               "AntiKt4LCTopoJets.ConeTruthLabelID.PartonTruthLabelID",
+                               "AntiKt4EMTopoJets.ConeTruthLabelID.PartonTruthLabelID" ]
+
+HIGG3D3ExtraContainers = [ ]
+
+HIGG3D3ExtraTruthContainers = [ "TruthEvents",
+                                "TruthParticles",
+                                "TruthVertices",
+                                "AntiKt4TruthJets",
+                                "MuonTruthParticles" ]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG4DxAugmentation.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#################################################
+# Common code used for the HIGG4 augmentation  	#
+# Z.Zinonos					#
+# zenon@cern.ch					#
+# Nov 2015					#
+#################################################
+
+from AthenaCommon.GlobalFlags import globalflags
+# running on data or MC
+DFisMC = (globalflags.DataSource()=='geant4')
+
+def setup(HIGG4DxName, ToolSvc):
+
+    augmentationTools=[]
+
+    # DELTA R TOOL
+    from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__DeltaRTool
+    HIGG4DxTauJetsElectronsDeltaRTool = DerivationFramework__DeltaRTool(  name                    = "HIGG4DxTauJetsElectronsDeltaRTool",
+                                                                          ContainerName           = "Electrons",
+                                                                          SecondContainerName     = "TauJets",
+                                                                          StoreGateEntryName      = "HIGG4DxTauJetsElectronsDeltaR")
+    ToolSvc += HIGG4DxTauJetsElectronsDeltaRTool
+    augmentationTools.append(HIGG4DxTauJetsElectronsDeltaRTool)
+
+    # TAU SELECTOR TOOL
+    from DerivationFrameworkTau.DerivationFrameworkTauConf import DerivationFramework__TauSelectionWrapper
+    HIGG4DxJetBDTSigMediumSelectionWrapper = DerivationFramework__TauSelectionWrapper( name                    = "HIGG4DxJetBDTSigMediumSelectionWrapper",
+                                                                                       #IsTauFlag              = IsTauFlag.JetBDTSigMedium,
+                                                                                       IsTauFlag               = 20,
+                                                                                       CollectionName          = "TauJets",
+                                                                                       StoreGateEntryName      = "HIGG4DxJetBDTSigMedium")
+    ToolSvc += HIGG4DxJetBDTSigMediumSelectionWrapper
+    augmentationTools.append(HIGG4DxJetBDTSigMediumSelectionWrapper)
+
+    HIGG4DxJetBDTSigLooseSelectionWrapper = DerivationFramework__TauSelectionWrapper( name                   = "HIGG4DxJetBDTSigLooseSelectionWrapper",
+                                                                                     IsTauFlag               = 19,
+                                                                                     CollectionName          = "TauJets",
+                                                                                     StoreGateEntryName      = "HIGG4DxJetBDTSigLoose")
+    ToolSvc += HIGG4DxJetBDTSigLooseSelectionWrapper
+    augmentationTools.append(HIGG4DxJetBDTSigLooseSelectionWrapper)
+
+
+
+    # Tau primary vertex refit
+    if HIGG4DxName == "HIGG4D3":
+        from DerivationFrameworkTau.DerivationFrameworkTauConf import DerivationFramework__TauPVTrkSelectionTool
+        HIGG4DxTauPVTrkSelectionTool = DerivationFramework__TauPVTrkSelectionTool( name = "HIGG4DxTauPVTrkSelectionTool",
+                                                                                   #minPt = 15000,
+                                                                                   #m_maxDeltaR = 0.2,
+                                                                                   UseTrueTracks = DFisMC,
+                                                                                   TauContainerName = "TauJets",
+                                                                                   TauPVTracksContainerName = "TauPVTracks")
+        ToolSvc += HIGG4DxTauPVTrkSelectionTool
+        augmentationTools.append(HIGG4DxTauPVTrkSelectionTool)
+
+        from DerivationFrameworkTau.DerivationFrameworkTauConf import DerivationFramework__TauPVRefitTool
+        HIGG4DxTauPVRefittingTool = DerivationFramework__TauPVRefitTool( name = "HIGG4DxTauPVRefittingTool",
+                                                                         PVLinkName = "PVLink",
+                                                                         RefittedLinkName = "TauRefittedPVLink",
+                                                                         PVContainerName = "PrimaryVertices",
+                                                                         TauTrkContainerName = "TauPVTracks",
+                                                                         PVRefContainerName = "TauRefittedPrimaryVertices")
+        ToolSvc += HIGG4DxTauPVRefittingTool
+        augmentationTools.append(HIGG4DxTauPVRefittingTool)
+
+    if DFisMC:
+   	# Tau truth matching 
+        from TauAnalysisTools.TauAnalysisToolsConf import TauAnalysisTools__TauTruthMatchingTool
+        HIGG4DxTauTruthMatchingTool = TauAnalysisTools__TauTruthMatchingTool(name="HIGG4DxTauTruthMatchingTool",
+                                                                             WriteTruthTaus = True)
+        
+        ToolSvc += HIGG4DxTauTruthMatchingTool
+
+   	# Tau truth matching wrapper 
+        from DerivationFrameworkTau.DerivationFrameworkTauConf import DerivationFramework__TauTruthMatchingWrapper
+        HIGG4DxTauTruthMatchingWrapper = DerivationFramework__TauTruthMatchingWrapper( name = "HIGG4DxTauTruthMatchingWrapper",
+                                                                                TauTruthMatchingTool = HIGG4DxTauTruthMatchingTool)
+        
+        ToolSvc += HIGG4DxTauTruthMatchingWrapper
+        augmentationTools.append(HIGG4DxTauTruthMatchingWrapper)
+
+
+    #Tau Overlapping Electron LLH Decorator
+    from TauAnalysisTools.TauAnalysisToolsConf import TauAnalysisTools__TauOverlappingElectronLLHDecorator
+    HIGG4DxTauOrlElLLHDec = TauAnalysisTools__TauOverlappingElectronLLHDecorator(name="HIGG4DxTauOrlElLLHDec",
+                                                                                 ElectronContainerName = "Electrons")
+    
+    ToolSvc += HIGG4DxTauOrlElLLHDec
+        
+    #Tau Overlapping Electron LLH Decorator Wrapper
+    from DerivationFrameworkTau.DerivationFrameworkTauConf import DerivationFramework__TauOverlappingElectronLLHDecoratorWrapper
+    HIGG4DxTauOrlElLLHDecWrapper = DerivationFramework__TauOverlappingElectronLLHDecoratorWrapper( name = "HIGG4DxTauOrlElLLHDecWrapper",
+                                                                                                   TauOverlappingElectronLLHDecorator = HIGG4DxTauOrlElLLHDec,
+                                                                                                   TauContainerName     = "TauJets")
+    
+    ToolSvc += HIGG4DxTauOrlElLLHDecWrapper
+    augmentationTools.append(HIGG4DxTauOrlElLLHDecWrapper)
+
+    #=============
+    # return tools
+    #=============
+    return augmentationTools
+

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG4DxJets.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#################################################################
+# Common code used for the HIGG4 jet building and calibration   #
+# Z.Zinonos                                     		#
+# zenon@cern.ch                                 		#
+# Nov 2015                                      		#
+#################################################################
+
+from DerivationFrameworkJetEtMiss.JetCommon import *
+from DerivationFrameworkJetEtMiss.ExtendedJetCommon import *
+
+def setup(HIGG4DxName, HIGG4DxSequence, HIGG4DxSlimmingHelper):
+
+#    if not DAOD_StreamID+"Jets" in OutputJets:
+    
+        # add a small-R collection
+#        OutputJets[DAOD_StreamID+"Jets"] = ["AntiKt2PV0TrackJets"]
+
+    	# schedule reconstruction of AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets 
+#        addTrimmedJets("AntiKt", 1.0, "LCTopo", rclus=0.2, ptfrac=0.05, algseq=DerivationFrameworkJob)
+#        OutputJets[DAOD_StreamID+"Jets"].append("AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets")
+#        print "HELLO HERE", OutputJets[DAOD_StreamID+"Jets"]
+    
+    jet_collection = HIGG4DxName+"Jets"
+    if not jet_collection in OutputJets:
+        # AntiKt10*PtFrac5Rclus20 jets
+        if HIGG4DxName in ['HIGG4D2', 'HIGG4D3']:
+            addDefaultTrimmedJets(HIGG4DxSequence, jet_collection, False)
+
+        if HIGG4DxName in ['HIGG4D2', 'HIGG4D3']:
+            OutputJets[jet_collection].append("AntiKt2PV0TrackJets")
+

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG4DxSkimming.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#################################################
+# Common code used for the HIGG4 skimming       #
+# Z.Zinonos                                     #
+# zenon@cern.ch                                 #
+# Nov 2015                                      #
+#################################################
+
+from AthenaCommon.GlobalFlags import globalflags
+
+def setup(HIGG4DxName, ToolSvc):
+
+    skimmingTools = []
+
+    if HIGG4DxName == 'HIGG4D1':
+        muonLead = "(Muons.pt > 13.0*GeV) && (Muons.DFCommonGoodMuon)"
+        muonSubL = "(Muons.pt > 9.0*GeV) && (Muons.DFCommonGoodMuon)"
+        electron = "(Electrons.pt > 13.0*GeV) && ((Electrons.DFCommonElectronsIsEMMedium) || (Electrons.DFCommonElectronsLHMedium))"
+        count1 = "( count("+muonLead+") + count("+electron+") ) >=1"
+        count2 = "( count("+muonSubL+") + count("+electron+") ) >=2"
+        skim_expression = "("+count1+") && ("+count2+")"
+    elif HIGG4DxName == 'HIGG4D2':
+        #(pT(mu)>18 && pT(tau)>18) || (pT(mu)>12 && pT(tau)>23) 
+        #(pT(el)>22 && pT(tau)>18) || (pT(el)>15 && pT(tau)>23)
+        e15 = '(count((Electrons.pt > 15.0*GeV) && ((Electrons.DFCommonElectronsIsEMMedium)||(Electrons.DFCommonElectronsLHMedium))) >= 1)'
+        e22 = '(count((Electrons.pt > 22.0*GeV) && ((Electrons.DFCommonElectronsIsEMMedium)||(Electrons.DFCommonElectronsLHMedium))) >= 1)'
+        mu12 = '(count( (Muons.pt > 12.0*GeV) && Muons.DFCommonGoodMuon ) >= 1)'
+        mu18 = '(count( (Muons.pt > 18.0*GeV) && Muons.DFCommonGoodMuon ) >= 1)'
+        tau18 = '(count( (TauJets.pt > 18.0*GeV) && (abs(TauJets.charge)==1.0) && ((TauJets.nTracks == 1) || (TauJets.nTracks == 3)) ) >= 1)'
+        tau23 = '(count( (TauJets.pt > 23.0*GeV) && (abs(TauJets.charge)==1.0) && ((TauJets.nTracks == 1) || (TauJets.nTracks == 3)) ) >= 1)'
+        mutau = '('+mu18+' && '+tau18+') || ('+mu12+' && '+tau23+')'
+        etau = '('+e22+' && '+tau18+') || ('+e15+' && '+tau23+')'
+        skim_expression = '('+mutau+') || ('+etau+')'
+
+    elif HIGG4DxName == 'HIGG4D3':
+        tauTrks = '( (TauJets.nTracks + TauJets.nWideTracks >= 1) && (TauJets.nTracks + TauJets.nWideTracks <= 8) )'
+        tauLead = '(TauJets.pt > 33.0*GeV)'
+        tauSubl = '(TauJets.pt > 23.0*GeV)'
+        tauId   = 'HIGG4DxJetBDTSigLoose'
+        tauReq0 = '(count( '+tauSubl+' && '+tauTrks+' ) >= 2)'
+        tauReq1 = '(count( '+tauSubl+' && '+tauTrks+' && '+tauId+' ) >= 1)'
+        tauReq2 = '(count( '+tauLead+' && '+tauTrks+' ) >= 1)'
+        skim_expression = tauReq0 + '&&' + tauReq1 + '&&' + tauReq2
+	#skim_expression = tauReq0 + '&&' + tauReq2
+    elif HIGG4DxName == 'HIGG4D4':
+        ditau = '(count(((TauJets.nTracks == 1) || (TauJets.nTracks == 3)) && (TauJets.pt > 45.0*GeV)) >= 2)'
+        tau1 = '(count((TauJets.pt > 100.0*GeV)) >= 1)'
+        tau2 = '(count((TauJets.pt > 45.0*GeV)) >= 2)'
+        tauTrack = '(count(((TauJets.nTracks == 1) || (TauJets.nTracks == 3)) && (TauJets.pt > 45.0*GeV)) >= 1)'
+        #muonveto = '(count((Muons.pt > 15.0*GeV) && (Muons.DFCommonMuonsTight) && (abs(Muons.eta < 2.4))) == 0)'
+        #eleveto = '(count((Electrons.pt > 20.0*GeV) && (Electrons.DFCommonElectronsLHTight) && ((abs(Electrons.eta) < 1.3) || ((abs(Electrons.eta) > 1.6) && (abs(Electrons.eta) < 2.4)))) == 0)'
+        trigger = '( HLT_j15 || HLT_j25 || HLT_j35 || HLT_j55 || HLT_j60 || HLT_j85 || HLT_j110 || HLT_j150 || HLT_j175 || HLT_j200 || HLT_j260 || HLT_j300 || HLT_j320 || HLT_j360 || HLT_j380 || HLT_j400 || HLT_j420 || HLT_j440 || HLT_j460 || HLT_tau80_medium1_tracktwo_L1TAU60 || HLT_tau125_medium1_tracktwo || HLT_tau160_medium1_tracktwo || HLT_tau80_medium1_tracktwo_L1TAU60_tau50_medium1_tracktwo_L1TAU12 || HLT_tau35_medium1_tracktwo_tau25_medium1_tracktwo_L1TAU20IM_2TAU12IM)'
+        monotau =   '(count(((TauJets.nTracks == 1) || (TauJets.nTracks == 3)) && (TauJets.pt > 60.0*GeV)) >= 1)'
+        monotrigger = '( HLT_xe70 || HLT_j360 || HLT_j80_xe80 )'
+        mono_skim = '('+monotau+' && '+monotrigger+')'
+        DFisMC = (globalflags.DataSource()=='geant4')
+        if not DFisMC:
+            hadhad = '(((' + ditau + ') || (' + tau1 + ' && ' + tau2 + ' && ' + tauTrack + ')) && ' + trigger + ') || '+mono_skim
+        else:
+            hadhad = ditau + ' || '+mono_skim
+        skim_expression = hadhad
+    else:
+        assert False, "HIGG4DxSkimming: Unknown derivation stream '{}'".format(HIGG4DxName)
+
+    from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+    HIGG4DxSkimmingTool = DerivationFramework__xAODStringSkimmingTool( name 		= HIGG4DxName+"SkimmingTool",
+                                                                       expression 	= skim_expression)
+    ToolSvc += HIGG4DxSkimmingTool
+    skimmingTools.append(HIGG4DxSkimmingTool)
+
+    return skimmingTools

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG4DxSlimming.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#################################################
+# Common code used for the HIGG4 slimming       #
+# Z.Zinonos                                     #
+# zenon@cern.ch                                 #
+# Nov 2015                                      #
+#################################################
+
+
+def setup(HIGG4DxName, HIGG4DxStream, HIGG4DxSlimmingHelper):
+    from AthenaCommon.GlobalFlags import globalflags
+    DFisMC = (globalflags.DataSource()=='geant4')
+    
+    #HIGG4DxSlimmingHelper = SlimmingHelper(HIGG4DxName+"SlimmingHelper")
+
+    #smart slimming
+
+    if HIGG4DxName == 'HIGG4D4':
+        HIGG4DxSlimmingHelper.SmartCollections = ["Electrons",
+                                                  "Muons",
+                                                  "TauJets",
+                                                  "MET_Reference_AntiKt4EMTopo",
+                                                  "AntiKt4EMTopoJets",
+                                                  "BTagging_AntiKt4EMTopo",
+                                                  "InDetTrackParticles",
+                                                  "PrimaryVertices" ]
+    else:
+        HIGG4DxSlimmingHelper.SmartCollections = ["Electrons",
+                                                  "Photons",
+                                                  "Muons",
+                                                  "TauJets",
+                                                  "MET_Reference_AntiKt4EMTopo",
+                                                  "MET_Reference_AntiKt4LCTopo",
+                                                  "AntiKt4EMTopoJets",
+                                                  "AntiKt4LCTopoJets",
+                                                  "BTagging_AntiKt4EMTopo",
+                                                  "BTagging_AntiKt4LCTopo",
+                                                  "InDetTrackParticles",
+                                                  "PrimaryVertices" ]
+
+    #extra variables added to the smart slimming content
+    ExtraContentElectrons=[
+        "Electrons."
+        "LHLoose."
+        "LHMedium."
+        "LHTight."
+        "LHValue"
+        ]
+
+    ExtraElectronsTruth=[
+        "Electrons."
+        "truthOrigin."
+        "truthType."
+        "truthParticleLink"
+        ]
+
+    ExtraContentMuons=[
+        "Muons."
+        "quality."
+        "m"
+        ]
+
+    ExtraMuonsTruth=[
+        "MuonTruthParticles."
+        "truthOrigin."
+        "truthType"
+        ]
+
+    ExtraContentTaus=[
+        "TauJets."
+        "pantau_CellBasedInput_isPanTauCandidate."
+        "pantau_CellBasedInput_DecayMode."
+        "ptPanTauCellBased."
+        "etaPanTauCellBased."
+        "phiPanTauCellBased."
+        "mPanTauCellBased."
+        "pantau_CellBasedInput_BDTValue_1p0n_vs_1p1n."
+        "pantau_CellBasedInput_BDTValue_1p1n_vs_1pXn."
+        "pantau_CellBasedInput_BDTValue_3p0n_vs_3pXn"
+        ,
+        "TauNeutralParticleFlowObjects."
+        "pt."
+        "eta."
+        "phi."
+        "m."
+        "e."
+        "rapidity."
+        "bdtPi0Score"
+        ]
+
+    ExtraTausTruth = [
+        "TauJets.IsTruthMatched.truthParticleLink.truthJetLink.ele_match_lhscore.ele_olr_pass.electronLink"
+        ]
+    
+
+    if HIGG4DxName == 'HIGG4D3':
+        ExtraContentVtx=["PrimaryVertices.x.y.z.vertexType.TauRefittedPVLink"]
+    else:
+        ExtraContentVtx=["PrimaryVertices.x.y.z.vertexType"]
+
+    HIGG4DxSlimmingHelper.ExtraVariables = ExtraContentElectrons + ExtraContentMuons + ExtraContentTaus + ExtraContentVtx
+
+    if DFisMC:
+        HIGG4DxSlimmingHelper.ExtraVariables += ExtraElectronsTruth + ExtraMuonsTruth + ExtraTausTruth
+
+    #extra containers
+    if HIGG4DxName in ['HIGG4D2', 'HIGG4D3', 'HIGG4D4']:
+        HIGG4DxSlimmingHelper.AllVariables += ["LVL1JetRoIs"]
+        
+    if DFisMC:
+        HIGG4DxSlimmingHelper.AllVariables += ["TruthEvents", 
+                                               "TruthParticles", 
+                                               "TruthVertices", 
+                                               "AntiKt4TruthJets"]
+
+    #derivation truth
+    if DFisMC:
+
+        from DerivationFrameworkMCTruth.MCTruthCommon import *
+
+        HIGG4DxSlimmingHelper.StaticContent = ["xAOD::TruthParticleContainer#TruthMuons",
+                                               "xAOD::TruthParticleAuxContainer#TruthMuonsAux.",
+                                               "xAOD::TruthParticleContainer#TruthElectrons",
+                                               "xAOD::TruthParticleAuxContainer#TruthElectronsAux.",
+                                               #"xAOD::TruthParticleContainer#TruthPhotons",
+                                               #"xAOD::TruthParticleAuxContainer#TruthPhotonsAux.",
+                                               "xAOD::TruthParticleContainer#TruthNeutrinos",
+                                               "xAOD::TruthParticleAuxContainer#TruthNeutrinosAux.",
+                                               "xAOD::TruthParticleContainer#TruthTaus",
+                                               "xAOD::TruthParticleAuxContainer#TruthTausAux."]
+
+
+
+    #trigger content
+    if HIGG4DxName == 'HIGG4D1':
+        HIGG4DxSlimmingHelper.IncludeMuonTriggerContent = True
+        HIGG4DxSlimmingHelper.IncludeEGammaTriggerContent = True
+    elif HIGG4DxName == 'HIGG4D2':
+        HIGG4DxSlimmingHelper.IncludeMuonTriggerContent = True
+        HIGG4DxSlimmingHelper.IncludeEGammaTriggerContent = True
+        HIGG4DxSlimmingHelper.IncludeTauTriggerContent = True
+    elif HIGG4DxName == 'HIGG4D3':
+        HIGG4DxSlimmingHelper.IncludeTauTriggerContent = True
+    elif HIGG4DxName == 'HIGG4D4':
+        HIGG4DxSlimmingHelper.IncludeJetTriggerContent = True
+        HIGG4DxSlimmingHelper.IncludeTauTriggerContent = True
+    else:
+        assert False, "HIGG4DxSlimming: Unknown derivation stream '{}'".format(HIGG4DxName)
+
+    if HIGG4DxName in ['HIGG4D2', 'HIGG4D3']:
+        from DerivationFrameworkJetEtMiss.JetCommon import *
+        addJetOutputs(HIGG4DxSlimmingHelper, [HIGG4DxName+"Jets"])
+
+    # the very last line in job options
+    HIGG4DxSlimmingHelper.AppendContentToStream(HIGG4DxStream)
+
+    #add tau PV refitted results
+    if HIGG4DxName == 'HIGG4D3':
+        HIGG4DxStream.AddItem(['xAOD::VertexContainer#TauRefittedPrimaryVertices'])
+        HIGG4DxStream.AddItem(['xAOD::VertexAuxContainer#TauRefittedPrimaryVerticesAux.-vxTrackAtVertex'])
+
+
+
+    

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG4DxThinning.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#################################################
+# Common code used for the HIGG4 thinning       #
+# Z.Zinonos                                     #
+# zenon@cern.ch                                 #
+# Nov 2015                                      #
+#################################################
+
+from AthenaCommon.GlobalFlags import globalflags
+
+# running on data or MC
+DFisMC = (globalflags.DataSource()=='geant4')
+
+# trigger navigation
+def TriggerChains(HIGG4DxName):
+    if HIGG4DxName == 'HIGG4D1': 
+        return 'HLT_e.*|HLT_2e.*|HLT_mu.*|HLT_2mu.*'
+    elif HIGG4DxName == 'HIGG4D2': 
+        return 'HLT_e.*|HLT_mu.*'
+    elif HIGG4DxName in ['HIGG4D3', 'HIGG4D4']:
+        return 'HLT_tau.*'        
+    else :
+        assert False, "HIGG4DxThinning: Unknown derivation stream '{}'".format(HIGG4DxName)
+
+def setup(HIGG4DxName, HIGG4DxThinningSvc, ToolSvc):
+    thinningTools=[]
+
+    #jets and tracks
+    from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__JetTrackParticleThinning
+    HIGG4DxJetTPThinningTool = DerivationFramework__JetTrackParticleThinning( name          		= HIGG4DxName+"JetTPThinningTool",
+                                                                              ThinningService         	= HIGG4DxThinningSvc,
+                                                                              JetKey                  = "AntiKt4EMTopoJets",
+                                                                              SelectionString         = "AntiKt4EMTopoJets.pt > 18*GeV",
+                                                                              InDetTrackParticlesKey  = "InDetTrackParticles",
+                                                                              ApplyAnd                = True)
+    ToolSvc += HIGG4DxJetTPThinningTool
+    thinningTools.append(HIGG4DxJetTPThinningTool)
+    
+    HIGG4DxJetLCTPThinningTool = DerivationFramework__JetTrackParticleThinning( name                    = HIGG4DxName+"JetLCTPThinningTool",
+                                                                                ThinningService         = HIGG4DxThinningSvc,
+                                                                                JetKey                  = "AntiKt4LCTopoJets",
+                                                                                SelectionString         = "AntiKt4LCTopoJets.pt > 18*GeV",
+                                                                                InDetTrackParticlesKey  = "InDetTrackParticles",
+                                                                                ApplyAnd                = True)
+    ToolSvc += HIGG4DxJetLCTPThinningTool
+    thinningTools.append(HIGG4DxJetLCTPThinningTool)
+
+    #fat jets and track thinning
+    if HIGG4DxName in ['HIGG4D2', 'HIGG4D3']:
+        from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__JetTrackParticleThinning
+        HIGG4DxJetTrackThinningTool1 = DerivationFramework__JetTrackParticleThinning( name          	    = HIGG4DxName+"JetTrackThinningTool1",
+                                                                                      ThinningService        = HIGG4DxThinningSvc,
+                                                                                      JetKey                 = "AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets",
+                                                                                      SelectionString        = "AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets.pt > 150*GeV",
+                                                                                      InDetTrackParticlesKey = "InDetTrackParticles",
+                                                                                      ApplyAnd               = True)
+        ToolSvc += HIGG4DxJetTrackThinningTool1
+        thinningTools.append(HIGG4DxJetTrackThinningTool1)
+
+    if HIGG4DxName in ['HIGG4D2', 'HIGG4D3']:
+        from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__JetTrackParticleThinning
+        HIGG4DxJetTrackThinningTool2 = DerivationFramework__JetTrackParticleThinning( name          	    = HIGG4DxName+"JetTrackThinningTool2",
+                                                                                      ThinningService        = HIGG4DxThinningSvc,
+                                                                                      JetKey                 = "AntiKt2PV0TrackJets",
+                                                                                      SelectionString        = "AntiKt2PV0TrackJets.pt > 6*GeV",
+                                                                                      InDetTrackParticlesKey = "InDetTrackParticles",
+                                                                                      ApplyAnd               = True)
+        #ToolSvc += HIGG4DxJetTrackThinningTool2
+        #thinningTools.append(HIGG4DxJetTrackThinningTool2)
+
+    # Tracks associated with Muons
+    HIGG4DxMuonSelectionString = ""
+    if HIGG4DxName in ['HIGG4D3', 'HIGG4D4']:
+        HIGG4DxMuonSelectionString = "Muons.pt > 1*GeV"
+    from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+    HIGG4DxMuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name                    = HIGG4DxName+"MuonTPThinningTool",
+                                                                               ThinningService         = HIGG4DxThinningSvc,
+                                                                               MuonKey                 = "Muons",
+                                                                               SelectionString 	       = HIGG4DxMuonSelectionString,
+                                                                               InDetTrackParticlesKey  = "InDetTrackParticles")
+    ToolSvc += HIGG4DxMuonTPThinningTool
+    thinningTools.append(HIGG4DxMuonTPThinningTool)
+
+    # Tracks associated with Electrons
+    HIGG4DxElectronSelectionString = ""
+    if HIGG4DxName in ['HIGG4D3', 'HIGG4D4']:
+        HIGG4DxElectronSelectionString = "Electrons.pt > 1*GeV"
+    from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__EgammaTrackParticleThinning
+    HIGG4DxElectronTPThinningTool = DerivationFramework__EgammaTrackParticleThinning(name                    = HIGG4DxName+"ElectronTPThinningTool",
+                                                                                     ThinningService         = HIGG4DxThinningSvc,
+                                                                                     SGKey                   = "Electrons",
+                                                                                     SelectionString 	     = HIGG4DxElectronSelectionString,
+                                                                                     InDetTrackParticlesKey  = "InDetTrackParticles")
+    ToolSvc += HIGG4DxElectronTPThinningTool
+    thinningTools.append(HIGG4DxElectronTPThinningTool)
+
+    # Tracks associated with taus
+    HIGG4DxTauSelectionString = "TauJets.pt > 18*GeV"
+    if HIGG4DxName == 'HIGG4D4':
+        HIGG4DxTauSelectionString = "TauJets.pt > 40*GeV"
+    from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__TauTrackParticleThinning
+    HIGG4DxTauTPThinningTool = DerivationFramework__TauTrackParticleThinning(name                    = HIGG4DxName+"TauTPThinningTool",
+                                                                             ThinningService         = HIGG4DxThinningSvc,
+                                                                             TauKey                  = "TauJets",
+                                                                             SelectionString         = HIGG4DxTauSelectionString,
+                                                                             ConeSize                = 0.6,
+                                                                             InDetTrackParticlesKey  = "InDetTrackParticles")
+    ToolSvc += HIGG4DxTauTPThinningTool
+    thinningTools.append(HIGG4DxTauTPThinningTool)
+
+
+    #Truth tau/nutau and their ancestors and descendants
+    truth_cond_tau = "((abs(TruthParticles.pdgId) == 15 || abs(TruthParticles.pdgId) == 16) && (TruthParticles.pt > 0.01*GeV) && (TruthParticles.barcode<200000))"
+    truth_cond_lep = "((abs(TruthParticles.pdgId) >= 11 && abs(TruthParticles.pdgId) <= 14) && (TruthParticles.pt > 4.0*GeV) && (TruthParticles.status == 1) && (TruthParticles.barcode<200000))"
+    truth_cond_comb = "("+truth_cond_lep+"||"+truth_cond_tau+")"
+
+    #truth_photon_thinning = "(TruthPhotons.pt > 1.0*GeV) && (abs(TruthPhotons.eta)<3.0)"
+    # PreserveGeneratorDescendants only keeps particles that came directly from the event generator
+    # PreserveDescendants keeps all particles including those that come from Geant processes
+
+    if DFisMC:
+    	#thin special containers
+        from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+    	#thin taus
+        HIGG4DxTruthTool_TAU = DerivationFramework__GenericTruthThinning(name                         = HIGG4DxName+"TruthTool_TAU",
+                                                                         ThinningService              = HIGG4DxThinningSvc,
+                                                                         ParticleSelectionString      = truth_cond_tau,
+                                                                         PreserveDescendants          = False,
+                                                                         PreserveGeneratorDescendants = True,
+                                                                         PreserveAncestors            = False,
+                                                                         TauHandling                  = False)
+        ToolSvc += HIGG4DxTruthTool_TAU
+        thinningTools.append(HIGG4DxTruthTool_TAU)
+
+	#thin leptons and taus
+        HIGG4DxTruthTool_COMB = DerivationFramework__GenericTruthThinning(name                         = HIGG4DxName+"TruthTool_COMB",
+                                                                          ThinningService              = HIGG4DxThinningSvc,
+                                                                          ParticleSelectionString      = truth_cond_comb,
+                                                                          PreserveDescendants          = False,
+                                                                          PreserveGeneratorDescendants = False,
+                                                                          PreserveAncestors            = True,
+                                                                          TauHandling                  = False)
+
+        ToolSvc += HIGG4DxTruthTool_COMB
+        thinningTools.append(HIGG4DxTruthTool_COMB)
+
+    	#thin photons
+        """HIGG4DxTruthTool_PHO = DerivationFramework__GenericTruthThinning(name                    = "HIGG4DxTruthTool_PHO",
+                                                                     ThinningService         = HIGG4DxThinningHelper.ThinningSvc(),
+                                                                     ParticlesKey            = "TruthPhotons",
+                                                                     ParticleSelectionString = truth_photon_thinning)
+    
+                                                                     ToolSvc += HIGG4DxTruthTool_PHO
+                                                                     thinningTools.append(HIGG4DxTruthTool_PHO)"""
+
+    	#thinning the master truth collection
+        from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__MenuTruthThinning
+        HIGG4DxTruthTool_MENU = DerivationFramework__MenuTruthThinning(  name 			    = HIGG4DxName+"TruthTool_MENU",
+                                                                         ThinningService 	    = HIGG4DxThinningSvc,
+                                                                         WritePartons               = False,
+                                                                         WriteHadrons               = False,
+                                                                         WriteBHadrons              = False,
+                                                                         WriteGeant                 = False,
+                                                                         GeantPhotonPtThresh        = -1.0,
+                                                                         WriteTauHad                = False,
+                                                                         PartonPtThresh             = -1.0,
+                                                                         WriteBSM                   = False,
+                                                                         WriteBosons                = False,
+                                                                         WriteBSMProducts           = False,
+                                                                         WriteBosonProducts         = False,
+                                                                         WriteTopAndDecays          = False,
+                                                                         WriteEverything            = False,
+                                                                         WriteAllLeptons            = False,
+                                                                         WriteStatus3               = False,
+                                                                         PreserveDescendants        = False,
+                                                                         PreserveGeneratorDescendants = False,
+                                                                         PreserveAncestors          = True,
+                                                                         WriteFirstN                = 15)
+
+        ToolSvc += HIGG4DxTruthTool_MENU
+        thinningTools.append(HIGG4DxTruthTool_MENU)
+    #end of MC
+
+    # return thinning tools
+    return thinningTools
+

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG5D1ContentList.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+HIGG5D1Content = [
+### Event info
+"xAOD::EventInfo_v1#EventInfo",
+"xAOD::EventAuxInfo_v1#EventInfoAux.",
+"PileUpEventInfo#McEventInfo",
+### Electron
+"xAOD::ElectronContainer_v1#ElectronCollection",
+"xAOD::ElectronAuxContainer#ElectronCollectionAux.",
+"xAOD::ElectronContainer_v1#FwdElectrons",        ### may not need
+"xAOD::ElectronAuxContainer#FwdElectronsAux.", ### may not need
+### Muon
+"xAOD::MuonContainer_v1#Muons",
+"xAOD::MuonAuxContainer_v1#MuonsAux.",
+### Tau
+"xAOD::TauJetContainer_v1#TauRecContainer",
+"xAOD::TauJetAuxContainer_v1#TauRecContainerAux.",
+### Photon
+#"xAOD::PhotonContainer_v1#*",
+#"xAOD::PhotonAuxContainer_v1#*",
+### Jet
+"xAOD::JetContainer_v1#AntiKt4EMTopoJets",
+"xAOD::JetAuxContainer_v1#AntiKt4EMTopoJetsAux.",
+"xAOD::JetContainer_v1#AntiKt4LCTopoJets",
+"xAOD::JetAuxContainer_v1#AntiKt4LCTopoJetsAux.",
+"xAOD::JetContainer_v1#AntiKt4TruthJets",
+"xAOD::JetAuxContainer_v1#AntiKt4TruthJetsAux.",
+"xAOD::JetContainer_v1#AntiKt4TruthWZJets",
+"xAOD::JetAuxContainer_v1#AntiKt4TruthWZJetsAux.",
+"xAOD::JetContainer_v1#AntiKt10LCTopoJets",
+"xAOD::JetAuxContainer_v1#AntiKt10LCTopoJetsAux.",
+"xAOD::JetContainer_v1#AntiKt10TruthJets",
+"xAOD::JetAuxContainer_v1#AntiKt10TruthJetsAux.",
+"xAOD::JetContainer_v1#AntiKt10TruthWZJets",
+"xAOD::JetAuxContainer_v1#AntiKt10TruthWZJetsAux.",
+"xAOD::JetContainer_v1#CamKt12LCTopoJets",
+"xAOD::JetAuxContainer_v1#CamKt12LCTopoJetsAux.",
+"xAOD::JetContainer_v1#CamKt12TruthJets",
+"xAOD::JetAuxContainer_v1#CamKt12TruthJetsAux.",
+"xAOD::JetContainer_v1#CamKt12TruthWZJets",
+"xAOD::JetAuxContainer_v1#CamKt12TruthWZJetsAux.",
+"xAOD::JetContainer_v1#AntiKt3PV0TrackJets",
+"xAOD::JetAuxContainer_v1#AntiKt3PV0TrackJetsAux.",
+"xAOD::EventShape_v1#*",
+"xAOD::EventShapeAuxInfo_v1#*",
+### Calo cluster 
+#"xAOD::CaloClusterContainer_v1#CaloCalTopoCluster",
+#"xAOD::CaloClusterAuxContainer_v1#CaloCalTopoClusterAux.",
+"xAOD::CaloClusterContainer_v1#LArClusterEMFrwd",
+"xAOD::CaloClusterAuxContainer_v1#LArClusterEMFrwdAux.",
+"xAOD::CaloClusterContainer_v1#egClusterCollection",
+"xAOD::CaloClusterAuxContainer_v1#egClusterCollectionAux.",
+### Track
+"xAOD::TrackParticleContainer_v1#CombinedMuonTrackParticles",
+"xAOD::TrackParticleContainer_v1#ExtrapolatedMuonTrackParticles",
+"xAOD::TrackParticleContainer_v1#GSFTrackParticles",
+"xAOD::TrackParticleContainer_v1#InDetTrackParticles",
+"xAOD::TrackParticleContainer_v1#InDetTrackParticlesForward",
+"xAOD::TrackParticleAuxContainer_v1#CombinedMuonTrackParticlesAux.",
+"xAOD::TrackParticleAuxContainer_v1#ExtrapolatedMuonTrackParticlesAux.",
+"xAOD::TrackParticleAuxContainer_v1#GSFTrackParticlesAux.",
+"xAOD::TrackParticleAuxContainer_v1#InDetTrackParticlesAux.",
+"xAOD::TrackParticleAuxContainer_v1#InDetTrackParticlesForwardAux.",
+### Missing ET
+"xAOD::MissingETContainer_v1#MET_EMJets",
+"xAOD::MissingETAuxContainer_v1#MET_EMJetsAux.",
+"xAOD::MissingETContainer_v1#MET_EleLHMedEMJets",
+"xAOD::MissingETAuxContainer_v1#MET_EleLHMedEMJetsAux.",
+#"xAOD::MissingETContainer_v1#MET_RefFinal",
+#"xAOD::MissingETAuxContainer_v1#MET_RefFinalAux.",
+"xAOD::MissingETContainer_v1#MET_RefFinalFix",
+"xAOD::MissingETAuxContainer_v1#MET_RefFinalFixAux.",
+"xAOD::MissingETContainer_v1#MET_Truth",
+"xAOD::MissingETAuxContainer_v1#MET_TruthAux.",
+#"xAOD::MissingETContainer_v1#MET_Track",
+#"xAOD::MissingETAuxContainer_v1#MET_TrackAux.",
+"xAOD::MissingETContainer_v1#MET_TrackFix", 
+"xAOD::MissingETAuxContainer_v1#MET_TrackFixAux.", 
+"xAOD::MissingETComponentMap_v1#METMap_EMJets", 
+"xAOD::MissingETAuxComponentMap_v1#METMap_EMJetsAux.",
+"xAOD::MissingETComponentMap_v1#METMap_EleLHMedEMJets",
+"xAOD::MissingETAuxComponentMap_v1#METMap_EleLHMedEMJetsAux.",
+"xAOD::MissingETComponentMap_v1#METMap_RefFinalFix",
+"xAOD::MissingETAuxComponentMap_v1#METMap_RefFinalFixAux.",
+"xAOD::MissingETComponentMap_v1#METMap_Truth", 
+"xAOD::MissingETAuxComponentMap_v1#METMap_TruthAux.", 
+"xAOD::MissingETComponentMap_v1#METMap_TrackFix", 
+"xAOD::MissingETAuxComponentMap_v1#METMap_TrackFixAux.", 
+### Vertex
+"xAOD::VertexContainer_v1#*",
+"xAOD::VertexAuxContainer_v1#*",
+### B-tag
+"xAOD::BTaggingContainer_v1#BTagging_AntiKt4EMTopo",
+"xAOD::BTaggingAuxContainer_v1#BTagging_AntiKt4EMTopoAux.",
+"xAOD::BTaggingContainer_v1#BTagging_AntiKt4LCTopo",
+"xAOD::BTaggingAuxContainer_v1#BTagging_AntiKt4LCTopoAux.",
+"xAOD::BTaggingContainer_v1#BTagging_AntiKt4Truth",
+"xAOD::BTaggingAuxContainer_v1#BTagging_AntiKt4TruthAux.",
+"xAOD::BTaggingContainer_v1#BTagging_AntiKt4TruthWZ",
+"xAOD::BTaggingAuxContainer_v1#BTagging_AntiKt4TruthWZAux.",
+"xAOD::BTaggingContainer_v1#BTagging_AntiKt10LCTopo",
+"xAOD::BTaggingAuxContainer_v1#BTagging_AntiKt10LCTopoAux.",
+"xAOD::BTaggingContainer_v1#BTagging_AntiKt10Truth",
+"xAOD::BTaggingAuxContainer_v1#BTagging_AntiKt10TruthAux.",
+"xAOD::BTaggingContainer_v1#BTagging_AntiKt10TruthWZ",
+"xAOD::BTaggingAuxContainer_v1#BTagging_AntiKt10TruthWZAux.",
+### Trigger 
+"xAOD::TrigDecision_v1#xTrigDecision",
+"xAOD::TrigDecisionAuxInfo_v1#xTrigDecisionAux.",
+"xAOD::TriggerMenuContainer_v1#TriggerMenu",
+"xAOD::TriggerMenuAuxContainer_v1#TriggerMenuAux.",
+"HLT::HLTResult#HLTResult_HLT",
+"HLT::HLTResult#HLTResult_L2",
+"HLT::HLTResult#HLTResult_EF",
+"TrigDec::TrigDecision#TrigDecision",
+### Truth
+"xAOD::TruthVertexContainer_v1#TruthVertex",
+"xAOD::TruthVertexAuxContainer_v1#TruthVertexAux.",
+"xAOD::TruthParticleContainer_v1#TruthParticle",
+"xAOD::TruthParticleContainer_v1#MuonTruthParticle",
+"xAOD::TruthParticleAuxContainer_v1#TruthParticleAux.",
+"xAOD::TruthParticleAuxContainer_v1#MuonTruthParticleAux.",
+"xAOD::TruthEventContainer_v1#TruthEvent",
+"xAOD::TruthEventAuxContainer_v1#TruthEventAux.",
+### Tau
+"xAOD::PFOContainer_v1#TauPi0ChargedPFOContainer",
+"xAOD::PFOAuxContainer_v1#TauPi0ChargedPFOContainerAux.",
+"xAOD::PFOContainer_v1#TauPi0NeutralPFOContainer",
+"xAOD::PFOAuxContainer_v1#TauPi0NeutralPFOContainerAux.",
+"xAOD::PFOContainer_v1#TauShotPFOContainer",
+"xAOD::PFOAuxContainer_v1#TauShotPFOContainerAux.",
+"xAOD::PFOContainer_v1#chargedTauPFO_eflowRec",
+"xAOD::PFOAuxContainer_v1#chargedTauPFO_eflowRecAux.",
+"xAOD::PFOContainer_v1#neutralTauPFO_eflowRec",
+"xAOD::PFOAuxContainer_v1#neutralTauPFO_eflowRecAux."
+]

PhysicsAnalysis/DerivationFramework/DerivationFrameworkHiggs/python/HIGG5D1ExtraContent.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#Content included in addition to the Smart Slimming Content
+
+ExtraContent=[
+    "egammaClusters.rawE.phi_sampl.calM",
+    "Muons.clusterLink.EnergyLoss.energyLossType",
+    "AntiKt4LCTopoJets.TrackWidthPt500.GhostTrackCount.Jvt.JvtJvfcorr.JvtRpt",
+    "AntiKt4LCTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m",
+    "AntiKt4EMTopoJets.TrackWidthPt500.GhostTrackCount.Jvt.JvtJvfcorr.JvtRpt",
+    "AntiKt4EMTopoJets.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m",
+    "AntiKt4EMTopoJets.DFCommonJets_Calib_pt.DFCommonJets_Calib_eta.DFCommonJets_Calib_phi.DFCommonJets_Calib_m",
+    "Photons.f3core"]
+
+ExtraContentTruth=[
+    "AntiKt4EMTopoJets.ConeTruthLabelID",
+    "AntiKt4LCTopoJets.ConeTruthLabelID"]
+
+ExtraContainers=[
+    "BTagging_AntiKt3Track",
+    "BTagging_AntiKt2Track",
+    "MuonSegments"]
+
+ExtraContainersTruth=[
+    "TruthEvents",
+    "TruthParticles",
+    "TruthVertices",
+    "MuonTruthParticles"]