TrigIsoHPtTrackTriggerHypoTool Class Reference

Generated the decision for hypo thats triggers on high pt isolated tracks. More...

#include <TrigIsoHPtTrackTriggerHypoTool.h>

Inheritance diagram for TrigIsoHPtTrackTriggerHypoTool:

Collaboration diagram for TrigIsoHPtTrackTriggerHypoTool:

Classes
struct	TrackInfo

Public Member Functions
	TrigIsoHPtTrackTriggerHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TrigIsoHPtTrackTriggerHypoTool ()
virtual StatusCode	initialize () override
StatusCode	decide (std::vector< TrackInfo > &decisions) const
	decides upon a collection of tracks More...
bool	decideOnSingleObject (const xAOD::TrackParticle_v1 *track, const xAOD::TrackParticleContainer *AllTracks, size_t cutIndex) const
	Auxiluary method, single track selection. More...
StatusCode	inclusiveSelection (std::vector< TrackInfo > &input) const
	actual implementation of decide, in case of inclusive selection ( one object cut ) More...
StatusCode	multiplicitySelection (std::vector< TrackInfo > &input) const
	actual implementation of decide, in case of multiple objects selection ( independentone ) More...
StatusCode	markPassing (std::vector< TrackInfo > &input, const std::set< size_t > &passing) const
	stores decisions for all object passing multiple cuts The passsingSelection inner vectors have to have size == input size 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

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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
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
HLT::Identifier	m_decisionId
Gaudi::Property< std::vector< float > >	m_TrackPt { this, "MinTrackPt", { float( 50.0*Gaudi::Units::GeV ) }, "Track pT requirement" }
Gaudi::Property< std::vector< float > >	m_TrackEta { this, "MinTrackEta", { float(2.5 ) }, "Track Eta requirement" }
Gaudi::Property< std::vector< float > >	m_Trackd0 { this, "MaxTrackd0", {5.}, "Maximum Track d0 allowed" }
Gaudi::Property< std::vector< float > >	m_Trackd0Sig { this, "MaxTrackd0Sig", {5.}, "Maximum Track d0 Sig allowed" }
Gaudi::Property< std::vector< unsigned > >	m_TrackNPixHits { this, "MinTrackNPixHits", {2}, "Minimum number of pixel hits required from the trigger" }
Gaudi::Property< std::vector< unsigned > >	m_TrackNSCTHits { this, "MinTrackNSCTHits", {5}, "Minimum number of SCT hits required from the trigger" }
Gaudi::Property< std::vector< bool > >	m_doIso { this, "EnableTrackIsolation", {false}, "If track based isolation should be applied or not? "}
Gaudi::Property< std::vector< bool > >	m_IsoCum { this, "EnableCumalitiveIsolation", {false}, "Instead of checking if one track is above a certain pT threshold, add up all tracks for isolation"}
Gaudi::Property< std::vector< float > >	m_IsoDR { this, "TrackIsoCone", {0.3}, "Isolation requirment over the main track" }
Gaudi::Property< std::vector< float > >	m_IsoPt { this, "MinIsoTrackPt", {float( 5.0*Gaudi::Units::GeV )}, "Min pT requirment of other tracks to be considered for isolation" }
size_t	m_multiplicity = 1
ToolHandle< GenericMonitoringTool >	m_monTool { this, "MonTool", "", "Monitoring tool" }
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

Generated the decision for hypo thats triggers on high pt isolated tracks.

Author

Ismet Siral ismet.nosp@m..sir.nosp@m.al@ce.nosp@m.rn.c.nosp@m.h - University of Oregon

Definition at line 23 of file TrigIsoHPtTrackTriggerHypoTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrigIsoHPtTrackTriggerHypoTool()

TrigIsoHPtTrackTriggerHypoTool::TrigIsoHPtTrackTriggerHypoTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 17 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

  : AthAlgTool( type, name, parent ),
    m_decisionId( HLT::Identifier::fromToolName( name ) ) {}

~TrigIsoHPtTrackTriggerHypoTool()

TrigIsoHPtTrackTriggerHypoTool::~TrigIsoHPtTrackTriggerHypoTool ( )

virtual

Definition at line 56 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

