TrigMufastHypoTool Class Reference

#include <TrigMufastHypoTool.h>

Inheritance diagram for TrigMufastHypoTool:

Collaboration diagram for TrigMufastHypoTool:

Classes
struct	MuonClusterInfo

Public Member Functions
	TrigMufastHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TrigMufastHypoTool ()
virtual StatusCode	initialize () override
virtual StatusCode	decide (std::vector< TrigMufastHypoTool::MuonClusterInfo > &toolInput) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
enum	{ MaxNumberTools = 20 }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	decideOnSingleObject (TrigMufastHypoTool::MuonClusterInfo &input, size_t cutIndex) const
StatusCode	inclusiveSelection (std::vector< TrigMufastHypoTool::MuonClusterInfo > &toolInput) const
StatusCode	multiplicitySelection (std::vector< TrigMufastHypoTool::MuonClusterInfo > &toolInput) const
StatusCode	applyOverlapRemoval (std::vector< TrigMufastHypoTool::MuonClusterInfo > &toolInput) const
StatusCode	checkOverlap (std::vector< TrigMufastHypoTool::MuonClusterInfo * > &input) const
bool	isOverlap (const xAOD::L2StandAloneMuon *mf1, const xAOD::L2StandAloneMuon *mf2) const
double	dR (double eta1, double phi1, double eta2, double phi2) const
double	invMass (double m1, double pt1, double eta1, double phi1, double m2, double pt2, double eta2, double phi2) const
StatusCode	chooseBestMuon (std::vector< TrigMufastHypoTool::MuonClusterInfo * > &input, const std::vector< unsigned int > &mufastResult) const
float	getLocalPhi (float, float, float) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
HLT::Identifier	m_decisionId
Gaudi::Property< std::vector< std::vector< double > > >	m_ptBins
Gaudi::Property< std::vector< std::vector< double > > >	m_ptThresholds
Gaudi::Property< bool >	m_acceptAll
Gaudi::Property< bool >	m_selectPV
Gaudi::Property< float >	m_ZPV
Gaudi::Property< float >	m_RPV
Gaudi::Property< std::vector< double > >	m_ptThresholdForECWeakBRegionA
Gaudi::Property< std::vector< double > >	m_ptThresholdForECWeakBRegionB
Gaudi::Property< bool >	m_decisionPerCluster
Gaudi::Property< bool >	m_doCalib
Gaudi::Property< bool >	m_applyOR
Gaudi::Property< bool >	m_requireDR
Gaudi::Property< bool >	m_requireMass
Gaudi::Property< bool >	m_requireSameSign
Gaudi::Property< float >	m_dRThresBB
Gaudi::Property< float >	m_massThresBB
Gaudi::Property< float >	m_dRThresBE
Gaudi::Property< float >	m_massThresBE
Gaudi::Property< std::vector< float > >	m_etaBinsEC
Gaudi::Property< std::vector< float > >	m_dRThresEC
Gaudi::Property< std::vector< float > >	m_massThresEC
std::vector< size_t >	m_bins = {0}
ToolHandle< GenericMonitoringTool >	m_monTool { this, "MonTool", "", "Monitoring tool" }
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 33 of file TrigMufastHypoTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
MaxNumberTools

Definition at line 34 of file TrigMufastHypoTool.h.

{ MaxNumberTools = 20 }; 

Constructor & Destructor Documentation

TrigMufastHypoTool()

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

Definition at line 19 of file TrigMufastHypoTool.cxx.

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

~TrigMufastHypoTool()

TrigMufastHypoTool::~TrigMufastHypoTool ( )

virtual

Definition at line 27 of file TrigMufastHypoTool.cxx.

                                       {
}

Member Function Documentation

applyOverlapRemoval()

StatusCode TrigMufastHypoTool::applyOverlapRemoval ( std::vector< TrigMufastHypoTool::MuonClusterInfo > & toolInput ) const

private

Definition at line 390 of file TrigMufastHypoTool.cxx.

                                                                                                               {
 
   ATH_MSG_DEBUG("Running Overlap Removal for muFast");
 
  std::vector<TrigMufastHypoTool::MuonClusterInfo*> input;
 
  for ( auto& i: toolInput ) {
    // If muon event has difference DecisionID, it shouldn't apply.
    if ( TrigCompositeUtils::passed( m_decisionId.numeric(), i.previousDecisionIDs ) ) {
      input.emplace_back(&i);
    }
  }
 
  size_t numMuon = input.size();
 
  auto mufastNrAllEVs     = Monitored::Scalar("NrAllEVs", -9999.);
  auto mufastNrActiveEVs  = Monitored::Scalar("NrActiveEVs", -9999.);
  auto monitorIt          = Monitored::Group(m_monTool, mufastNrAllEVs, mufastNrActiveEVs);
  if ( numMuon == 0) {
    ATH_MSG_DEBUG( "No positive previous hypo decision. Not need overlap removal." );
    mufastNrActiveEVs = numMuon;
    mufastNrAllEVs = numMuon;
    return StatusCode::SUCCESS;
  }
  else if ( numMuon == 1 ) {
    ATH_MSG_DEBUG("Number of muon event = " << numMuon );
    ATH_MSG_DEBUG("no overlap Removal necessary. exitting with all EventViews active." );
    mufastNrActiveEVs = numMuon;
    mufastNrAllEVs = numMuon;
    return StatusCode::SUCCESS;
  } else {
    ATH_MSG_DEBUG("Number of muon event = " << numMuon );
    mufastNrAllEVs = numMuon;
    ATH_CHECK(checkOverlap(input));
    return StatusCode::SUCCESS;
  }
 
 
  return StatusCode::SUCCESS;
}

checkOverlap()

StatusCode TrigMufastHypoTool::checkOverlap ( std::vector< TrigMufastHypoTool::MuonClusterInfo * > & input ) const

private

