.. _program_listing_file_Root_OverlapRemover.cxx:

Program Listing for File OverlapRemover.cxx
===========================================

|exhale_lsh| :ref:`Return to documentation for file <file_Root_OverlapRemover.cxx>` (``Root/OverlapRemover.cxx``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*************************************************
    *
    * Interface to ASG overlap removal tool
    ( applying recommendations from Harmonisation TF ).
    *
    * M. Milesi (marco.milesi@cern.ch)
    * J. Dandoy
    *
    ************************************************/
   
   // c++ include(s):
   #include <iostream>
   #include <sstream>
   
   // EL include(s):
   #include <EventLoop/Job.h>
   #include <EventLoop/StatusCode.h>
   #include <EventLoop/Worker.h>
   
   // EDM include(s):
   #include "xAODEgamma/ElectronContainer.h"
   #include "xAODEgamma/Electron.h"
   #include "xAODEgamma/PhotonContainer.h"
   #include "xAODEgamma/Photon.h"
   #include "xAODMuon/MuonContainer.h"
   #include "xAODMuon/Muon.h"
   #include "xAODJet/JetContainer.h"
   #include "xAODJet/Jet.h"
   #include "xAODTau/TauJetContainer.h"
   #include "xAODTau/TauJet.h"
   #include "AthContainers/ConstDataVector.h"
   #include "xAODCore/ShallowCopy.h"
   
   // package include(s):
   #include "xAODAnaHelpers/OverlapRemover.h"
   #include "xAODAnaHelpers/HelperFunctions.h"
   #include "xAODAnaHelpers/HelperClasses.h"
   
   using HelperClasses::ToolName;
   
   // this is needed to distribute the algorithm to the workers
   ClassImp(OverlapRemover)
   
   
   OverlapRemover :: OverlapRemover () :
       Algorithm("OverlapRemover")
   {
   }
   
   EL::StatusCode OverlapRemover :: setupJob (EL::Job& job)
   {
     // Here you put code that sets up the job on the submission object
     // so that it is ready to work with your algorithm, e.g. you can
     // request the D3PDReader service or add output files.  Any code you
     // put here could instead also go into the submission script.  The
     // sole advantage of putting it here is that it gets automatically
     // activated/deactivated when you add/remove the algorithm from your
     // job, which may or may not be of value to you.
   
     ANA_MSG_INFO( "Calling setupJob");
   
     job.useXAOD ();
     xAOD::Init( "OverlapRemover" ).ignore(); // call before opening first file
   
     return EL::StatusCode::SUCCESS;
   }
   
   
   
   EL::StatusCode OverlapRemover :: histInitialize ()
   {
     // Here you do everything that needs to be done at the very
     // beginning on each worker node, e.g. create histograms and output
     // trees.  This method gets called before any input files are
     // connected.
     ANA_CHECK( xAH::Algorithm::algInitialize());
     return EL::StatusCode::SUCCESS;
   }
   
   
   
   EL::StatusCode OverlapRemover :: fileExecute ()
   {
     // Here you do everything that needs to be done exactly once for every
     // single file, e.g. collect a list of all lumi-blocks processed
     return EL::StatusCode::SUCCESS;
   }
   
   
   
   EL::StatusCode OverlapRemover :: changeInput (bool /*firstFile*/)
   {
     // Here you do everything you need to do when we change input files,
     // e.g. resetting branch addresses on trees.  If you are using
     // D3PDReader or a similar service this method is not needed.
     return EL::StatusCode::SUCCESS;
   }
   
   
   
   EL::StatusCode OverlapRemover :: initialize ()
   {
     // Here you do everything that you need to do after the first input
     // file has been connected and before the first event is processed,
     // e.g. create additional histograms based on which variables are
     // available in the input files.  You can also create all of your
     // histograms and trees in here, but be aware that this method
     // doesn't get called if no events are processed.  So any objects
     // you create here won't be available in the output if you have no
     // input events.
   
     ANA_MSG_INFO( "Initializing OverlapRemover Interface... ");
   
     if ( setCutFlowHist() == EL::StatusCode::FAILURE ) {
       ANA_MSG_ERROR( "Failed to setup cutflow histograms. Exiting." );
       return EL::StatusCode::FAILURE;
     }
   
     m_event = wk()->xaodEvent();
     m_store = wk()->xaodStore();
   
     ANA_MSG_INFO( "Number of events in file: " << m_event->getEntries() );
   
   
     if ( m_inContainerName_Jets.empty() ) {
       ANA_MSG_ERROR( "InputContainerJets is empty! Must have it to perform Overlap Removal! Exiting.");
       return EL::StatusCode::FAILURE;
     }
   
     if ( !m_inContainerName_Electrons.empty() ) { m_useElectrons = true; }
     if ( !m_inContainerName_Muons.empty() )     { m_useMuons     = true; }
     if ( !m_inContainerName_Taus.empty() )      { m_useTaus      = true; }
     if ( !m_inContainerName_Photons.empty() )   { m_usePhotons   = true; }
   
     m_outAuxContainerName_Electrons   = m_outContainerName_Electrons + "Aux."; // the period is very important!
     m_outAuxContainerName_Muons       = m_outContainerName_Muons + "Aux.";     // the period is very important!
     m_outAuxContainerName_Jets        = m_outContainerName_Jets + "Aux.";      // the period is very important!
     m_outAuxContainerName_Photons     = m_outContainerName_Photons + "Aux.";   // the period is very important!
     m_outAuxContainerName_Taus        = m_outContainerName_Taus + "Aux.";      // the period is very important!
   
   
     if ( setCounters() == EL::StatusCode::FAILURE ) {
       ANA_MSG_ERROR( "Failed to properly set event/object counters. Exiting." );
       return EL::StatusCode::FAILURE;
     }
   
     // initialize ASG overlap removal tool
     const std::string selected_label = ( m_useSelected ) ? "passSel" : "";  // set with decoration flag you use for selected objects if want to consider only selected objects in OR, otherwise it will perform OR on all objects
   
     //Set Flags for recommended overlap procedures
     ORUtils::ORFlags orFlags("OverlapRemovalTool", selected_label, m_decor);
   
     orFlags.outputPassValue     = true;
     orFlags.linkOverlapObjects  = m_linkOverlapObjects;
     orFlags.bJetLabel           = m_bTagWP;
     orFlags.boostedLeptons      = m_useBoostedLeptons;
     orFlags.doEleEleOR          = m_doEleEleOR || m_lepFavWP;
   
     orFlags.doJets      = true;
     orFlags.doMuons     = m_useMuons;
     orFlags.doElectrons = m_useElectrons;
     orFlags.doTaus      = m_useTaus;
     orFlags.doPhotons   = m_usePhotons;
     orFlags.doFatJets   = false;
   
     ANA_CHECK( ORUtils::recommendedTools(orFlags, m_ORToolbox));
     if(m_applyRelPt) ANA_CHECK( m_ORToolbox.muJetORT.setProperty("ApplyRelPt", true) );
     if (m_lepFavWP) {
       ANA_CHECK( m_ORToolbox.eleEleORT.setProperty("UseClusterMatch", true) );
       ANA_CHECK( m_ORToolbox.muJetORT.setProperty("OuterDR", 0.) );
       ANA_CHECK( m_ORToolbox.eleJetORT.setProperty("OuterDR", 0.) );
     }
     ANA_CHECK( m_ORToolbox.initialize());
     ANA_MSG_INFO( "OverlapRemover Interface succesfully initialized!" );
   
     return EL::StatusCode::SUCCESS;
   }
   
   
   EL::StatusCode OverlapRemover :: execute ()
   {
     // Here you do everything that needs to be done on every single
     // events, e.g. read input variables, apply cuts, and fill
     // histograms and trees.  This is where most of your actual analysis
     // code will go.
   
     ANA_MSG_DEBUG("Applying Overlap Removal... ");
   
     m_numEvent++;
   
     // get the collections from TEvent or TStore
     const xAOD::ElectronContainer* inElectrons (nullptr);
     const xAOD::MuonContainer* inMuons         (nullptr);
     const xAOD::JetContainer* inJets           (nullptr);
     const xAOD::PhotonContainer* inPhotons     (nullptr);
     const xAOD::TauJetContainer* inTaus        (nullptr);
   
     // syst container name
     auto vecOutContainerNames = std::make_unique< std::vector< std::string > >();
   
     // --------------------------------------------------------------------------------------------
     //
     // always run the nominal case
     executeOR(inElectrons, inMuons, inJets, inPhotons, inTaus, NOMINAL, nullptr, vecOutContainerNames.get());
   
     // look what do we have in TStore
     if(msgLvl(MSG::VERBOSE)) m_store->print();
   
     // -----------------------------------------------------------------------------------------------
     //
     // if at least one of the m_inputAlgo* is not empty, and there's at least one non-empty syst name,
     // then perform OR for every non-empty systematic set
   
     // ****************** //
     //      Electrons     //
     // ****************** //
   
     if ( !m_inputAlgoElectrons.empty() ) {
   
       // -----------------------
       //
       // get the systematic sets:
   
       // get vector of string giving the syst names (rememeber: 1st element is a blank string: nominal case!)
       std::vector<std::string>* systNames_el(nullptr);
       ANA_CHECK( HelperFunctions::retrieve(systNames_el, m_inputAlgoElectrons, 0, m_store, msg()) );
   
       if ( HelperFunctions::found_non_dummy_sys(systNames_el) ) {
         executeOR(inElectrons, inMuons, inJets, inPhotons, inTaus,  ELSYST, systNames_el, vecOutContainerNames.get());
       }
   
     }
   
     // **************** //
     //      Muons       //
     // **************** //
   
     if ( !m_inputAlgoMuons.empty() ) {
   
       // -----------------------
       //
       // get the systematic sets:
   
       // get vector of string giving the syst names (rememeber: 1st element is a blank string: nominal case!)
       std::vector<std::string>* systNames_mu(nullptr);
       ANA_CHECK( HelperFunctions::retrieve(systNames_mu, m_inputAlgoMuons, 0, m_store, msg()) );
   
       if ( HelperFunctions::found_non_dummy_sys(systNames_mu) ) {
         executeOR(inElectrons, inMuons, inJets, inPhotons, inTaus,  MUSYST, systNames_mu, vecOutContainerNames.get());
       }
   
     }
   
     // **************** //
     //       Jets       //
     // **************** //
   
     if ( !m_inputAlgoJets.empty() ) {
   
       // -----------------------
       //
       // get the systematic sets:
   
       // get vector of string giving the syst names (rememeber: 1st element is a blank string: nominal case!)
       std::vector<std::string>* systNames_jet;
       ANA_CHECK( HelperFunctions::retrieve(systNames_jet, m_inputAlgoJets, 0, m_store, msg()) );
   
       if ( HelperFunctions::found_non_dummy_sys(systNames_jet) ) {
         executeOR(inElectrons, inMuons, inJets, inPhotons, inTaus,  JETSYST, systNames_jet, vecOutContainerNames.get());
       }
   
     }
   
     // **************** //
     //     Photons      //
     // **************** //
   
     if ( !m_inputAlgoPhotons.empty() ) {
   
       // -----------------------
       //
       // get the systematic sets:
   
       // get vector of string giving the syst names (rememeber: 1st element is a blank string: nominal case!)
       std::vector<std::string>* systNames_photon;
       ANA_CHECK( HelperFunctions::retrieve(systNames_photon, m_inputAlgoPhotons, 0, m_store, msg()) );
   
       executeOR(inElectrons, inMuons, inJets, inPhotons, inTaus,  PHSYST, systNames_photon, vecOutContainerNames.get());
   
     }
     // **************** //
     //       Taus       //
     // **************** //
   
     if ( !m_inputAlgoTaus.empty() ) {
   
       // -----------------------
       //
       // get the systematic sets:
   
       // get vector of string giving the syst names (rememeber: 1st element is a blank string: nominal case!)
       std::vector<std::string>* systNames_tau;
       ANA_CHECK( HelperFunctions::retrieve(systNames_tau, m_inputAlgoTaus, 0, m_store, msg()) );
   
       executeOR(inElectrons, inMuons, inJets, inPhotons, inTaus, TAUSYST, systNames_tau, vecOutContainerNames.get());
   
     }
   
     // save list of systs that should be considered down stream
     ANA_CHECK( m_store->record( std::move(vecOutContainerNames), m_outputAlgoSystNames));
   
     // look what do we have in TStore
     if(msgLvl(MSG::VERBOSE)) m_store->print();
   
     return EL::StatusCode::SUCCESS;
   
   }
   
   EL::StatusCode OverlapRemover :: postExecute ()
   {
     // Here you do everything that needs to be done after the main event
     // processing.  This is typically very rare, particularly in user
     // code.  It is mainly used in implementing the NTupleSvc.
   
     ANA_MSG_DEBUG("Calling postExecute");
   
     return EL::StatusCode::SUCCESS;
   }
   
   
   EL::StatusCode OverlapRemover :: finalize ()
   {
     // This method is the mirror image of initialize(), meaning it gets
     // called after the last event has been processed on the worker node
     // and allows you to finish up any objects you created in
     // initialize() before they are written to disk.  This is actually
     // fairly rare, since this happens separately for each worker node.
     // Most of the time you want to do your post-processing on the
     // submission node after all your histogram outputs have been
     // merged.  This is different from histFinalize() in that it only
     // gets called on worker nodes that processed input events.
   
     ANA_MSG_INFO( "Deleting tool instances...");
   
     return EL::StatusCode::SUCCESS;
   }
   
   
   
   EL::StatusCode OverlapRemover :: histFinalize ()
   {
     // This method is the mirror image of histInitialize(), meaning it
     // gets called after the last event has been processed on the worker
     // node and allows you to finish up any objects you created in
     // histInitialize() before they are written to disk.  This is
     // actually fairly rare, since this happens separately for each
     // worker node.  Most of the time you want to do your
     // post-processing on the submission node after all your histogram
     // outputs have been merged.  This is different from finalize() in
     // that it gets called on all worker nodes regardless of whether
     // they processed input events.
   
     ANA_MSG_INFO( "Calling histFinalize");
     ANA_CHECK( xAH::Algorithm::algFinalize());
     return EL::StatusCode::SUCCESS;
   }
   
   
   EL::StatusCode OverlapRemover :: fillObjectCutflow (const xAOD::IParticleContainer* objCont, const std::string& overlapFlag, const std::string& selectFlag)
   {
     SG::AuxElement::ConstAccessor<char> selectAcc(selectFlag);
     SG::AuxElement::ConstAccessor<char> overlapAcc(overlapFlag);
     static SG::AuxElement::ConstAccessor< ElementLink<xAOD::IParticleContainer> > objLinkAcc("overlapObject");
   
     for ( auto obj_itr : *(objCont) ) {
   
       std::string type;
   
       // Safety check
       //
       if ( !overlapAcc.isAvailable( *obj_itr ) ) {
         ANA_MSG_ERROR( "Overlap decoration missing for this object");
         return EL::StatusCode::FAILURE;
       }
       switch(obj_itr->type()) {
         case xAOD::Type::Electron:
           type = "electron";
           if (!overlapAcc( *obj_itr ))
             m_el_cutflowHist_1->Fill( m_el_cutflow_OR_cut, 1 );
           break;
         case xAOD::Type::Muon:
           if (!overlapAcc( *obj_itr ))
             m_mu_cutflowHist_1->Fill( m_mu_cutflow_OR_cut, 1 );
           type = "muon";
           break;
         case xAOD::Type::Jet:
           if (!overlapAcc( *obj_itr ))
             m_jet_cutflowHist_1->Fill( m_jet_cutflow_OR_cut, 1 );
           type = "jet";
           break;
         case xAOD::Type::Photon:
           if (!overlapAcc( *obj_itr ))
             m_ph_cutflowHist_1->Fill( m_ph_cutflow_OR_cut, 1 );
           type = "photon";
           break;
         case xAOD::Type::Tau:
           if (!overlapAcc( *obj_itr ))
             m_tau_cutflowHist_1->Fill( m_tau_cutflow_OR_cut, 1 );
           type = "tau";
           break;
         default:
           ANA_MSG_ERROR("Unsupported object");
           return EL::StatusCode::FAILURE;
           break;
       }
   
       int isBTagged = 0;
       if ( !m_bTagWP.empty() ) {
         SG::AuxElement::Decorator< char > isBTag( m_bTagWP );
         if( isBTag.isAvailable( *obj_itr ) && isBTag(*obj_itr)==true ) isBTagged = 1;
       }
   
       if(selectAcc.isAvailable(*obj_itr)){
         ANA_MSG_DEBUG( type << " pt " << obj_itr->pt()/1e3 << " eta " << obj_itr->eta() << " phi " << obj_itr->phi() << " btagged " << isBTagged << " selected " << selectAcc(*obj_itr) << " passesOR  " << overlapAcc( *obj_itr ) );
       } else {
         ANA_MSG_DEBUG( type << " pt " << obj_itr->pt()/1e3 << " eta " << obj_itr->eta() << " phi " << obj_itr->phi() << " btagged " << isBTagged << " selected N/A" << " passesOR  " << overlapAcc( *obj_itr ) );
       }
       // Check for overlap object link
       if ( objLinkAcc.isAvailable( *obj_itr ) && objLinkAcc( *obj_itr ).isValid() ) {
         const xAOD::IParticle* overlapObj = *objLinkAcc( *obj_itr );
         std::stringstream ss_or; ss_or << overlapObj->type();
         ANA_MSG_DEBUG( " Overlap: type " << ss_or.str() << " pt " << overlapObj->pt()/1e3);
       }
   
     }
   
     return EL::StatusCode::SUCCESS;
   
   }
   
   
   EL::StatusCode OverlapRemover :: executeOR(  const xAOD::ElectronContainer* inElectrons, const xAOD::MuonContainer* inMuons, const xAOD::JetContainer* inJets,
                  const xAOD::PhotonContainer* inPhotons,   const xAOD::TauJetContainer* inTaus,
                  SystType syst_type, std::vector<std::string>* sysVec, std::vector<std::string>* sysVecOut)
   {
   
     // instantiate output container(s)
     //
     ConstDataVector<xAOD::ElectronContainer> *selectedElectrons   (nullptr);
     ConstDataVector<xAOD::MuonContainer>     *selectedMuons (nullptr);
     ConstDataVector<xAOD::JetContainer>      *selectedJets  (nullptr);
     ConstDataVector<xAOD::PhotonContainer>   *selectedPhotons (nullptr);
     ConstDataVector<xAOD::TauJetContainer>   *selectedTaus  (nullptr);
   
     // make a switch for systematics types
     //
     switch ( static_cast<int>(syst_type) )
     {
   
       case NOMINAL:  // this is the nominal case
       {
         ANA_MSG_DEBUG("Doing nominal case");
         bool nomContainerNotFound(false);
   
         if( m_useElectrons ) {
           if ( m_store->contains<ConstDataVector<xAOD::ElectronContainer> >(m_inContainerName_Electrons) || m_store->contains<xAOD::ElectronContainer>(m_inContainerName_Electrons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inElectrons, m_inContainerName_Electrons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Electrons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case...");  }
           }
         }
   
         if( m_useMuons ) {
           if ( m_store->contains<ConstDataVector<xAOD::MuonContainer> >(m_inContainerName_Muons) || m_store->contains<xAOD::MuonContainer>(m_inContainerName_Muons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inMuons, m_inContainerName_Muons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Muons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_store->contains<ConstDataVector<xAOD::JetContainer> >(m_inContainerName_Jets) || m_store->contains<xAOD::JetContainer>(m_inContainerName_Jets) ) {
           ANA_CHECK( HelperFunctions::retrieve(inJets, m_inContainerName_Jets, m_event, m_store, msg()) );
         } else {
           nomContainerNotFound = true;
           if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Jets << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
         }
   
         if ( m_usePhotons ) {
           if ( m_store->contains<ConstDataVector<xAOD::PhotonContainer> >(m_inContainerName_Photons) || m_store->contains<xAOD::PhotonContainer>(m_inContainerName_Photons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inPhotons, m_inContainerName_Photons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Photons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_useTaus ) {
           if ( m_store->contains<ConstDataVector<xAOD::TauJetContainer> >(m_inContainerName_Taus) || m_store->contains<xAOD::TauJetContainer>(m_inContainerName_Taus) ) {
             ANA_CHECK( HelperFunctions::retrieve(inTaus, m_inContainerName_Taus, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Taus << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( nomContainerNotFound ) {return EL::StatusCode::SUCCESS;}
   
         if ( m_useElectrons ) { ANA_MSG_DEBUG(  "inElectrons : " << inElectrons->size()); }
         if ( m_useMuons )     { ANA_MSG_DEBUG(  "inMuons : " << inMuons->size()); }
         ANA_MSG_DEBUG(  "inJets : " << inJets->size() );
         if ( m_usePhotons )   { ANA_MSG_DEBUG(  "inPhotons : " << inPhotons->size());  }
         if ( m_useTaus    )   { ANA_MSG_DEBUG(  "inTaus : " << inTaus->size());  }
   
         // do the actual OR
         //
         ANA_MSG_DEBUG(  "Calling removeOverlaps()");
         ANA_CHECK( m_ORToolbox.masterTool->removeOverlaps(inElectrons, inMuons, inJets, inTaus, inPhotons)); // This line raises an exception
         ANA_MSG_DEBUG(  "Done Calling removeOverlaps()");
   
         std::string ORdecor(m_decor);
         if(m_useCutFlow){
           // fill cutflow histograms
           //
           ANA_MSG_DEBUG(  "Filling Cut Flow Histograms");
           if ( m_useElectrons ) fillObjectCutflow(inElectrons);
           if ( m_useMuons )     fillObjectCutflow(inMuons);
           fillObjectCutflow(inJets);
           if ( m_usePhotons )   fillObjectCutflow(inPhotons);
           if ( m_useTaus )      fillObjectCutflow(inTaus);
         }
   
         // make a copy of input container(s) with selected objects
         //
         if ( m_createSelectedContainers ) {
           ANA_MSG_DEBUG(  "Creating selected Containers");
           if( m_useElectrons ) selectedElectrons  = new ConstDataVector<xAOD::ElectronContainer>(SG::VIEW_ELEMENTS);
           if( m_useMuons )     selectedMuons      = new ConstDataVector<xAOD::MuonContainer>(SG::VIEW_ELEMENTS);
           selectedJets      = new ConstDataVector<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
           if ( m_usePhotons )  selectedPhotons  = new ConstDataVector<xAOD::PhotonContainer>(SG::VIEW_ELEMENTS);
           if ( m_useTaus )     selectedTaus = new ConstDataVector<xAOD::TauJetContainer>(SG::VIEW_ELEMENTS);
         }
   
         // resize containers basd on OR decision:
         //
         // if an object has been flagged as 'passOR', it will be stored in the 'selected' container
         //
         ANA_MSG_DEBUG(  "Resizing");
         if ( m_useElectrons ) { ANA_CHECK( HelperFunctions::makeSubsetCont(inElectrons, selectedElectrons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
         if ( m_useMuons )     { ANA_CHECK( HelperFunctions::makeSubsetCont(inMuons, selectedMuons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
         ANA_CHECK( HelperFunctions::makeSubsetCont(inJets, selectedJets, msg(), ORdecor.c_str(), ToolName::SELECTOR));
         if ( m_usePhotons )   { ANA_CHECK( HelperFunctions::makeSubsetCont(inPhotons, selectedPhotons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
         if ( m_useTaus )      { ANA_CHECK( HelperFunctions::makeSubsetCont(inTaus, selectedTaus, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
   
         if ( m_useElectrons) { ANA_MSG_DEBUG(  "selectedElectrons : " << selectedElectrons->size()); }
         if ( m_useMuons )    { ANA_MSG_DEBUG(  "selectedMuons : " << selectedMuons->size()); }
         ANA_MSG_DEBUG(  "selectedJets : " << selectedJets->size());
         if ( m_usePhotons )  { ANA_MSG_DEBUG(  "selectedPhotons : " << selectedPhotons->size()); }
         if ( m_useTaus )     { ANA_MSG_DEBUG(  "selectedTaus : " << selectedTaus->size() ); }
   
         // add ConstDataVector to TStore
         //
         if ( m_createSelectedContainers ) {
           ANA_MSG_DEBUG(  "Recording");
           if ( m_useElectrons ){ ANA_CHECK( m_store->record( selectedElectrons,   m_outContainerName_Electrons )); }
           if ( m_useMuons )    { ANA_CHECK( m_store->record( selectedMuons,  m_outContainerName_Muons )); }
           ANA_CHECK( m_store->record( selectedJets,  m_outContainerName_Jets ));
           if ( m_usePhotons )  { ANA_CHECK( m_store->record( selectedPhotons, m_outContainerName_Photons )); }
           if ( m_useTaus )     { ANA_CHECK( m_store->record( selectedTaus, m_outContainerName_Taus )); }
         }
   
         sysVecOut->push_back("");
         break;
       }
       case ELSYST : // electron syst
       {
         ANA_MSG_DEBUG(  "Doing  electron systematics");
         bool nomContainerNotFound(false);
   
         // just to check everything is fine
         ANA_MSG_DEBUG("will consider the following ELECTRON systematics:" );
         for ( auto it : *sysVec ){ ANA_MSG_DEBUG("\t " << it); }
   
         // these input containers won't change in the electron syst loop ...
         if( m_useMuons ) {
           if ( m_store->contains<ConstDataVector<xAOD::MuonContainer> >(m_inContainerName_Muons) || m_store->contains<xAOD::MuonContainer>(m_inContainerName_Muons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inMuons, m_inContainerName_Muons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Muons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case...");  }
           }
         }
   
         if ( m_store->contains<ConstDataVector<xAOD::JetContainer> >(m_inContainerName_Jets) || m_store->contains<xAOD::JetContainer>(m_inContainerName_Jets) ) {
           ANA_CHECK( HelperFunctions::retrieve(inJets, m_inContainerName_Jets, m_event, m_store, msg()) );
         } else {
           nomContainerNotFound = true;
           if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Jets << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
         }
   
         if ( m_usePhotons ) {
           if ( m_store->contains<ConstDataVector<xAOD::PhotonContainer> >(m_inContainerName_Photons) || m_store->contains<xAOD::PhotonContainer>(m_inContainerName_Photons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inPhotons, m_inContainerName_Photons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Photons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_useTaus ) {
           if ( m_store->contains<ConstDataVector<xAOD::TauJetContainer> >(m_inContainerName_Taus) || m_store->contains<xAOD::TauJetContainer>(m_inContainerName_Taus) ) {
             ANA_CHECK( HelperFunctions::retrieve(inTaus, m_inContainerName_Taus, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Taus << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( nomContainerNotFound ) {return EL::StatusCode::SUCCESS;}
   
   
         for ( auto systName : *sysVec) {
   
           if ( systName.empty() ) continue;
   
           // ... instead, the electron input container will be different for each syst
           //
           std::string el_syst_cont_name = m_inContainerName_Electrons + systName;
           ANA_CHECK( HelperFunctions::retrieve(inElectrons, el_syst_cont_name, 0, m_store, msg()) );
   
           // do the actual OR
           //
           ANA_CHECK( m_ORToolbox.masterTool->removeOverlaps(inElectrons, inMuons, inJets, inTaus, inPhotons));
   
           const std::string ORdecor(m_decor);
           if(m_useCutFlow){
             // fill cutflow histograms
             //
             fillObjectCutflow(inElectrons);
             if ( m_useMuons )   fillObjectCutflow(inMuons);
             fillObjectCutflow(inJets);
             if ( m_usePhotons ) fillObjectCutflow(inPhotons);
             if ( m_useTaus )    fillObjectCutflow(inTaus);
           }
   
           // make a copy of input container(s) with selected objects
           //
           if ( m_createSelectedContainers ) {
             selectedElectrons   = new ConstDataVector<xAOD::ElectronContainer>(SG::VIEW_ELEMENTS);
             if ( m_useMuons )    selectedMuons  = new ConstDataVector<xAOD::MuonContainer>(SG::VIEW_ELEMENTS);
             selectedJets        = new ConstDataVector<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
             if ( m_usePhotons )  selectedPhotons  = new ConstDataVector<xAOD::PhotonContainer>(SG::VIEW_ELEMENTS);
             if ( m_useTaus )     selectedTaus = new ConstDataVector<xAOD::TauJetContainer>(SG::VIEW_ELEMENTS);
           }
   
           // resize containers basd on OR decision
           //
           ANA_CHECK( HelperFunctions::makeSubsetCont(inElectrons, selectedElectrons, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           if ( m_useMuons )  {  ANA_CHECK( HelperFunctions::makeSubsetCont(inMuons, selectedMuons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           ANA_CHECK( HelperFunctions::makeSubsetCont(inJets, selectedJets, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           if ( m_usePhotons ){ ANA_CHECK( HelperFunctions::makeSubsetCont(inPhotons, selectedPhotons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           if ( m_useTaus )   {  ANA_CHECK( HelperFunctions::makeSubsetCont(inTaus, selectedTaus, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
   
           // add ConstDataVector to TStore
           //
           if ( m_createSelectedContainers ) {
             // a different syst varied container will be stored for each syst variation
             ANA_CHECK( m_store->record( selectedElectrons, m_outContainerName_Electrons + systName ));
             if ( m_useMuons )  { ANA_CHECK( m_store->record( selectedMuons,     m_outContainerName_Muons + systName )); }
             ANA_CHECK( m_store->record( selectedJets,      m_outContainerName_Jets + systName ));
             if ( m_usePhotons ){ ANA_CHECK( m_store->record( selectedPhotons, m_outContainerName_Photons + systName )); }
             if ( m_useTaus )   { ANA_CHECK( m_store->record( selectedTaus, m_outContainerName_Taus + systName )); }
           }
   
           sysVecOut->push_back(systName);
         } // close loop on systematic sets available from upstream algo (Electrons)
   
         break;
       }
       case MUSYST: // muon syst
       {
         ANA_MSG_DEBUG(  "Doing  muon systematics");
         bool nomContainerNotFound(false);
   
         // just to check everything is fine
         ANA_MSG_DEBUG("will consider the following MUON systematics:" );
         for ( auto it : *sysVec ){ ANA_MSG_DEBUG("\t " << it); }
   
         // these input containers won't change in the muon syst loop ...
         if( m_useElectrons ) {
           if ( m_store->contains<ConstDataVector<xAOD::ElectronContainer> >(m_inContainerName_Electrons) || m_store->contains<xAOD::ElectronContainer>(m_inContainerName_Electrons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inElectrons, m_inContainerName_Electrons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Electrons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case...");  }
           }
         }
   
         if ( m_store->contains<ConstDataVector<xAOD::JetContainer> >(m_inContainerName_Jets) || m_store->contains<xAOD::JetContainer>(m_inContainerName_Jets) ) {
           ANA_CHECK( HelperFunctions::retrieve(inJets, m_inContainerName_Jets, m_event, m_store, msg()) );
         } else {
           nomContainerNotFound = true;
           if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Jets << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
         }
   
         if ( m_usePhotons ) {
           if ( m_store->contains<ConstDataVector<xAOD::PhotonContainer> >(m_inContainerName_Photons) || m_store->contains<xAOD::PhotonContainer>(m_inContainerName_Photons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inPhotons, m_inContainerName_Photons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Photons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_useTaus ) {
           if ( m_store->contains<ConstDataVector<xAOD::TauJetContainer> >(m_inContainerName_Taus) || m_store->contains<xAOD::TauJetContainer>(m_inContainerName_Taus) ) {
             ANA_CHECK( HelperFunctions::retrieve(inTaus, m_inContainerName_Taus, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Taus << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( nomContainerNotFound ) {return EL::StatusCode::SUCCESS;}
   
   
         for ( auto systName : *sysVec) {
   
           if ( systName.empty() ) continue;
   
           // ... instead, the muon input container will be different for each syst
           //
           std::string mu_syst_cont_name = m_inContainerName_Muons + systName;
           ANA_CHECK( HelperFunctions::retrieve(inMuons, mu_syst_cont_name, 0, m_store, msg()) );
   
           // do the actual OR
           //
           ANA_CHECK( m_ORToolbox.masterTool->removeOverlaps(inElectrons, inMuons, inJets, inTaus, inPhotons));
   
           const std::string ORdecor(m_decor);
           if(m_useCutFlow){
             // fill cutflow histograms
             //
             if ( m_useElectrons ) fillObjectCutflow(inElectrons);
             fillObjectCutflow(inMuons);
             fillObjectCutflow(inJets);
             if( m_usePhotons )    fillObjectCutflow(inPhotons);
             if( m_useTaus )       fillObjectCutflow(inTaus);
           }
           // make a copy of input container(s) with selected objects
           //
           if ( m_createSelectedContainers ) {
             if ( m_useElectrons ) selectedElectrons   = new ConstDataVector<xAOD::ElectronContainer>(SG::VIEW_ELEMENTS);
             selectedMuons       = new ConstDataVector<xAOD::MuonContainer>(SG::VIEW_ELEMENTS);
             selectedJets        = new ConstDataVector<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
             if ( m_usePhotons )   selectedPhotons = new ConstDataVector<xAOD::PhotonContainer>(SG::VIEW_ELEMENTS);
             if ( m_useTaus )      selectedTaus  = new ConstDataVector<xAOD::TauJetContainer>(SG::VIEW_ELEMENTS);
           }
   
           // resize containers based on OR decision
           //
           if ( m_useElectrons ) { ANA_CHECK( HelperFunctions::makeSubsetCont(inElectrons, selectedElectrons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           ANA_CHECK( HelperFunctions::makeSubsetCont(inMuons, selectedMuons, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           ANA_CHECK( HelperFunctions::makeSubsetCont(inJets, selectedJets, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           if ( m_usePhotons )   { ANA_CHECK( HelperFunctions::makeSubsetCont(inPhotons, selectedPhotons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           if ( m_useTaus )      { ANA_CHECK( HelperFunctions::makeSubsetCont(inTaus, selectedTaus, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
   
           // add ConstDataVector to TStore
           //
           if ( m_createSelectedContainers ) {
             // a different syst varied container will be stored for each syst variation
             //
             if ( m_useElectrons ) { ANA_CHECK( m_store->record( selectedElectrons, m_outContainerName_Electrons + systName )); }
             ANA_CHECK( m_store->record( selectedMuons,     m_outContainerName_Muons + systName ));
             ANA_CHECK( m_store->record( selectedJets,      m_outContainerName_Jets + systName ));
             if ( m_usePhotons )   { ANA_CHECK( m_store->record( selectedPhotons, m_outContainerName_Photons + systName )); }
             if ( m_useTaus )      { ANA_CHECK( m_store->record( selectedTaus, m_outContainerName_Taus + systName )); }
           }
   
           sysVecOut->push_back(systName);
         } // close loop on systematic sets available from upstream algo (Muons)
   
         break;
       }
       case JETSYST: // jet systematics
       {
         ANA_MSG_DEBUG(  "Doing  jet systematics");
         bool nomContainerNotFound(false);
   
         // just to check everything is fine
         ANA_MSG_DEBUG("will consider the following JET systematics:" );
         for ( auto it : *sysVec ) { ANA_MSG_DEBUG("\t " << it);  }
   
         // these input containers won't change in the jet syst loop ...
         if( m_useElectrons ) {
           if ( m_store->contains<ConstDataVector<xAOD::ElectronContainer> >(m_inContainerName_Electrons) || m_store->contains<xAOD::ElectronContainer>(m_inContainerName_Electrons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inElectrons, m_inContainerName_Electrons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Electrons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case...");  }
           }
         }
   
         if( m_useMuons ) {
           if ( m_store->contains<ConstDataVector<xAOD::MuonContainer> >(m_inContainerName_Muons) || m_store->contains<xAOD::MuonContainer>(m_inContainerName_Muons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inMuons, m_inContainerName_Muons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Muons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_usePhotons ) {
           if ( m_store->contains<ConstDataVector<xAOD::PhotonContainer> >(m_inContainerName_Photons) || m_store->contains<xAOD::PhotonContainer>(m_inContainerName_Photons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inPhotons, m_inContainerName_Photons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Photons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_useTaus ) {
           if ( m_store->contains<ConstDataVector<xAOD::TauJetContainer> >(m_inContainerName_Taus) || m_store->contains<xAOD::TauJetContainer>(m_inContainerName_Taus) ) {
             ANA_CHECK( HelperFunctions::retrieve(inTaus, m_inContainerName_Taus, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Taus << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( nomContainerNotFound ) {return EL::StatusCode::SUCCESS;}
   
         for( auto systName : *sysVec ) {
   
           if ( systName.empty() ) continue;
   
           // ... instead, the jet input container will be different for each syst
           //
           std::string jet_syst_cont_name = m_inContainerName_Jets + systName;
           ANA_CHECK( HelperFunctions::retrieve(inJets, jet_syst_cont_name, 0, m_store, msg()) );
   
           // do the actual OR
           //
           ANA_CHECK( m_ORToolbox.masterTool->removeOverlaps(inElectrons, inMuons, inJets, inTaus, inPhotons));
   
           const std::string ORdecor(m_decor);
           if(m_useCutFlow){
             // fill cutflow histograms
             //
             if ( m_useElectrons ) fillObjectCutflow(inElectrons);
             if ( m_useMuons )     fillObjectCutflow(inMuons);
             fillObjectCutflow(inJets);
             if( m_usePhotons )    fillObjectCutflow(inPhotons);
             if( m_useTaus )       fillObjectCutflow(inTaus);
           }
   
           // make a copy of input container(s) with selected objects
           //
           if ( m_createSelectedContainers ) {
             if ( m_useElectrons ) selectedElectrons   = new ConstDataVector<xAOD::ElectronContainer>(SG::VIEW_ELEMENTS);
             if ( m_useMuons )     selectedMuons      = new ConstDataVector<xAOD::MuonContainer>(SG::VIEW_ELEMENTS);
             selectedJets       = new ConstDataVector<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
             if ( m_usePhotons )   selectedPhotons  = new ConstDataVector<xAOD::PhotonContainer>(SG::VIEW_ELEMENTS);
             if ( m_useTaus )      selectedTaus = new ConstDataVector<xAOD::TauJetContainer>(SG::VIEW_ELEMENTS);
           }
   
           // resize containers basd on OR decision
           //
           if ( m_useElectrons ) { ANA_CHECK( HelperFunctions::makeSubsetCont(inElectrons, selectedElectrons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           if ( m_useMuons )     { ANA_CHECK( HelperFunctions::makeSubsetCont(inMuons, selectedMuons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           ANA_CHECK( HelperFunctions::makeSubsetCont(inJets, selectedJets, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           if ( m_usePhotons )   { ANA_CHECK( HelperFunctions::makeSubsetCont(inPhotons, selectedPhotons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           if ( m_useTaus )      { ANA_CHECK( HelperFunctions::makeSubsetCont(inTaus, selectedTaus, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
   
           // add ConstDataVector to TStore
           //
           if ( m_createSelectedContainers ) {
             // a different syst varied container will be stored for each syst variation
             //
             if ( m_useElectrons ) { ANA_CHECK( m_store->record( selectedElectrons, m_outContainerName_Electrons + systName )); }
             if ( m_useMuons )   { ANA_CHECK( m_store->record( selectedMuons,     m_outContainerName_Muons + systName )); }
             ANA_CHECK( m_store->record( selectedJets,      m_outContainerName_Jets + systName ));
             if ( m_usePhotons )   { ANA_CHECK( m_store->record( selectedPhotons, m_outContainerName_Photons + systName )); }
             if ( m_useTaus )      { ANA_CHECK( m_store->record( selectedTaus, m_outContainerName_Taus + systName )); }
           }
   
           sysVecOut->push_back(systName);
         } // close loop on systematic sets available from upstream algo (Jets)
   
         break;
       }
       case PHSYST : // photon systematics
       {
         ANA_MSG_DEBUG(  "Doing  photon systematics");
         bool nomContainerNotFound(false);
   
         // just to check everything is fine
         ANA_MSG_DEBUG("will consider the following PHOTON systematics:" );
         for ( auto it : *sysVec ) { ANA_MSG_DEBUG("\t " << it);  }
   
         // these input containers won't change in the photon syst loop ...
         if( m_useElectrons ) {
           if ( m_store->contains<ConstDataVector<xAOD::ElectronContainer> >(m_inContainerName_Electrons) || m_store->contains<xAOD::ElectronContainer>(m_inContainerName_Electrons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inElectrons, m_inContainerName_Electrons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Electrons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case...");  }
           }
         }
   
         if( m_useMuons ) {
           if ( m_store->contains<ConstDataVector<xAOD::MuonContainer> >(m_inContainerName_Muons) || m_store->contains<xAOD::MuonContainer>(m_inContainerName_Muons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inMuons, m_inContainerName_Muons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Muons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_store->contains<ConstDataVector<xAOD::JetContainer> >(m_inContainerName_Jets) || m_store->contains<xAOD::JetContainer>(m_inContainerName_Jets) ) {
           ANA_CHECK( HelperFunctions::retrieve(inJets, m_inContainerName_Jets, m_event, m_store, msg()) );
         } else {
           nomContainerNotFound = true;
           if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Jets << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
         }
   
         if ( m_useTaus ) {
           if ( m_store->contains<ConstDataVector<xAOD::TauJetContainer> >(m_inContainerName_Taus) || m_store->contains<xAOD::TauJetContainer>(m_inContainerName_Taus) ) {
             ANA_CHECK( HelperFunctions::retrieve(inTaus, m_inContainerName_Taus, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Taus << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( nomContainerNotFound ) {return EL::StatusCode::SUCCESS;}
   
         for( auto systName : *sysVec ) {
   
           if ( systName.empty() ) continue;
   
           // ... instead, the photon input container will be different for each syst
           //
           std::string photon_syst_cont_name = m_inContainerName_Photons + systName;
           ANA_CHECK( HelperFunctions::retrieve(inPhotons, photon_syst_cont_name, 0, m_store, msg()) );
   
           // do the actual OR
           //
           ANA_CHECK( m_ORToolbox.masterTool->removeOverlaps(inElectrons, inMuons, inJets, inTaus, inPhotons));
   
   
           const std::string ORdecor(m_decor);
           if(m_useCutFlow){
             // fill cutflow histograms
             //
             if( m_useElectrons ) fillObjectCutflow(inElectrons);
             if( m_useMuons     ) fillObjectCutflow(inMuons);
             fillObjectCutflow(inJets);
             fillObjectCutflow(inPhotons);
             if( m_useTaus )      fillObjectCutflow(inTaus);
           }
   
           // make a copy of input container(s) with selected objects
           //
           if ( m_createSelectedContainers ) {
             if( m_useElectrons ) selectedElectrons   = new ConstDataVector<xAOD::ElectronContainer>(SG::VIEW_ELEMENTS);
             if( m_useMuons     ) selectedMuons       = new ConstDataVector<xAOD::MuonContainer>(SG::VIEW_ELEMENTS);
             selectedJets        = new ConstDataVector<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
             selectedPhotons     = new ConstDataVector<xAOD::PhotonContainer>(SG::VIEW_ELEMENTS);
             if ( m_useTaus )     selectedTaus    = new ConstDataVector<xAOD::TauJetContainer>(SG::VIEW_ELEMENTS);
           }
   
           // resize containers based on OR decision
           //
           if( m_useElectrons ) { ANA_CHECK( HelperFunctions::makeSubsetCont(inElectrons, selectedElectrons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           if( m_useMuons )     { ANA_CHECK( HelperFunctions::makeSubsetCont(inMuons, selectedMuons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           ANA_CHECK( HelperFunctions::makeSubsetCont(inJets, selectedJets, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           ANA_CHECK( HelperFunctions::makeSubsetCont(inPhotons, selectedPhotons, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           if ( m_useTaus )     { ANA_CHECK( HelperFunctions::makeSubsetCont(inTaus, selectedTaus, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
   
           // add ConstDataVector to TStore
           //
           if ( m_createSelectedContainers ) {
             // a different syst varied container will be stored for each syst variation
             //
             if( m_useElectrons ){ ANA_CHECK( m_store->record( selectedElectrons, m_outContainerName_Electrons + systName )); }
             if( m_useMuons )    { ANA_CHECK( m_store->record( selectedMuons,     m_outContainerName_Muons + systName )); }
             ANA_CHECK( m_store->record( selectedJets,      m_outContainerName_Jets + systName ));
             ANA_CHECK( m_store->record( selectedPhotons,   m_outContainerName_Photons + systName ));
             if ( m_useTaus )    { ANA_CHECK( m_store->record( selectedTaus, m_outContainerName_Taus + systName )); }
           }
   
           sysVecOut->push_back(systName);
         } // close loop on systematic sets available from upstream algo (Photons)
   
         break;
       }
       case TAUSYST : // tau systematics
       {
         ANA_MSG_DEBUG(  "Doing tau systematics");
         bool nomContainerNotFound(false);
   
         // just to check everything is fine
         ANA_MSG_DEBUG("output vector already contains the following TAU systematics:" );
         for ( auto it : *sysVec ) { ANA_MSG_DEBUG("\t " << it);  }
   
         // these input containers won't change in the tau syst loop ...
         if( m_useElectrons ) {
           if ( m_store->contains<ConstDataVector<xAOD::ElectronContainer> >(m_inContainerName_Electrons) || m_store->contains<xAOD::ElectronContainer>(m_inContainerName_Electrons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inElectrons, m_inContainerName_Electrons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Electrons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case...");  }
           }
         }
   
         if( m_useMuons ) {
           if ( m_store->contains<ConstDataVector<xAOD::MuonContainer> >(m_inContainerName_Muons) || m_store->contains<xAOD::MuonContainer>(m_inContainerName_Muons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inMuons, m_inContainerName_Muons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Muons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( m_store->contains<ConstDataVector<xAOD::JetContainer> >(m_inContainerName_Jets) || m_store->contains<xAOD::JetContainer>(m_inContainerName_Jets) ) {
           ANA_CHECK( HelperFunctions::retrieve(inJets, m_inContainerName_Jets, m_event, m_store, msg()) );
         } else {
           nomContainerNotFound = true;
           if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Jets << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
         }
   
         if ( m_usePhotons ) {
           if ( m_store->contains<ConstDataVector<xAOD::PhotonContainer> >(m_inContainerName_Photons) || m_store->contains<xAOD::PhotonContainer>(m_inContainerName_Photons) ) {
             ANA_CHECK( HelperFunctions::retrieve(inPhotons, m_inContainerName_Photons, m_event, m_store, msg()) );
           } else {
             nomContainerNotFound = true;
             if ( m_numEvent == 1 ) { ANA_MSG_WARNING( "Could not find nominal container " << m_inContainerName_Photons << " in xAOD::TStore. Overlap Removal will not be done for the 'all-nominal' case..."); }
           }
         }
   
         if ( nomContainerNotFound ) {return EL::StatusCode::SUCCESS;}
   
         for( auto systName : *sysVec ) {
   
           if ( systName.empty() ) continue;
   
           // ... instead, the tau input container will be different for each syst
           //
           std::string tau_syst_cont_name = m_inContainerName_Taus + systName;
           ANA_CHECK( HelperFunctions::retrieve(inTaus, tau_syst_cont_name, 0, m_store, msg()) );
   
           // do the actual OR
           //
           ANA_CHECK( m_ORToolbox.masterTool->removeOverlaps(inElectrons, inMuons, inJets, inTaus, inPhotons));
   
           const std::string ORdecor(m_decor);
           if(m_useCutFlow){
             // fill cutflow histograms
             //
             if( m_useElectrons ) fillObjectCutflow(inElectrons);
             if( m_useMuons     ) fillObjectCutflow(inMuons);
             fillObjectCutflow(inJets);
             if( m_usePhotons ) fillObjectCutflow(inPhotons);
             fillObjectCutflow(inTaus);
           }
   
           // make a copy of input container(s) with selected objects
           //
           if ( m_createSelectedContainers ) {
             if( m_useElectrons ) selectedElectrons   = new ConstDataVector<xAOD::ElectronContainer>(SG::VIEW_ELEMENTS);
             if( m_useMuons )     selectedMuons       = new ConstDataVector<xAOD::MuonContainer>(SG::VIEW_ELEMENTS);
             selectedJets       = new ConstDataVector<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
             if ( m_usePhotons )  selectedPhotons     = new ConstDataVector<xAOD::PhotonContainer>(SG::VIEW_ELEMENTS);
             selectedTaus       = new ConstDataVector<xAOD::TauJetContainer>(SG::VIEW_ELEMENTS);
           }
   
           // resize containers based on OR decision
           //
           if( m_useElectrons ) { ANA_CHECK( HelperFunctions::makeSubsetCont(inElectrons, selectedElectrons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           if( m_useMuons )     { ANA_CHECK( HelperFunctions::makeSubsetCont(inMuons, selectedMuons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           ANA_CHECK( HelperFunctions::makeSubsetCont(inJets, selectedJets, msg(), ORdecor.c_str(), ToolName::SELECTOR));
           if ( m_usePhotons )  { ANA_CHECK( HelperFunctions::makeSubsetCont(inPhotons, selectedPhotons, msg(), ORdecor.c_str(), ToolName::SELECTOR)); }
           ANA_CHECK( HelperFunctions::makeSubsetCont(inTaus, selectedTaus, msg(), ORdecor.c_str(), ToolName::SELECTOR));
   
           // add ConstDataVector to TStore
           //
           if ( m_createSelectedContainers ) {
             // a different syst varied container will be stored for each syst variation
             //
             if( m_useElectrons ) { ANA_CHECK( m_store->record( selectedElectrons, m_outContainerName_Electrons + systName )); }
             if( m_useMuons )     { ANA_CHECK( m_store->record( selectedMuons,     m_outContainerName_Muons + systName )); }
             ANA_CHECK( m_store->record( selectedJets,      m_outContainerName_Jets + systName ));
             if ( m_usePhotons )  { ANA_CHECK( m_store->record( selectedPhotons,   m_outContainerName_Photons + systName )); }
             ANA_CHECK( m_store->record( selectedTaus, m_outContainerName_Taus + systName ));
           }
   
           sysVecOut->push_back(systName);
         } // close loop on systematic sets available from upstream algo (Taus)
   
         break;
       }
       default :
       {
         ANA_MSG_ERROR("Unknown systematics type. Aborting");
         return EL::StatusCode::FAILURE;
       }
     } // end of switch
   
   
     return EL::StatusCode::SUCCESS;
   
   }
   
   EL::StatusCode OverlapRemover :: setCutFlowHist( )
   {
   
     if ( m_useCutFlow ) {
   
       // retrieve the file in which the cutflow hists are stored
       //
       TFile *file     = wk()->getOutputFile (m_cutFlowStreamName);
   
       // retrieve the object cutflow
       //
       m_el_cutflowHist_1  = (TH1D*)file->Get("cutflow_electrons_1");
       m_el_cutflow_OR_cut   = m_el_cutflowHist_1->GetXaxis()->FindBin("OR_cut");
       m_mu_cutflowHist_1  = (TH1D*)file->Get("cutflow_muons_1");
       m_mu_cutflow_OR_cut   = m_mu_cutflowHist_1->GetXaxis()->FindBin("OR_cut");
       m_jet_cutflowHist_1   = (TH1D*)file->Get("cutflow_jets_1");
       m_jet_cutflow_OR_cut  = m_jet_cutflowHist_1->GetXaxis()->FindBin("OR_cut");
       m_ph_cutflowHist_1  = (TH1D*)file->Get("cutflow_photons_1");
       m_ph_cutflow_OR_cut   = m_ph_cutflowHist_1->GetXaxis()->FindBin("OR_cut");
       m_tau_cutflowHist_1   = (TH1D*)file->Get("cutflow_taus_1");
       m_tau_cutflow_OR_cut  = m_tau_cutflowHist_1->GetXaxis()->FindBin("OR_cut");
     }
   
     return EL::StatusCode::SUCCESS;
   }
   
   EL::StatusCode OverlapRemover :: setCounters( )
   {
     m_numEvent      = 0;
     m_numObject     = 0;
   
     return EL::StatusCode::SUCCESS;
   }