{}

Member Function Documentation

decide()

StatusCode TrigIsoHPtTrackTriggerHypoTool::decide

(

std::vector< TrackInfo > &

decisions

)

const

decides upon a collection of tracks

Definition at line 283 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

                                                                                       {
  // handle the simplest and most common case ( multiplicity == 1 ) in easiest possible manner
  if ( m_TrackPt.size() == 1 ) {
    return inclusiveSelection( input );
 
  } else {    
    return multiplicitySelection( input );    
  }
 
  return StatusCode::SUCCESS;
}

decideOnSingleObject()

bool TrigIsoHPtTrackTriggerHypoTool::decideOnSingleObject	(	const xAOD::TrackParticle_v1 *	track,
		const xAOD::TrackParticleContainer *	AllTracks,
		size_t	cutIndex
	)		const

Auxiluary method, single track selection.

Definition at line 58 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

                                                                                                                                                                 {
  auto cutCounter = Monitored::Scalar<int>( "CutCounter", -1 );  
  auto cutIndexM  = Monitored::Scalar<int>( "CutIndex", cutIndex );  // one can do 2D plots for each cut independently
 
  auto MONtrackPt     = Monitored::Scalar( "trackPt", -999. );
  auto MONtrackd0    = Monitored::Scalar( "trackd0", -999. );
  auto MONtrackNPixHits   = Monitored::Scalar( "trackNPixHits", -999. );
  auto MONtrackNSCTHits   = Monitored::Scalar( "trackNSCTHits", -999. );
  auto MONtrackd0Sig   = Monitored::Scalar( "trackd0Sig", -999. );
  auto MONtrackEta     = Monitored::Scalar( "trackEta", -999. );
  auto MONtrackIsoPt   = Monitored::Scalar( "trackIsoPt", -999. );
  auto MONtrackAggrIsoPt   = Monitored::Scalar( "trackAggrIsoPt", -999. );
  auto monitorIt  = Monitored::Group( m_monTool, cutCounter, cutIndexM,
                      MONtrackPt, MONtrackEta, 
                      MONtrackd0, MONtrackd0Sig,
                      MONtrackNPixHits, MONtrackNSCTHits, 
                      MONtrackIsoPt, MONtrackAggrIsoPt   
                      );
 
 
 
 
  //Checking Track pT Requirments
  auto trackPt= (track)->pt();
  if( trackPt < m_TrackPt[cutIndex] ) { // Check track pT requirments 
    ATH_MSG_DEBUG( "Fails pt cut" << trackPt << " < " << m_TrackPt[cutIndex] );
    return false;
 
  }
  cutCounter++;
 
 
  //Checking Track Eta Requirments
  auto trackEta=std::abs( (track)->p4().Eta() );
  if(  trackEta > m_TrackEta[cutIndex] ) { // Check track pT requirments 
    ATH_MSG_DEBUG( "Fails Eta cut" << trackEta << " > " << m_TrackEta[cutIndex] );
    return false;
 
  }
  cutCounter++;
 
 
  
  //Checking Track d0 Requirments
  auto trackd0= std::abs((track)->d0());
  if( trackd0 > m_Trackd0[cutIndex]) {
    ATH_MSG_DEBUG( "Fails d0 cut" << trackd0 << " > " << m_Trackd0[cutIndex] );
    return false;
 
  }
  cutCounter++;
 
 
  //Checking Track d0 Sig Requirments
  auto trackd0Sig= std::abs(xAOD::TrackingHelpers::d0significance(track));
  if( trackd0Sig > m_Trackd0Sig[cutIndex]) {
    ATH_MSG_DEBUG( "Fails d0 Sig cut" << trackd0Sig << " > " << m_Trackd0Sig[cutIndex] );
    return false;
 
  }
  cutCounter++;
 
 
  //Attempt to read track summary, and save info on number of pixels
  uint8_t trackNPixHits=0;
  if ( ! (track)->summaryValue(trackNPixHits,xAOD::numberOfPixelHits )) { // Cannot obtain the track summary
    ATH_MSG_DEBUG( "Failed to retrieve pedigree parameters");  
    return  false;
  }
  ATH_MSG_DEBUG( "Succesfully retrieved pedigree parameters");  
  cutCounter++;
 //Attempt to read track summary, and save info on number of SCT hits
  uint8_t trackNSCTHits=0;
  if ( ! (track)->summaryValue(trackNSCTHits,xAOD::numberOfSCTHits )) { // Cannot obtain the track summary
    ATH_MSG_DEBUG( "Failed to retrieve pedigree parameters");  
    return  false;
  }
  ATH_MSG_DEBUG( "Succesfully retrieved pedigree parameters");  
  cutCounter++;
 
 
 
  //Checking Track Min number of Pix Hits Requirments
  if( trackNPixHits <= m_TrackNPixHits[cutIndex] ){
 
    ATH_MSG_DEBUG( "Fails numperOfPixelHits cut" << trackNPixHits  << " <= " << m_TrackNPixHits[cutIndex]  );
    return false;
  }
  cutCounter++;    
 
 
  //Checking Track Min number of SCT Hits Requirments
  if( trackNSCTHits <= m_TrackNSCTHits[cutIndex] ){
 
    ATH_MSG_DEBUG( "Fails numperOfSCTHits cut" << trackNSCTHits  << " <= " << m_TrackNSCTHits[cutIndex]  );
    return false;
  }
  cutCounter++;    
 
 
  //Definning a cumlative pT variable that adds up the momentum of all tracks
 
  //If isolation is applied, loop over all tracks, and veto the event if there is a track above a certain threshold in the isolation cone
  if (m_doIso[cutIndex]) {
    float CumulativePT = 0.0;
    
    for (auto trackIter = AllTracks->begin(); trackIter != AllTracks->end(); ++trackIter){
 
      //Skip the track that is out of DR
      if( (*trackIter)==track) continue;
      if (track->p4().DeltaR((*trackIter)->p4()) > m_IsoDR[cutIndex] ) continue;
 
      //Skip the track that doens't have many Pixel and SCT Hits (Quality Check)
      uint8_t iterPix=0;
      if ( ! (*trackIter)->summaryValue(iterPix,xAOD::numberOfPixelHits ))  
    continue;
      uint8_t iterSCT=0;
      if ( ! (*trackIter)->summaryValue(iterSCT,xAOD::numberOfSCTHits )) 
    continue;
 
      if (iterPix<=m_TrackNPixHits[cutIndex] ) continue;
      if (iterSCT<=2 ) continue;
 
 
      //If cumalitve, add up the momentum of the track, if it's a bove a certain threshold kill the trac
 
      if(m_IsoCum[cutIndex]){
    CumulativePT+=(*trackIter)->pt();
    if(CumulativePT>=m_IsoPt[cutIndex]) {
      MONtrackAggrIsoPt=CumulativePT;
      ATH_MSG_DEBUG( "Fails Cum Isolation cut"  );    
      return false;
    }
      }
      //If not cumlaitve, veto the track only if one track is bigger then the threshold
      else {
    if ((*trackIter)->pt() > MONtrackIsoPt ) {
      MONtrackIsoPt=(*trackIter)->pt();
    }
 
    if( (*trackIter)->pt()>=m_IsoPt[cutIndex] ) {
      ATH_MSG_DEBUG( "Fails Isolation cut"  );    
      return false;
    }
      }
 
 
     
    }
 
    MONtrackAggrIsoPt=CumulativePT;
    cutCounter++;
  }
 
  //Monitorung histograms are filled at the end, only if they pass the selection. (For optimisation studies)
  MONtrackNPixHits=trackNPixHits;
  MONtrackNSCTHits=trackNSCTHits; 
  MONtrackPt= trackPt;
  MONtrackEta= trackEta;
  MONtrackd0= trackd0;
  MONtrackd0Sig= trackd0Sig;
 
 
 
  ATH_MSG_DEBUG( "Passed selection" );
  return  true;
 
}

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; }

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