Definition at line 434 of file TrigMufastHypoTool.cxx.

                                                                                                      {
 
  size_t numMuon = input.size();
  unsigned int i,j;
  std::vector<unsigned int> mufastResult;
 
  bool errorWhenIdentifyingOverlap = false;
 
  for(i=0; i<numMuon; i++) {mufastResult.emplace_back(i); }
  for(i=0; i<numMuon-1; i++){
    for(j=i+1; j<numMuon; j++){
      ATH_MSG_DEBUG("++ i=" << i << " vs j=" << j);
      bool overlapped = isOverlap((*input[i]).muFast, (*input[j]).muFast);
      if( ! overlapped ){ // judged as different
    ATH_MSG_DEBUG("   judged as: different objects");
    if( mufastResult[i] == mufastResult[j] ) { // but marked as same by someone
      ATH_MSG_DEBUG( "inconsistentency in muFast overlap removal for more than two objects" );
      ATH_MSG_DEBUG( "two objects are judged as different but both were already marked as identical by someone else as: " );
      ATH_MSG_DEBUG( "i/j/result[i]/result[j]=" << i << " / " << j << " / " << mufastResult[i] << " / "  << mufastResult[j] );
      auto mufastError  = Monitored::Scalar("MufastError", -9999.);
      auto monitorIt    = Monitored::Group(m_monTool, mufastError);
      mufastError = TrigMufastHypoToolConsts::errorCode_inconsistent_overlap1;
      errorWhenIdentifyingOverlap = true;
    }
      }
      else{ // judged as overlap
    if( (mufastResult[j] != j && mufastResult[i] != mufastResult[j]) || (mufastResult[j] == j && mufastResult[i] != i) ){
      ATH_MSG_DEBUG( "inconsistentency in muFast overlap removal for more than two objects" );
      ATH_MSG_DEBUG( "two objects are judged as overlap but only either was already marked as overlap to someone else: " );
      ATH_MSG_DEBUG( "i/j/result[i]/result[j]=" << i << " / " << j << " / " << mufastResult[i] << " / "  << mufastResult[j] );
      auto mufastError  = Monitored::Scalar("MufastError", -9999.);
      auto monitorIt    = Monitored::Group(m_monTool, mufastError);
      mufastError = TrigMufastHypoToolConsts::errorCode_inconsistent_overlap2;
      errorWhenIdentifyingOverlap = true;
    }
    ATH_MSG_DEBUG("   judged as: overlapped objects");
    if( mufastResult[i] == i ) {
      ATH_MSG_DEBUG( "   i is not yet marked as overlap. so, it is a newly found overlap" );
      ATH_MSG_DEBUG( "   -> marking mufastResult[j] as i..." );
      mufastResult[j] = i;
    } else {
      ATH_MSG_DEBUG( "   both i/j already marked as overlap by: mufastResult[i]=" << mufastResult[i] );
      ATH_MSG_DEBUG( "   -> do nothing..." );
    }
      }
    }
  }
 
  if( errorWhenIdentifyingOverlap ) {
      ATH_MSG_WARNING( "error when resolving overlap. exitting with all EVs active..." );
      auto mufastNrActiveEVs  = Monitored::Scalar("NrActiveEVs", -9999.);
      auto monitorIt          = Monitored::Group(m_monTool, mufastNrActiveEVs);
      mufastNrActiveEVs = numMuon;
      // for(i=0; i<numMuon; i++) TrigCompositeUtils::addDecisionID( m_decisionId, toolInput[i].decision );
      return StatusCode::SUCCESS;
   }
 
  unsigned int n_uniqueMuon = 0;
  for(i=0; i<numMuon; i++) {
    ATH_MSG_DEBUG( "muFast results: i=" << i << ": ");
    if( mufastResult[i] != i ) { ATH_MSG_DEBUG( "      overlap to j=" << mufastResult[i] ); }
    else {
      n_uniqueMuon++;
      ATH_MSG_DEBUG( "      unique" );
    }
  }
 
  ATH_MSG_DEBUG( "nr of unique Muons after muFast overlap removal=" << n_uniqueMuon );
 
  if( numMuon != n_uniqueMuon ){
    ATH_CHECK(chooseBestMuon(input, mufastResult));
  } else {
    ATH_MSG_DEBUG( "no overlap identified. exitting with all EventViews active" );
    auto mufastNrActiveEVs  = Monitored::Scalar("NrActiveEVs", -9999.);
    auto monitorIt          = Monitored::Group(m_monTool, mufastNrActiveEVs);
    mufastNrActiveEVs = n_uniqueMuon;
  }
 
  return StatusCode::SUCCESS;
}

chooseBestMuon()

StatusCode TrigMufastHypoTool::chooseBestMuon ( std::vector< TrigMufastHypoTool::MuonClusterInfo * > & input, const std::vector< unsigned int > & mufastResult ) const

private

Definition at line 684 of file TrigMufastHypoTool.cxx.

