JetInputElRemovalTool Class Reference

Selec electrons and store a vector of cluster free of the electron ones. More...

#include <JetInputElRemovalTool.h>

Inheritance diagram for JetInputElRemovalTool:

Collaboration diagram for JetInputElRemovalTool:

Public Member Functions
	JetInputElRemovalTool (const std::string &t)
	~JetInputElRemovalTool ()
StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...
int	execute () const
	Method to be called for each event. More...
StatusCode	finalize ()
int	fillSelectedClusters (std::vector< const xAOD::Electron * > &selected_el, ConstDataVector< xAOD::CaloClusterContainer > &selected_cl) const
	: Select TopoClusters away of the electrons may select : More...
int	fillSelectedClustersInJets (std::vector< const xAOD::Electron * > &selected_el, ConstDataVector< xAOD::CaloClusterContainer > &selected_cl) const
int	fillSelectedTracks (std::vector< const xAOD::Electron * > &selected_el, ConstDataVector< xAOD::TrackParticleContainer > &selected_trk) const
virtual void	print () const
	Print the state of the tool. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const
virtual int	inputContainerNames (std::vector< std::string > &connames)
	Method to return the list of input containers. More...
virtual int	outputContainerNames (std::vector< std::string > &connames)
	Method to return the list of output containers. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
using	ClOutHandleKey = SG::WriteHandleKey< ConstDataVector< xAOD::CaloClusterContainer > >
using	TrkOutHandleKey = SG::WriteHandleKey< ConstDataVector< xAOD::TrackParticleContainer > >
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< const xAOD::Electron * >	selectElectron () const
	Select the electron of the event My select : More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::string	m_elIDname = "DFCommonElectronsLHTight"
float	m_elPt = 25000
bool	m_useOnlyclInJets =false
float	m_clRemovRadius =0.15
float	m_clEMFrac = 0.8
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trkInputContainer_key
SG::ReadHandleKey< xAOD::JetContainer >	m_jetInputContainer_key
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clInputContainer_key
SG::ReadHandleKey< xAOD::EgammaContainer >	m_elInputContainer_key
ClOutHandleKey	m_clOutputContainer_key
TrkOutHandleKey	m_trkOutputContainer_key
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Selec electrons and store a vector of cluster free of the electron ones.

Definition at line 41 of file JetInputElRemovalTool.h.

Member Typedef Documentation

ClOutHandleKey

using JetInputElRemovalTool::ClOutHandleKey = SG::WriteHandleKey<ConstDataVector<xAOD::CaloClusterContainer> >

private

Definition at line 106 of file JetInputElRemovalTool.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TrkOutHandleKey

using JetInputElRemovalTool::TrkOutHandleKey = SG::WriteHandleKey<ConstDataVector<xAOD::TrackParticleContainer> >

private

Definition at line 111 of file JetInputElRemovalTool.h.

Constructor & Destructor Documentation

JetInputElRemovalTool()

JetInputElRemovalTool::JetInputElRemovalTool

(

const std::string &

t

)

Definition at line 20 of file JetInputElRemovalTool.cxx.

  :AsgTool(t)
   
  ,m_elIDname("DFCommonElectronsLHTight")
  ,m_elPt(25000)
  ,m_useOnlyclInJets(false)
  ,m_clRemovRadius(0.15)
  ,m_clEMFrac(0.8)
{
  declareProperty("ElectronQuality",m_elIDname);
  declareProperty("ElectronMinpT",m_elPt);
  declareProperty("ClusterRemovRadius",m_clRemovRadius);
  declareProperty("ClusterEMFrac",m_clEMFrac);
  declareProperty("UseOnlyclInJets",m_useOnlyclInJets);
 
  declareProperty("TrkInputContainer",
                  m_trkInputContainer_key="InDetTrackParticles");
 
  declareProperty("JetINputContainer",
                  m_jetInputContainer_key="AntiKt4EMTopoJets");
 
 
  declareProperty("ClusterContainerName",
                  m_clInputContainer_key="CaloCalTopoClusters");
 
  declareProperty("ElectronContainerName",
                  m_elInputContainer_key="Electrons");
 
  declareProperty("ClusterNoElName",
                  m_clOutputContainer_key="CaloCalTopoClustersNoEl");
 
  declareProperty("TrkOutputContainer",
                  m_trkOutputContainer_key="InDetTrackParticlesNoEl");
 
  
}