inclusiveSelection()

StatusCode TrigIsoHPtTrackTriggerHypoTool::inclusiveSelection

(

std::vector< TrackInfo > &

input

)

const

actual implementation of decide, in case of inclusive selection ( one object cut )

Definition at line 227 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

                                                                                                 {
    for ( auto i: input ) {
 
      if ( i.previousDecisionsIDs.count( m_decisionId.numeric() ) == 0 ) {
    continue;
      }
 
      auto objDecision = decideOnSingleObject( i.track, i.AllTracks, 0 );
      if ( objDecision == true ) {
 
    addDecisionID( m_decisionId.numeric(), i.decision  );
      }
    }
    return StatusCode::SUCCESS;
}

initialize()

StatusCode TrigIsoHPtTrackTriggerHypoTool::initialize ( )

overridevirtual

Definition at line 23 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

                                                       {
  
  if ( !m_monTool.empty() ) CHECK( m_monTool.retrieve() );
 
  ATH_MSG_VERBOSE( "Initialization completed successfully:" );
 
  //Track Trigger Kinematic Requirments
  ATH_MSG_VERBOSE( "MaxTrackPt           = " << m_TrackPt ); 
  ATH_MSG_VERBOSE( "MaxTrackEta          = " << m_TrackEta ); 
  ATH_MSG_VERBOSE( "MaxTrackd0           = " << m_Trackd0 );
  ATH_MSG_VERBOSE( "MaxTrackd0Sig        = " << m_Trackd0Sig );
  ATH_MSG_VERBOSE( "MinTrackNPixHits     = " << m_TrackNPixHits );
  ATH_MSG_VERBOSE( "MinTrackNSCTHits     = " << m_TrackNSCTHits );
  //Track Trigger Isolation Requirments
  ATH_MSG_VERBOSE( "TrackIsoCone         = " << m_IsoDR );
  ATH_MSG_VERBOSE( "MinIsoTrackPt        = " << m_IsoPt );
  ATH_MSG_VERBOSE( "EnableTrackIsolation = " << m_doIso );
  ATH_MSG_VERBOSE( "EnableCumulIsolation = " << m_IsoCum );
 
  std::vector<size_t> sizes( {m_TrackPt.size(), m_TrackEta.size(), m_Trackd0.size( ), m_Trackd0Sig.size(), m_TrackNPixHits.size() ,  m_TrackNSCTHits.size() , m_doIso.size() , m_IsoDR.size() , m_IsoPt.size() } );
 
 
  if ( *std::min_element( sizes.begin(), sizes.end() ) != *std::max_element( sizes.begin(), sizes.end() )  ) {
    ATH_MSG_ERROR( "Missconfiguration, cut properties listed above ( when INFO ) have different dimensions shortest: " <<  *std::min_element( sizes.begin(), sizes.end() ) << " longest " << *std::max_element( sizes.begin(), sizes.end() ) );
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_VERBOSE( "Tool configured for chain/id: " << m_decisionId  );
 
  return StatusCode::SUCCESS;
}

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.

markPassing()

StatusCode TrigIsoHPtTrackTriggerHypoTool::markPassing	(	std::vector< TrackInfo > &	input,
		const std::set< size_t > &	passing
	)		const

stores decisions for all object passing multiple cuts The passsingSelection inner vectors have to have size == input size

Definition at line 244 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

                                                                                                                         {
 
  for ( auto idx: passing ) 
    addDecisionID( m_decisionId.numeric(), input[idx].decision );
  return StatusCode::SUCCESS;
 
}

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);
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