{
  size_t numMuon = input.size();
  unsigned int i,j,k;
 
  auto mufastNrActiveEVs    = Monitored::Scalar("NrActiveEVs", -9999.);
  auto mufastNrOverlapped   = Monitored::Scalar("NrOverlapped", 0);
  auto mufastOverlappedEta  = Monitored::Scalar("OverlappedEta", -9999.);
  auto mufastOverlappedPhi  = Monitored::Scalar("OverlappedPhi", -9999.);
  auto mufastOverlappedPt   = Monitored::Scalar("OverlappedPt", -9999.);
 
  auto monitorIt       = Monitored::Group(m_monTool, mufastNrActiveEVs, mufastNrOverlapped,
                      mufastOverlappedPt, mufastOverlappedEta, mufastOverlappedPhi);
 
  ATH_MSG_DEBUG( "--- choose best among overlaps & disable EVs (muFast based) ---" );
  for(i=0; i<numMuon; i++) {
    ATH_MSG_DEBUG( "++ i=" << i << ": result=" << mufastResult[i] );
    if( mufastResult[i] != i ) {
      ATH_MSG_DEBUG( "   overlap to some one. already the best one was chosen. skip." );
      continue;
    }
    std::vector<unsigned int> others;
    for(j=0; j<numMuon; j++) {
      if( mufastResult[j] == mufastResult[i] ) others.emplace_back(j);
    }
    if( others.size() == 1 ) {
      ATH_MSG_DEBUG( "   unique object. keep it active." );
      continue;
    }
    else {
      // must choose one best
      ATH_MSG_DEBUG( "   overlapped objects among: " << others );
      unsigned int best_ev = 0;
      float maxPtMf  = 0;
      float maxPtRoI = 0;
      for(k=0; k<others.size(); k++) {
    j=others[k];
    // const LVL1::RecMuonRoI* muonRoI = input[j].RecRoI;
    // float ptRoI = muonRoI->getThresholdValue();
    const xAOD::L2StandAloneMuon* mf = (*input[j]).muFast;
    float ptMf  = fabs(mf->pt());
    float ptRoI = mf->roiThreshold();
    ATH_MSG_DEBUG("     ev/PtRoI/ptMf="<< j << "/" << ptRoI << "/" << ptMf);
    if( (ptRoI-maxPtRoI) > 0.1 ) {
      maxPtRoI = ptRoI;
      maxPtMf  = ptMf;
      best_ev  = j;
    }
    else if( fabs(ptRoI-maxPtRoI) < 0.1 ) {
      if( ptMf > maxPtMf ) {
        maxPtRoI = ptRoI;
        maxPtMf  = ptMf;
        best_ev  = j;
      }
    }
      }
      ATH_MSG_DEBUG( "     best is: best_ev/maxPtRoI/maxPtMf=" << best_ev << " / " << maxPtRoI << " / " << maxPtMf );
 
      for(k=0; k<others.size(); k++) {
    j=others[k];
    if( j != best_ev ) {
      ATH_MSG_DEBUG( "      EventView( j=" << j << " ) is not active" );
 
      (*input[j]).isOR.insert(m_decisionId.numeric());
 
      // monitoring
      const xAOD::L2StandAloneMuon* mf = (*input[j]).muFast;
      ++mufastNrOverlapped;
      mufastOverlappedPt = mf->pt();
      mufastOverlappedEta = mf->etaMS();
      mufastOverlappedPhi = mf->phiMS();
    }
    if( j == best_ev ){
      ATH_MSG_DEBUG( "      EventView( j=" << j << " ) is best one" );
    }
      }
    }
  }
   mufastNrActiveEVs = numMuon - mufastNrOverlapped;
 
  return StatusCode::SUCCESS;
}

decide()

StatusCode TrigMufastHypoTool::decide ( std::vector< TrigMufastHypoTool::MuonClusterInfo > & toolInput ) const

virtual

Definition at line 278 of file TrigMufastHypoTool.cxx.

                                                                                 {
 
   size_t numTrigger = m_ptBins.size(); 
   size_t numMuon = toolInput.size();
   ATH_MSG_DEBUG("Retrieved from TrigMufastHypoAlg and Running TrigMufastHypoTool for selections.");
   
   if ( numTrigger == 1 ) { // in case of HLT_mu4, HLT_mu6 and so on.
      ATH_MSG_DEBUG("Number of muon event = " << numMuon );
      ATH_MSG_DEBUG("Applying selection of single << " << m_decisionId );
      return inclusiveSelection(toolInput);
   } else {         // in case of HLT_2mu6 and so on.
         ATH_MSG_DEBUG("Number of muon event = " << numMuon );
         ATH_MSG_DEBUG("Applying selection of multiplicity << " << m_decisionId );
 
     if(m_applyOR)
       ATH_CHECK(applyOverlapRemoval(toolInput));
 
         return multiplicitySelection(toolInput);
   }
 
   return StatusCode::SUCCESS;
}

decideOnSingleObject()

bool TrigMufastHypoTool::decideOnSingleObject ( TrigMufastHypoTool::MuonClusterInfo & input, size_t cutIndex ) const

private

Definition at line 120 of file TrigMufastHypoTool.cxx.