~JetInputElRemovalTool()

JetInputElRemovalTool::~JetInputElRemovalTool ( )

default

Member Function Documentation

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

int JetInputElRemovalTool::execute ( ) const

virtual

Method to be called for each event.

Returns 0 for success.

Implements IJetExecuteTool.

Definition at line 75 of file JetInputElRemovalTool.cxx.

                                        {
 
  using OutContTypeCl = ConstDataVector<xAOD::CaloClusterContainer>;
  OutContTypeCl* filtered_clusters = new OutContTypeCl(SG::VIEW_ELEMENTS);
  
  //Select the electrons with given properties
  std::vector<const xAOD::Electron*> el_vector=selectElectron();
  
  //Select the clusters away from electrons
  
  //Use all the clusters in the event
  if(!m_useOnlyclInJets){
    fillSelectedClusters(el_vector,*filtered_clusters);
  }
  //Use only the cluster from jets in the event
  else{
    fillSelectedClustersInJets(el_vector,*filtered_clusters);
  }
  
  //Record clusters vector
  {
    auto handle = SG::makeHandle(m_clOutputContainer_key);
    if(!handle.record(std::unique_ptr<OutContTypeCl>(filtered_clusters))){
      ATH_MSG_WARNING("Unable to record new clusters vector");
      return 1;
    }
  }
  
  //Store vector only if data vector name not empty 
  if (!m_trkInputContainer_key.key().empty()){
 
    using OutContTypeTr = ConstDataVector<xAOD::TrackParticleContainer>;
 
    OutContTypeTr* filtered_tracks = new OutContTypeTr(SG::VIEW_ELEMENTS) ;
 
    fillSelectedTracks(el_vector,*filtered_tracks);
  
    auto handle_out = SG::makeHandle(m_trkOutputContainer_key);
    if(!handle_out.record(std::unique_ptr<OutContTypeTr>(filtered_tracks))){
      ATH_MSG_WARNING("Unable to record new tracks vector");
      return 1;
    }
  }
 
  return 0;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

fillSelectedClusters()

int JetInputElRemovalTool::fillSelectedClusters	(	std::vector< const xAOD::Electron * > &	selected_el,
		ConstDataVector< xAOD::CaloClusterContainer > &	selected_cl
	)		const

: Select TopoClusters away of the electrons may select :

• Match radius
• Min EM frac of cluster to be removed

Create vector of cluster

Returns

The number of removed clusters

Definition at line 172 of file JetInputElRemovalTool.cxx.

                                                                                                                                                      {
  
  //Initialize variables
  
  int countRemoved_clusters=0;
  double propEM=0;
  
  //Get the Topo clusters of the event
 
  auto handle = SG::makeHandle(m_clInputContainer_key);
  if(!handle.isValid()){
    ATH_MSG_WARNING("Unable to retrieve clusters");
    return 0;
  }
    
  const auto *clusterContainer = handle.cptr();
  
  //Loop over all the clusters
  for (const xAOD::CaloCluster* cluster_itr : *clusterContainer){
    
    //Compute the EMP proportion of the cluster
    propEM=0;
    
    double EMB_Enegy=cluster_itr->eSample(CaloSampling::CaloSample::PreSamplerB)+cluster_itr->eSample(CaloSampling::CaloSample::EMB1)+cluster_itr->eSample(CaloSampling::CaloSample::EMB2)+cluster_itr->eSample(CaloSampling::CaloSample::EMB3);
    
    double EMEC_Energy=cluster_itr->eSample(CaloSampling::CaloSample::PreSamplerE)+cluster_itr->eSample(CaloSampling::CaloSample::EME1)+cluster_itr->eSample(CaloSampling::CaloSample::EME2)+cluster_itr->eSample(CaloSampling::CaloSample::EME3);
    
    //Remove clusters w/o energy
    if (cluster_itr->rawE()==0) {
      continue;
    }
    propEM=(EMB_Enegy+EMEC_Energy)/cluster_itr->rawE();
    
    
    
    //Check if close to electron
    bool closetoel=false;
    
    std::vector<const xAOD::Electron*>::iterator it=selected_el.begin();
    std::vector<const xAOD::Electron*>::iterator itE =selected_el.end();
    //For each el in the vector
    for ( ; it != itE ;++it){
      ATH_MSG_DEBUG( "Deleta R electron cluster = "<<(*it)->p4().DeltaR(cluster_itr->p4()) );
      //Check if electron close to cluster
      //if ((*it)->p4().DeltaR(cluster_itr->p4())<m_clRemovRadius){
      if ((*it)->caloCluster()->p4().DeltaR(cluster_itr->p4())<m_clRemovRadius){
    
    //if (TMath::Abs((*it)->caloCluster()->etaBE(2))<1.52 && TMath::Abs((*it)->caloCluster()->etaBE(2))>1.37){
    if (TMath::Abs(cluster_itr->eta())<1.52 && TMath::Abs(cluster_itr->eta())>1.37){
      closetoel=true;
    }
    
    //Check if the proportion of EM enegy above threshold
    else if(propEM>=m_clEMFrac){
      closetoel=true;
    }
      }
      
    }
    //If not close enough or not enough EM energy the cluster is kept
    if (!closetoel){
      selected_cl.push_back(dynamic_cast<const xAOD::CaloCluster*> (cluster_itr));
    }
    else{ //else it is removed
      countRemoved_clusters+=1;
    }
  }//End loop over clusters
  
  
  //ANA_CHECK(evtStore()->record( filtered_clusters , "CaloCalTopoClustersNoElec" ));
  
  return  countRemoved_clusters;
}//End of SelectClusters()

fillSelectedClustersInJets()

int JetInputElRemovalTool::fillSelectedClustersInJets	(	std::vector< const xAOD::Electron * > &	selected_el,
		ConstDataVector< xAOD::CaloClusterContainer > &	selected_cl
	)		const

Definition at line 254 of file JetInputElRemovalTool.cxx.

                                                                                                                                                            {
  
  int countRemoved_clusters=0;
  double propEM=0;
  
  auto handle = SG::makeHandle(m_jetInputContainer_key);
  if(!handle.isValid()){
    ATH_MSG_WARNING("Unable to retrieve jets");
    return 0;
  }
 
  const auto *jetsContainer = handle.cptr();
 
  // const xAOD::JetContainer* jetsContainer;
  // StatusCode sc=evtStore()->retrieve( jetsContainer, m_jetINputContainer );
  // if (sc.isFailure()){
  //   ATH_MSG_WARNING("Unable to retrieve jets");
  //   return 0;
  // }
  
  for (const xAOD::Jet* jet_itr : *jetsContainer){
    
    
    const xAOD::JetConstituentVector jetcons = jet_itr->getConstituents();
    
    
    if (!jetcons.isValid()) continue ;
    
    xAOD::JetConstituentVector::iterator jetcons_it = jetcons.begin();
    xAOD::JetConstituentVector::iterator jetcons_itE = jetcons.end();
    
    for( ; jetcons_it != jetcons_itE; ++jetcons_it){
      
      propEM=0;
      const xAOD::CaloCluster* cluster_itr= dynamic_cast<const xAOD::CaloCluster*> (jetcons_it->rawConstituent());
      
      
      double EMB_Enegy=cluster_itr->eSample(CaloSampling::CaloSample::PreSamplerB)+cluster_itr->eSample(CaloSampling::CaloSample::EMB1)+cluster_itr->eSample(CaloSampling::CaloSample::EMB2)+cluster_itr->eSample(CaloSampling::CaloSample::EMB3);
      
      double EMEC_Energy=cluster_itr->eSample(CaloSampling::CaloSample::PreSamplerE)+cluster_itr->eSample(CaloSampling::CaloSample::EME1)+cluster_itr->eSample(CaloSampling::CaloSample::EME2)+cluster_itr->eSample(CaloSampling::CaloSample::EME3);
      
      
      //Remove Clusters w/o energy
      if (cluster_itr->rawE()==0) {
    continue;
      };
      
      propEM=(EMB_Enegy+EMEC_Energy)/cluster_itr->rawE();
      
      bool closetoel=false;
      std::vector<const xAOD::Electron*>::iterator it=selected_el.begin();
      std::vector<const xAOD::Electron*>::iterator itE =selected_el.end();
      
      for ( ; it != itE ;++it){
    ATH_MSG_DEBUG( "Deleta R electron cluster = "<<(*it)->p4().DeltaR(cluster_itr->p4()) );
    if ((*it)->p4().DeltaR(cluster_itr->p4())<m_clRemovRadius){
      if(propEM>=m_clEMFrac){
        closetoel=true;
      }
    }
    
      }
      if (!closetoel){
    selected_cl.push_back(dynamic_cast<const xAOD::CaloCluster*> (cluster_itr));
      }
      else{
    countRemoved_clusters+=1;
      }
    }//End loop over clusters
    
  }//End loop over jets
  
  //ANA_CHECK(evtStore()->record( filtered_clusters , "CaloCalTopoClustersNoElec" ));
  
  return  countRemoved_clusters;
}

fillSelectedTracks()

int JetInputElRemovalTool::fillSelectedTracks	(	std::vector< const xAOD::Electron * > &	selected_el,
		ConstDataVector< xAOD::TrackParticleContainer > &	selected_trk
	)		const

Definition at line 332 of file JetInputElRemovalTool.cxx.

                                                                                                                                                      {
  
  int countRemoved_trk=0;
  
  auto handle = SG::makeHandle(m_trkInputContainer_key);
  if(!handle.isValid()){
    ATH_MSG_WARNING("Unable to retrieve jets");
    return 0;
  }
 
  const auto *tkPrtclContainer = handle.cptr();
 
  // PS 
  // const xAOD::TrackParticleContainer* tkPrtclContainer;
  // StatusCode sc=evtStore()->retrieve( tkPrtclContainer, m_trkInputContainer );
  // if (sc.isFailure()){
  //   ATH_MSG_WARNING("Unable to retrieve jets");
  //   return 0;
  // }
  
  //Loop over all the tracks
  for (const xAOD::TrackParticle* trk_itr : *tkPrtclContainer){
    
    //Check if close to electron
    bool is_eltrk=false;
    
    std::vector<const xAOD::Electron*>::iterator it=selected_el.begin();
    std::vector<const xAOD::Electron*>::iterator itE =selected_el.end();
    //For each el in the vector
    for ( ; it != itE ;++it){
      
      const xAOD::TrackParticle* el_trk=(*it)->trackParticle();
      
      ATH_MSG_DEBUG( "Deleta R electron trkack = "<<(*it)->p4().DeltaR(trk_itr->p4()) );
      //Check if electron close to cluster
      if (el_trk==trk_itr){
    is_eltrk=true;
      }
      
    }
    //If not close enough or not enough EM energy the cluster is kept
    if (!is_eltrk){
      selected_cl.push_back(dynamic_cast<const xAOD::TrackParticle*> (trk_itr));
    }
    else{ //else it is removed
      countRemoved_trk+=1;
    }
  }//End loop over tracks
  
  
  return  countRemoved_trk;
}

finalize()

StatusCode JetInputElRemovalTool::finalize

(

)

Definition at line 122 of file JetInputElRemovalTool.cxx.

                                          {
  return StatusCode::SUCCESS;
}

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void *  ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T >

const T* asg::AsgTool::getProperty ( const std::string &  name ) const

inherited

Get one of the tool's properties.

initialize()

StatusCode JetInputElRemovalTool::initialize ( )

virtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 60 of file JetInputElRemovalTool.cxx.

                                            {
  ATH_MSG_INFO("Initializing tool " << name() << "...");
  ATH_MSG_DEBUG("initializing version with data handles");
 
  ATH_CHECK(m_trkInputContainer_key.initialize());
  ATH_CHECK(m_jetInputContainer_key.initialize());
  ATH_CHECK(m_clInputContainer_key.initialize());
  ATH_CHECK(m_elInputContainer_key.initialize());
  ATH_CHECK(m_clOutputContainer_key.initialize()); 
  ATH_CHECK(m_trkOutputContainer_key.initialize()); 
  
  return StatusCode::SUCCESS;
}

inputContainerNames()

int IJetExecuteTool::inputContainerNames ( std::vector< std::string > &  connames )

virtualinherited

Method to return the list of input containers.

The names of required input containers are appended to connames. Returns nonzero for error. Default returns 0 and adds no names.

Reimplemented in JetRecTool.

Definition at line 11 of file IJetExecuteTool.cxx.

                                                              {
  return 0;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputContainerNames()

int IJetExecuteTool::outputContainerNames ( std::vector< std::string > &  connames )

virtualinherited

Method to return the list of output containers.

The names of produced output containers are appended to connames. Returns nonzero for error. Default returns 0 and adds no names.

Reimplemented in JetRecTool.

Definition at line 17 of file IJetExecuteTool.cxx.

                                                               {
  return 0;
}

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

selectElectron()

std::vector< const xAOD::Electron * > JetInputElRemovalTool::selectElectron ( ) const

private

Select the electron of the event My select :

• pt cut
• electron quality

Returns

Load an electron Vector in SG

Definition at line 128 of file JetInputElRemovalTool.cxx.

                                                                         {
 
  std::vector<const xAOD::Electron*> selected_electrons_v;  
 
  auto handle = SG::makeHandle(m_elInputContainer_key);
  if(!handle.isValid()){
    ATH_MSG_WARNING("Unable to retrieve electrons");
    return selected_electrons_v;
  }
    
  const auto *electrons = handle.cptr();
 
  selected_electrons_v.clear();
  bool isTight=false;
 
  SG::Decorator< char > idflagDec( m_elIDname );
  for (const auto *electron_itr : *electrons){
    
    isTight=false;
    
    //Select only el with given quality
    if (idflagDec (*electron_itr)==1){
      isTight=true;
    }
    
    if (! isTight) continue ;
    
    
    //Select only el with pt>25GeV
    if (electron_itr->pt()<m_elPt) continue;
    
    selected_electrons_v.push_back(dynamic_cast<const xAOD::Electron*>(electron_itr));
    
    
  }
  
  return selected_electrons_v ;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_clEMFrac

float JetInputElRemovalTool::m_clEMFrac = 0.8

private

Definition at line 99 of file JetInputElRemovalTool.h.

m_clInputContainer_key

SG::ReadHandleKey<xAOD::CaloClusterContainer> JetInputElRemovalTool::m_clInputContainer_key

private

Definition at line 103 of file JetInputElRemovalTool.h.

m_clOutputContainer_key

ClOutHandleKey JetInputElRemovalTool::m_clOutputContainer_key

private

Definition at line 109 of file JetInputElRemovalTool.h.

m_clRemovRadius

float JetInputElRemovalTool::m_clRemovRadius =0.15

private

Definition at line 98 of file JetInputElRemovalTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_elIDname

std::string JetInputElRemovalTool::m_elIDname = "DFCommonElectronsLHTight"

private

Definition at line 94 of file JetInputElRemovalTool.h.

m_elInputContainer_key

SG::ReadHandleKey<xAOD::EgammaContainer> JetInputElRemovalTool::m_elInputContainer_key

private

Definition at line 104 of file JetInputElRemovalTool.h.

m_elPt

float JetInputElRemovalTool::m_elPt = 25000

private

Definition at line 95 of file JetInputElRemovalTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_jetInputContainer_key

SG::ReadHandleKey<xAOD::JetContainer> JetInputElRemovalTool::m_jetInputContainer_key

private

Definition at line 102 of file JetInputElRemovalTool.h.

m_trkInputContainer_key

SG::ReadHandleKey<xAOD::TrackParticleContainer> JetInputElRemovalTool::m_trkInputContainer_key

private

Definition at line 101 of file JetInputElRemovalTool.h.

m_trkOutputContainer_key

TrkOutHandleKey JetInputElRemovalTool::m_trkOutputContainer_key

private

Definition at line 114 of file JetInputElRemovalTool.h.

m_useOnlyclInJets

bool JetInputElRemovalTool::m_useOnlyclInJets =false

private

Definition at line 96 of file JetInputElRemovalTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• JetInputElRemovalTool.h
• JetInputElRemovalTool.cxx