multiplicitySelection()

StatusCode TrigIsoHPtTrackTriggerHypoTool::multiplicitySelection

(

std::vector< TrackInfo > &

input

)

const

actual implementation of decide, in case of multiple objects selection ( independentone )

Definition at line 253 of file TrigIsoHPtTrackTriggerHypoTool.cxx.

                                                                                                    {
  HLT::Index2DVec passingSelection( m_multiplicity );
  
  for ( size_t cutIndex = 0; cutIndex < m_multiplicity; ++ cutIndex ) {
    size_t trkIndex{ 0 };
    for ( auto trkIter =  input.begin(); trkIter != input.end(); ++trkIter, ++trkIndex ) {
      
      if ( trkIter->previousDecisionsIDs.count( m_decisionId.numeric() ) == 0 ) {
    continue;
      }
      
      if ( decideOnSingleObject( trkIter->track, trkIter->AllTracks, cutIndex ) ) {
      passingSelection[cutIndex].push_back( trkIndex );
 
      }
    }
    // checking if by chance none of the objects passed the single obj selection, if so there will be no valid combination and we can skip
    if ( passingSelection[cutIndex].empty() ) {
      ATH_MSG_DEBUG( "No object passed selection " << cutIndex << " rejecting" );
      return StatusCode::SUCCESS;
    }
  }
 
  std::set<size_t> passingIndices;
  HLT::elementsInUniqueCombinations( passingSelection, passingIndices );
  return markPassing( input, passingIndices );
  
 
}

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.

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();
  }

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_decisionId