{
 
   auto fexPt       = Monitored::Scalar("Pt", -9999.);
   auto fexEta      = Monitored::Scalar("Eta", -9999.);
   auto fexPhi      = Monitored::Scalar("Phi", -9999.);
   auto fexPtFL     = Monitored::Scalar("PtFL", -9999.);
   auto xatStation  = Monitored::Scalar("XatSt", -9999.);
   auto yatStation  = Monitored::Scalar("YatSt", -9999.);
   auto zatStation  = Monitored::Scalar("ZatSt", -9999.);
   auto xatBeam     = Monitored::Scalar("XatBe", -9999.);
   auto zatBeam     = Monitored::Scalar("ZatBe", -9999.);
 
   auto monitorIt   = Monitored::Group(m_monTool, fexPt, fexEta, fexPhi, fexPtFL,
                              xatStation, yatStation, zatStation, 
                              xatBeam, zatBeam);
 
   ATH_MSG_VERBOSE( "Cut index " << cutIndex );
 
   auto roiDescriptor = input.roi;
   ATH_MSG_DEBUG("RoI ID = " << roiDescriptor->roiId() 
                 << ", Eta = " << roiDescriptor->eta()
                 << ", Phi = " << roiDescriptor->phi());
 
   bool result = false;
   // if accept All flag is on, just pass it
   if(m_acceptAll) {
      result = true;
      ATH_MSG_DEBUG("Accept property is set: taking all the events");
      return result;
   } else {
      result = false;
      ATH_MSG_DEBUG("Accept property not set: applying selection!");
   }
 
   // Get xAOD::L2StandAloneMuon:
   auto pMuon = input.muFast;
 
   if(!pMuon){
      result = false;
      ATH_MSG_ERROR("Retrieval of L2StandAloneMuon from vector failed");
      return result;
   }
 
   // fill Monitoring histos
   fexPt    = (pMuon->pt())?  pMuon->pt()  : -9999.;
   fexEta   = (pMuon->etaMS())? pMuon->etaMS() : -9999.;
   fexPhi   = (pMuon->etaMS())? pMuon->phiMS() : -9999.;
   fexPtFL  = (pMuon->pt())?  pMuon->pt()  : -9999.;
 
   if( pMuon->etaMS() ) {
      float localPhi = getLocalPhi(pMuon->etaMS(),pMuon->phiMS(),pMuon->rMS());
      float radius = pMuon->rMS()/cos(fabs(localPhi));
      float DirZ = (pMuon->dirZMS())? pMuon->dirZMS() : .000001;
      float DirF = (pMuon->dirPhiMS())?  pMuon->dirPhiMS()  : .000001;
      xatStation = radius * cos(pMuon->phiMS());
      yatStation = radius * sin(pMuon->phiMS());
      zatStation = pMuon->zMS();
      float xb = xatStation - yatStation/DirF;
      float de = xatStation - xb;
      float ds = sqrt(yatStation*yatStation+de*de);
      xatBeam = xb;
      zatBeam = zatStation - ds*DirZ;
   } else {
      xatStation = -9999.;
      yatStation = -9999.;
      zatStation = -9999.;
      xatBeam = -9999.;
      zatBeam = -9999.;
   }
 
   if(m_doCalib && !m_acceptAll){ 
      result = false;
      ATH_MSG_DEBUG("This muoncalib chain is only monitored.");
      return result;
   }
 
   //Get the Pt cut for that eta bin
   double threshold = 0;
   float absEta = fabs(fexEta);
   for (std::vector<float>::size_type i=0; i<m_bins[0]; ++i)
      if ( absEta > m_ptBins[cutIndex][i] && absEta < m_ptBins[cutIndex][i+1] ) threshold = m_ptThresholds[cutIndex][i]; 
 
   // if in the weak Bfield regions at endcap, set special threshold
 
   xAOD::L2MuonParameters::ECRegions ecRegion = xAOD::L2MuonParameters::whichECRegion( fexEta , fexPhi );
   if( ecRegion == xAOD::L2MuonParameters::ECRegions::WeakBFieldA ) { 
      ATH_MSG_DEBUG("threshold is set for EC WeakBField A");
      threshold = m_ptThresholdForECWeakBRegionA[cutIndex];
   }
 
   if( ecRegion == xAOD::L2MuonParameters::ECRegions::WeakBFieldA ) {
      ATH_MSG_DEBUG("threshold is set for EC WeakBField B");
      threshold = m_ptThresholdForECWeakBRegionB[cutIndex];
   }
 
   ATH_MSG_DEBUG("threshold value is set as: " << threshold/Gaudi::Units::GeV << " GeV");
 
   // Check pt threshold for hypothesis, 
   // convert units since Muonfeature is in GeV
   if ( std::abs(pMuon->pt()) > (threshold/Gaudi::Units::GeV)){
      // selects only tracks coming from a region around PV
      if( m_selectPV ){
     if((fabs(xatBeam)<m_RPV) && (fabs(zatBeam)<m_ZPV))
        result = true;
      } else {
     result = true;
      }
   }
 
   if ( result ) fexPtFL = -9999.;
 
   ATH_MSG_DEBUG("REGTEST: Muon pt is " << pMuon->pt() << " GeV" 
                 << " and threshold cut is " << threshold/Gaudi::Units::GeV << " GeV"
                 << " so hypothesis is " << (result?"true":"false"));
  
   return result;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & 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; }

dR()

double TrigMufastHypoTool::dR ( double eta1, double phi1, double eta2, double phi2 ) const

private

Definition at line 638 of file TrigMufastHypoTool.cxx.

{
  const double deta = eta1 - eta2;
  const double dphi = CxxUtils::deltaPhi(phi1, phi2);
  return std::sqrt(deta*deta + dphi*dphi);
}

evtStore()

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

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

getLocalPhi()

float TrigMufastHypoTool::getLocalPhi ( float eta, float phi, float rad ) const

private

Definition at line 242 of file TrigMufastHypoTool.cxx.

{
   if(phi<0.) phi += 2*3.14159265;
   float step = 0.78539816;
   float offs = 0.39269908;
   if(fabs(eta) <= 1.1)
   {
      float Dphi = 999999.;
      float sign = 0.;
      const float ZEROLIMIT = 1e-6;
      if(rad < 800.)
      {
         for(int i=0;i<8;++i) if(fabs(i*step-phi)<=Dphi)
     { 
        Dphi=fabs(i*step-phi);
        sign = (fabs(Dphi) > ZEROLIMIT) ? (i*step-phi)/fabs(i*step-phi) : 0;
     }
     return sign*Dphi;
      }else
      {
         for(int i=1;i<8;++i) if(fabs(i*step+offs-phi)<=Dphi)
     { 
        Dphi=fabs(i*step+offs-phi);
        sign = (fabs(Dphi) > ZEROLIMIT) ? (i*step+offs-phi)/fabs(i*step+offs-phi) : 0;
     }     
     return sign*Dphi;
      }
   }else
   {
      return 0.;
   }
}

inclusiveSelection()

StatusCode TrigMufastHypoTool::inclusiveSelection ( std::vector< TrigMufastHypoTool::MuonClusterInfo > & toolInput ) const

private

Definition at line 302 of file TrigMufastHypoTool.cxx.

                                                                                                              {
 
   for ( auto& i: toolInput ) {
     // If muon event has difference DecisionID, it shouldn't apply.
     if ( TrigCompositeUtils::passed( m_decisionId.numeric(), i.previousDecisionIDs ) ) {
         if ( decideOnSingleObject( i, 0 )==true ) {
            ATH_MSG_DEBUG("Pass through selection " << m_decisionId );
            TrigCompositeUtils::addDecisionID(m_decisionId, i.decision);
         } else {
            ATH_MSG_DEBUG("Not pass through selection " << m_decisionId );
         } 
      } else {
         ATH_MSG_DEBUG("Not match DecisionID:" << m_decisionId );
      } 
   }  
 
   return StatusCode::SUCCESS; 
}