HLT::Identifier TrigIsoHPtTrackTriggerHypoTool::m_decisionId

private

Definition at line 73 of file TrigIsoHPtTrackTriggerHypoTool.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_doIso

Gaudi::Property< std::vector<bool> > TrigIsoHPtTrackTriggerHypoTool::m_doIso { this, "EnableTrackIsolation", {false}, "If track based isolation should be applied or not? "}

private

Definition at line 82 of file TrigIsoHPtTrackTriggerHypoTool.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_IsoCum

Gaudi::Property< std::vector<bool> > TrigIsoHPtTrackTriggerHypoTool::m_IsoCum { this, "EnableCumalitiveIsolation", {false}, "Instead of checking if one track is above a certain pT threshold, add up all tracks for isolation"}

private

Definition at line 83 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_IsoDR

Gaudi::Property< std::vector<float> > TrigIsoHPtTrackTriggerHypoTool::m_IsoDR { this, "TrackIsoCone", {0.3}, "Isolation requirment over the main track" }

private

Definition at line 84 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_IsoPt

Gaudi::Property< std::vector<float> > TrigIsoHPtTrackTriggerHypoTool::m_IsoPt { this, "MinIsoTrackPt", {float( 5.0*Gaudi::Units::GeV )}, "Min pT requirment of other tracks to be considered for isolation" }

private

Definition at line 85 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_monTool

ToolHandle<GenericMonitoringTool> TrigIsoHPtTrackTriggerHypoTool::m_monTool { this, "MonTool", "", "Monitoring tool" }

private

Definition at line 90 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_multiplicity

size_t TrigIsoHPtTrackTriggerHypoTool::m_multiplicity = 1

private

Definition at line 88 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_Trackd0

Gaudi::Property< std::vector<float> > TrigIsoHPtTrackTriggerHypoTool::m_Trackd0 { this, "MaxTrackd0", {5.}, "Maximum Track d0 allowed" }

private

Definition at line 77 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_Trackd0Sig

Gaudi::Property< std::vector<float> > TrigIsoHPtTrackTriggerHypoTool::m_Trackd0Sig { this, "MaxTrackd0Sig", {5.}, "Maximum Track d0 Sig allowed" }

private

Definition at line 78 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_TrackEta

Gaudi::Property< std::vector<float> > TrigIsoHPtTrackTriggerHypoTool::m_TrackEta { this, "MinTrackEta", { float(2.5 ) }, "Track Eta requirement" }

private

Definition at line 76 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_TrackNPixHits

Gaudi::Property< std::vector<unsigned> > TrigIsoHPtTrackTriggerHypoTool::m_TrackNPixHits { this, "MinTrackNPixHits", {2}, "Minimum number of pixel hits required from the trigger" }

private

Definition at line 79 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_TrackNSCTHits

Gaudi::Property< std::vector<unsigned> > TrigIsoHPtTrackTriggerHypoTool::m_TrackNSCTHits { this, "MinTrackNSCTHits", {5}, "Minimum number of SCT hits required from the trigger" }

private

Definition at line 80 of file TrigIsoHPtTrackTriggerHypoTool.h.

m_TrackPt

Gaudi::Property< std::vector<float> > TrigIsoHPtTrackTriggerHypoTool::m_TrackPt { this, "MinTrackPt", { float( 50.0*Gaudi::Units::GeV ) }, "Track pT requirement" }

private

Definition at line 75 of file TrigIsoHPtTrackTriggerHypoTool.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:

• TrigIsoHPtTrackTriggerHypoTool.h
• TrigIsoHPtTrackTriggerHypoTool.cxx