initialize()

StatusCode TrigMufastHypoTool::initialize ( )

overridevirtual

Definition at line 33 of file TrigMufastHypoTool.cxx.

{
  ATH_MSG_DEBUG("Initializing " << name());
 
  if(m_acceptAll) {
     ATH_MSG_DEBUG("AcceptAll = True");
     ATH_MSG_DEBUG("Accepting all the events!");
  }
  else if(m_doCalib){
     ATH_MSG_DEBUG("This is a muon calibration chain.");
  }
  else {
     ATH_MSG_DEBUG("AcceptAll = False");
     m_bins.resize (m_ptBins.size());
     for ( size_t j=0; j<m_ptBins.size(); ++j) {
        m_bins[j] = m_ptBins[j].size() - 1;
        if (m_bins[j] != m_ptThresholds[j].size()) {
       ATH_MSG_DEBUG("bad thresholds setup .... exiting!");
           return StatusCode::SUCCESS;
        }
 
        for (std::vector<float>::size_type i=0; i<m_bins[j];++i) {
    char buf1[256];
    char buf2[256];
    sprintf(buf1,"%f5.2",m_ptBins[j][i]);
    sprintf(buf2,"%f5.2",m_ptBins[j][i+1]);
    ATH_MSG_DEBUG("EtaBin[" << j << "] " << buf1 << " - " <<  buf2
                 << ": with Pt Threshold of " << (m_ptThresholds[j][i])/Gaudi::Units::GeV
                 << " GeV");
        }
        
        ATH_MSG_DEBUG("Endcap WeakBField A[" << j << "]: pT threshold of " << m_ptThresholdForECWeakBRegionA[j] / Gaudi::Units::GeV << " GeV");
        ATH_MSG_DEBUG("Endcap WeakBField B[" << j << "]: pT threshold of " << m_ptThresholdForECWeakBRegionB[j] / Gaudi::Units::GeV << " GeV");
     }
  }
 
  ATH_MSG_DEBUG( "Tool configured for chain/id: " << m_decisionId );
 
  if ( not m_monTool.name().empty() ) {
     ATH_CHECK( m_monTool.retrieve() );
     ATH_MSG_DEBUG("MonTool name: " << m_monTool);
  }
 
 
  // Overlap Removal
  if( m_applyOR ) {
    ATH_MSG_DEBUG( "--- overlap removal as: ---"     );
    if( m_requireDR ) {
      ATH_MSG_DEBUG( "+ dR cut:" );
      if( (m_etaBinsEC.size()-1) != m_dRThresEC.size() ) {
    ATH_MSG_ERROR( "bad thresholds setup .... exiting!" );
    return StatusCode::FAILURE;
      }
      ATH_MSG_DEBUG( "     B-B : dR < " << m_dRThresBB );
      ATH_MSG_DEBUG( "     B-E : dR < " << m_dRThresBE );
      ATH_MSG_DEBUG( "     E-E : " );
      for(unsigned int i=0; i<m_dRThresEC.size(); i++) {
    ATH_MSG_DEBUG( "        EtaBin " << m_etaBinsEC[i] << " - " << m_etaBinsEC[i+1]
               << " : dR < " << m_dRThresEC[i] );
      }
    }
    if( m_requireMass ) {
      ATH_MSG_DEBUG( "+ Mass cut:" );
      if( (m_etaBinsEC.size()-1) != m_massThresEC.size() ) {
    ATH_MSG_ERROR( "bad thresholds setup .... exiting!" );
    return StatusCode::FAILURE;
      }
      ATH_MSG_DEBUG( "     B-B : Mass < " << m_massThresBB );
      ATH_MSG_DEBUG( "     B-E : Mass < " << m_massThresBE );
      ATH_MSG_DEBUG( "     E-E : " );
      for(unsigned int i=0; i<m_massThresEC.size(); i++) {
    ATH_MSG_DEBUG( "        EtaBin " << m_etaBinsEC[i] << " - " << m_etaBinsEC[i+1]
               << " : Mass < " << m_massThresEC[i] );
      }
    }
    if( m_requireSameSign ) ATH_MSG_DEBUG( "+ Same charge sign" );
  }
 
 
  ATH_MSG_DEBUG("Initialization completed successfully");
 
  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.

invMass()

double TrigMufastHypoTool::invMass ( double m1, double pt1, double eta1, double phi1, double m2, double pt2, double eta2, double phi2 ) const

private

Definition at line 648 of file TrigMufastHypoTool.cxx.

{
  const double ZERO_LIMIT = 1e-12;
 
  double theta1 = 2*atan2((double)exp(-eta1),1.);
  double theta2 = 2*atan2((double)exp(-eta2),1.);
 
  double fpt1   = fabs(pt1);
  double fpt2   = fabs(pt2);
 
  double px1    = fpt1*cos(phi1);
  double py1    = fpt1*sin(phi1);
  double pz1    = fpt1/tan(theta1);
  double  e1    = sqrt(px1*px1+py1*py1+pz1*pz1+m1*m1);
 
  double px2    = fpt2*cos(phi2);
  double py2    = fpt2*sin(phi2);
  double pz2    = fpt2/tan(theta2);
  double  e2    = sqrt(px2*px2+py2*py2+pz2*pz2+m2*m2);
 
  double pxsum  = px1 + px2;
  double pysum  = py1 + py2;
  double pzsum  = pz1 + pz2;
  double esum   =  e1 +  e2;
 
  double mass  = 0;
  double mass2 = esum*esum - pxsum*pxsum - pysum*pysum - pzsum*pzsum;
  if( mass2 > ZERO_LIMIT ) mass = sqrt(mass2);
 
  return mass;
}

isOverlap()

bool TrigMufastHypoTool::isOverlap ( const xAOD::L2StandAloneMuon * mf1, const xAOD::L2StandAloneMuon * mf2 ) const

private

Definition at line 518 of file TrigMufastHypoTool.cxx.

{
 
  auto mufastDR             = Monitored::Scalar("DR", -9999.);
  auto mufastMass           = Monitored::Scalar("Mass", -9999.);
  auto mufastDRLog10        = Monitored::Scalar("DRLog10", -9999.);
  auto mufastMassLog10      = Monitored::Scalar("MassLog10", -9999.);
 
  auto monitorIt       = Monitored::Group(m_monTool, mufastDR, mufastMass, mufastDRLog10, mufastMassLog10);
 
  ATH_MSG_DEBUG( "   ...mF1: pt/eta/phi=" << mf1->pt() << " / " << mf1->etaMS() << " / " << mf1->phiMS() );
  ATH_MSG_DEBUG( "   ...mF2: pt/eta/phi=" << mf2->pt() << " / " << mf2->etaMS() << " / " << mf2->phiMS() );
 
  // if dR or invMass is necessary but (eta,phi) info is not avaiable
  // (i.e. eta,phi=0,0; rec failed)
  const double ZERO_LIMIT_FOR_ETAPHI = 1e-4;
  if( (fabs(mf1->etaMS()) <ZERO_LIMIT_FOR_ETAPHI && fabs(mf1->phiMS()) < ZERO_LIMIT_FOR_ETAPHI) ||
      (fabs(mf2->etaMS()) <ZERO_LIMIT_FOR_ETAPHI && fabs(mf2->phiMS()) < ZERO_LIMIT_FOR_ETAPHI) ) {
    ATH_MSG_DEBUG( "   ...-> (eta,phi) info not available (rec at (eta,phi)=(0,0))" );
    ATH_MSG_DEBUG( "   ...-> but dR of invMass check is required. cannot judge overlap -> return with false" );
    return false;
  }
 
  // if charge or invMass is necessary but charge(=pT) info is not avaiable
  const double ZERO_LIMIT_FOR_PT = 1e-4;
  if( (fabs(mf1->pt()) <ZERO_LIMIT_FOR_PT) || (fabs(mf2->pt()) < ZERO_LIMIT_FOR_PT) ) {
    ATH_MSG_DEBUG( "   ...-> pT info not available (rec at pT=0)" );
    ATH_MSG_DEBUG( "   ...-> but same sign or invMass check is required. cannot judge overlap -> return with false" );
    return false;
  }
 
 
  // determine dR, mass threshold separately for: BB, BE, EE
  double dRThres   = 9999;
  double massThres = 9999;
 
  const int SADDRESS_EC = -1;
  bool isBarrel1 = (mf1->sAddress() != SADDRESS_EC ) ? true : false;
  bool isBarrel2 = (mf2->sAddress() != SADDRESS_EC ) ? true : false;
 
  if(  isBarrel1 && isBarrel2 ) { // BB
    ATH_MSG_DEBUG( "   ...B-B" );
    dRThres  =m_dRThresBB;
    massThres=m_massThresBB;
  }
  else if( (isBarrel1 && ! isBarrel2) || (!isBarrel1 && isBarrel2) ) { // BE
    ATH_MSG_DEBUG( "   ...B-E" );
    dRThres  =m_dRThresBE;
    massThres=m_massThresBE;
  }
  else { // EE
    ATH_MSG_DEBUG( "   ...E-E" );
    double absEta = (fabs(mf1->pt()) > fabs(mf2->pt())) ? fabs(mf1->etaMS()) : fabs(mf2->etaMS());
    unsigned int iThres=0;
    for(unsigned int i=0; i<(m_etaBinsEC.size()-1); i++) {
      if ( m_etaBinsEC[i] <= absEta && absEta < m_etaBinsEC[i+1] ) iThres = i;
    }
    ATH_MSG_DEBUG( "   ...iThres=" << iThres );
    dRThres   = m_dRThresEC[iThres];
    massThres = m_massThresEC[iThres];
  }
  ATH_MSG_DEBUG( "   ...dR   threshold=" << dRThres );
  ATH_MSG_DEBUG( "   ...mass threshold=" << massThres );
 
 
  // same sign cut
  bool sameSign = false;
  if( m_requireSameSign ) {
    sameSign = ((mf1->pt()*mf2->pt()) > 0) ? true : false;
    ATH_MSG_DEBUG( "   ...-> sameSign=" << sameSign );
  }
 
  // dR cut
  bool dRisClose = false;
  double dr = dR(mf1->etaMS(),mf1->phiMS(),mf2->etaMS(),mf2->phiMS());
 
  // for monitoring
  mufastDR = dr;
  const double monitor_limit = 1e-4;
  double dr_mon = (dr>=monitor_limit) ? dr : monitor_limit;
  mufastDRLog10 = log10(dr_mon);
 
  if( m_requireDR ) {
    if( dr < dRThres ) dRisClose = true;
    ATH_MSG_DEBUG( "   ...-> dR=" << dr << " : dRisClose=" << dRisClose );
  }
 
  // mass cut
  const double TRACK_MASS = 0;  // just assume zero mass
  bool massIsClose = false;
  double mass = invMass(TRACK_MASS,mf1->pt(),mf1->etaMS(),mf1->phiMS(),TRACK_MASS,mf2->pt(),mf2->etaMS(),mf2->phiMS());
 
  // for monitoring
  mufastMass = mass;
  double mass_mon = (mass>=monitor_limit) ? mass : monitor_limit;
  mufastMassLog10 = log10(mass_mon);
 
  if( m_requireMass ) {
    if( mass < massThres ) massIsClose = true;
    ATH_MSG_DEBUG( "   ...-> mass=" << mass << " : massIsClose=" << massIsClose );
  }
 
  // total judge
  bool overlap = false;
  if( ((m_requireSameSign &&   sameSign)   || (! m_requireSameSign)) &&
      ((m_requireDR       &&  dRisClose)   || (! m_requireDR))       &&
      ((m_requireMass     &&  massIsClose) || (! m_requireMass)) ) {
    overlap = true;
  }
 
  ATH_MSG_DEBUG( "   ...=> isOverlap=" << overlap );
 
  return overlap;
 
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 TrigMufastHypoTool::multiplicitySelection ( std::vector< TrigMufastHypoTool::MuonClusterInfo > & toolInput ) const

private

Definition at line 322 of file TrigMufastHypoTool.cxx.

                                                                                                                 {
 
   HLT::Index2DVec passingSelection( m_ptBins.size() );
 
   for ( size_t cutIndex=0; cutIndex < m_ptBins.size(); ++cutIndex ) {
      size_t elementIndex{ 0 };
      for ( auto& i: toolInput ) {
 
    if(!m_acceptAll && m_applyOR && (i.isOR.find(m_decisionId.numeric()) != i.isOR.end())) {
      ATH_MSG_DEBUG("skip due to overap, DecisionID " << m_decisionId );
      elementIndex++;
      continue;
    }
 
         // If muon event has difference DecisionID, it shouldn't apply.
         if ( TrigCompositeUtils::passed( m_decisionId.numeric(), i.previousDecisionIDs ) ) {
            if ( decideOnSingleObject( i, cutIndex ) == true ) {
               ATH_MSG_DEBUG("Pass through selection " << m_decisionId << " : Event[" << elementIndex << "]" );
               passingSelection[cutIndex].push_back( elementIndex );
            } else {
               ATH_MSG_DEBUG("Not pass through selection " << m_decisionId << " : Event[" << elementIndex << "]" );
            } 
         } else {
            ATH_MSG_DEBUG("Not match DecisionID " << m_decisionId );
         }
         elementIndex++;
      }
 
      // If no object passes the selection, multipul selection should stop.
      if ( passingSelection[cutIndex].empty() ) {
         ATH_MSG_DEBUG( "No object passed selection " << cutIndex << " rejecting" );
         return StatusCode::SUCCESS;
      }
   }
 
   std::set<size_t> passingIndices;
   if ( m_decisionPerCluster==true ) {
      auto notFromSameRoI = [&]( const HLT::Index1DVec& comb ) {
         std::set<const xAOD::L2StandAloneMuon*> setOfClusters;
         for ( auto index: comb ) {
            setOfClusters.insert( toolInput[index].muFast );
         }
         return setOfClusters.size() == comb.size();
      };
 
      HLT::elementsInUniqueCombinations( passingSelection, passingIndices, std::move(notFromSameRoI) );
 
   } else {
      HLT::elementsInUniqueCombinations( passingSelection, passingIndices );
   }
 
   if ( passingIndices.empty() ) {
      ATH_MSG_DEBUG("No muon event passed through selection " << m_decisionId );
      return StatusCode::SUCCESS;
   }
 
   for ( auto idx: passingIndices ) {
      ATH_MSG_DEBUG("Muon event[" << idx << "] passes through Chain/ID " << m_decisionId 
                    << " with pT = " << toolInput[idx].muFast->pt() << "GeV" );
      TrigCompositeUtils::addDecisionID( m_decisionId.numeric(), toolInput[idx].decision );
   }
 
   return StatusCode::SUCCESS;
}

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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_acceptAll

Gaudi::Property< bool > TrigMufastHypoTool::m_acceptAll

private

Initial value:

{
        this, "AcceptAll", false, "Ignore selection" }

Definition at line 95 of file TrigMufastHypoTool.h.

                                      {
        this, "AcceptAll", false, "Ignore selection" };

m_applyOR

Gaudi::Property< bool > TrigMufastHypoTool::m_applyOR

private

Initial value:

{
        this, "ApplyOR", false, "apply overlap removal for mufast" }

Definition at line 120 of file TrigMufastHypoTool.h.

                                    {
        this, "ApplyOR", false, "apply overlap removal for mufast" };

m_bins

std::vector<size_t> TrigMufastHypoTool::m_bins = {0}

private

Definition at line 155 of file TrigMufastHypoTool.h.

{0};

m_decisionId

HLT::Identifier TrigMufastHypoTool::m_decisionId

private

Definition at line 68 of file TrigMufastHypoTool.h.

m_decisionPerCluster

Gaudi::Property<bool> TrigMufastHypoTool::m_decisionPerCluster

private

Initial value:

{ 
    this, "DecisionPerCluster", true, "Is multiplicity requirement refering to muons ( false ) or RoIs/clusters with muons ( false ), relevant only in when multiplicity > 1" }

Definition at line 113 of file TrigMufastHypoTool.h.

                                              { 
    this, "DecisionPerCluster", true, "Is multiplicity requirement refering to muons ( false ) or RoIs/clusters with muons ( false ), relevant only in when multiplicity > 1" };

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_doCalib

Gaudi::Property< bool > TrigMufastHypoTool::m_doCalib

private

Initial value:

{
        this, "DoCalib", false, "muoncalib chain" }

Definition at line 116 of file TrigMufastHypoTool.h.

                                    {
        this, "DoCalib", false, "muoncalib chain" };

m_dRThresBB

Gaudi::Property< float > TrigMufastHypoTool::m_dRThresBB

private

Initial value:

{
        this, "DRThresBB", 0.05, "DR threshold in barel and barel region"}

Definition at line 132 of file TrigMufastHypoTool.h.

                                       {
        this, "DRThresBB", 0.05, "DR threshold in barel and barel region"};

m_dRThresBE

Gaudi::Property< float > TrigMufastHypoTool::m_dRThresBE

private

Initial value:

{
        this, "DRThresBE", 0.05, "DR threshold in barel and barel region"}

Definition at line 138 of file TrigMufastHypoTool.h.

                                       {
        this, "DRThresBE", 0.05, "DR threshold in barel and barel region"};

m_dRThresEC

Gaudi::Property< std::vector<float> > TrigMufastHypoTool::m_dRThresEC

private

Initial value:

{
        this, "DRThresEC", {0.06, 0.05, 0.05}, "DR threshold in endcap and barel region"}

Definition at line 147 of file TrigMufastHypoTool.h.

                                                  {
        this, "DRThresEC", {0.06, 0.05, 0.05}, "DR threshold in endcap and barel region"};

m_etaBinsEC

Gaudi::Property< std::vector<float> > TrigMufastHypoTool::m_etaBinsEC

private

Initial value:

{
        this, "EtaBinsEC", {0, 1.9, 2.1, 9.9}, "eta bins of DR and mass thresholds in endcap and barel region"}

Definition at line 144 of file TrigMufastHypoTool.h.

                                                  {
        this, "EtaBinsEC", {0, 1.9, 2.1, 9.9}, "eta bins of DR and mass thresholds in endcap and barel region"};

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_massThresBB

Gaudi::Property< float > TrigMufastHypoTool::m_massThresBB

private

Initial value:

{
        this, "MassThresBB", 0.20, "mass threshold in barel and barel region"}

Definition at line 135 of file TrigMufastHypoTool.h.

                                         {
        this, "MassThresBB", 0.20, "mass threshold in barel and barel region"};

m_massThresBE

Gaudi::Property< float > TrigMufastHypoTool::m_massThresBE

private

Initial value:

{
        this, "MassThresBE", 0.20, "mass threshold in barel and endcap region"}

Definition at line 141 of file TrigMufastHypoTool.h.

                                         {
        this, "MassThresBE", 0.20, "mass threshold in barel and endcap region"};

m_massThresEC

Gaudi::Property< std::vector<float> > TrigMufastHypoTool::m_massThresEC

private

Initial value:

{
        this, "MassThresEC", {0.20, 0.15, 0.10}, "mass threshold in endcap and endcap region"}

Definition at line 150 of file TrigMufastHypoTool.h.

                                                    {
        this, "MassThresEC", {0.20, 0.15, 0.10}, "mass threshold in endcap and endcap region"};

m_monTool

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

private

Definition at line 157 of file TrigMufastHypoTool.h.

{ this, "MonTool", "", "Monitoring tool" };   

m_ptBins

Gaudi::Property< std::vector<std::vector<double> > > TrigMufastHypoTool::m_ptBins

private

Initial value:

{
        this, "PtBins", { {0, 2.5} }, "Bins range of each pT threshold" }

Definition at line 89 of file TrigMufastHypoTool.h.

                                                           {
        this, "PtBins", { {0, 2.5} }, "Bins range of each pT threshold" };

m_ptThresholdForECWeakBRegionA

Gaudi::Property< std::vector<double> > TrigMufastHypoTool::m_ptThresholdForECWeakBRegionA

private

Initial value:

{
        this, "PtThresholdForECWeakBRegionA", {3.}, "Track pT requirement on regionA of weak magnetic field ( separate threshold for each muon )" }

Definition at line 107 of file TrigMufastHypoTool.h.

                                                                      {
        this, "PtThresholdForECWeakBRegionA", {3.}, "Track pT requirement on regionA of weak magnetic field ( separate threshold for each muon )" };

m_ptThresholdForECWeakBRegionB

Gaudi::Property< std::vector<double> > TrigMufastHypoTool::m_ptThresholdForECWeakBRegionB

private

Initial value:

{
        this, "PtThresholdForECWeakBRegionB", {3.}, "Track pT requirement on regionB of weak magnetic field ( separate threshold for each muon )" }

Definition at line 110 of file TrigMufastHypoTool.h.

                                                                      {
        this, "PtThresholdForECWeakBRegionB", {3.}, "Track pT requirement on regionB of weak magnetic field ( separate threshold for each muon )" };

m_ptThresholds

Gaudi::Property< std::vector<std::vector<double> > > TrigMufastHypoTool::m_ptThresholds

private

Initial value:

{
        this, "PtThresholds", { {5.49*Gaudi::Units::GeV} }, "Track pT requirement ( separate threshold for each muon )" }

Definition at line 92 of file TrigMufastHypoTool.h.

                                                                 {
        this, "PtThresholds", { {5.49*Gaudi::Units::GeV} }, "Track pT requirement ( separate threshold for each muon )" };

m_requireDR

Gaudi::Property<bool> TrigMufastHypoTool::m_requireDR

private

Initial value:

{
        this, "RequireDR", true, "require or not DR cut for overlap removal"}

Definition at line 123 of file TrigMufastHypoTool.h.

                                   {
        this, "RequireDR", true, "require or not DR cut for overlap removal"};

m_requireMass

Gaudi::Property<bool> TrigMufastHypoTool::m_requireMass

private

Initial value:

{
        this, "RequireMass", true, "require or not mass cut for overlap removal"}

Definition at line 126 of file TrigMufastHypoTool.h.

                                     {
        this, "RequireMass", true, "require or not mass cut for overlap removal"};

m_requireSameSign

Gaudi::Property<bool> TrigMufastHypoTool::m_requireSameSign

private

Initial value:

{
        this, "RequireSameSign", true, "require or not charge cut for overlap removal"}

Definition at line 129 of file TrigMufastHypoTool.h.

                                         {
        this, "RequireSameSign", true, "require or not charge cut for overlap removal"};

m_RPV

Gaudi::Property< float > TrigMufastHypoTool::m_RPV

private

Initial value:

{
        this, "RPVBins", 200., "Define RPV" }

Definition at line 104 of file TrigMufastHypoTool.h.

                                 {
        this, "RPVBins", 200., "Define RPV" };

m_selectPV

Gaudi::Property< bool > TrigMufastHypoTool::m_selectPV

private

Initial value:

{
        this, "SelectPV", false, "Select PV" }

Definition at line 98 of file TrigMufastHypoTool.h.

                                     {
        this, "SelectPV", false, "Select PV" };

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.

m_ZPV

Gaudi::Property< float > TrigMufastHypoTool::m_ZPV

private

Initial value:

{
        this, "ZPVBins", 400. , "Define ZPV" }

Definition at line 101 of file TrigMufastHypoTool.h.

                                 {
        this, "ZPVBins", 400. , "Define ZPV" };

---

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

• TrigMufastHypoTool.h
• TrigMufastHypoTool.cxx