The full list of LoKi Track/Trigger Functions

---

---

TrALL, the instance of LoKi::BooleanConstant<LHCb::Track> (true)

The most trivial predicate which always evaluates to true

TrBACKWARD, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::Backward )

The simple predicate which evaluates to true for the backward tracks:

 1000const LHCb::Track& track = ... ;
 1010const bool isBackward = TrBACKWARD ( track ) ;

See LHCb::Track::checkFlag.

TrCHI2, the instance of LoKi::Tracks::Chi2 ()

The simple function which evaluates of the track:

 1000const LHCb::Track& track = ... ;
 1010const double chi2 = TrCHI2 ( track ) ;

See LHCb::Track::chi2.

TrCLONE, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::Clone )

The simple predicate which evaluates to true for clones:

 1000const LHCb::Track& track = ... ;
 1010const bool isClone = TrCLONE ( track ) ;

See LHCb::Track::checkFlag.

TrCOUNTER, C++ type LoKi::Monitoring::Counter<LHCb::Track>

The special monitoring predicate, which could be used for monitoring of other predicates. The generic Gaudi counter StatEntity is used for monitoring:

 1000// the predicate to be monitored
 1010TrCut cut = ... ;
 1020
 1030// the generic counter:
 1040StatEntity* counter = ... ;
 1050
 1060// create the monitoring predicate:
 1070TrCut mon = TrCOUNTER ( cut , counter ) ;
 1080
 1090// use the counter:
 1100for ( .... ) 
 1110{
 1120   ...
 1130   const LHCb::Track& track = ... ;
 1140   const bool result = mon ( track ) ; ///< use the monitored predicate
 1150   ...
 1160}
 1170...
 1180// inspect the counter:
 1190info () 
 1200   << " Monitoring results : "                       << endreq 
 1210   << " NEntries:  #" << counter->entries ()         << endreq 
 1220   << " Efficiency:(" << counter->eff     ()   
 1230   << "+="            << counter->effErr  () << ")%" << endreq ;
 1240 

The alternative and recommended way for creation of of monitored predicates:

 1000// the predicate to be monitored 
 1010TrCut cut = ... ;
 1020
 1030// the monitored predicate 
 1040TrCut mon = monitor ( cut , counter ( "SomeEffCounter" ) ) ;
 1050     

The substitution of the predicate by the monitored predicate could be done "on-flight" without the disturbing of the actual processing:

 1000// The predicate to be monitored
 1010TrCut cut = ... ;
 1020     
 1030if ( monitoring ) 
 1040 {
 1050    cut = monitor ( cut , counter ( "Efficiency1" ) ) ;
 1060 }
 1070    

Attention:

• The string representation of the object is delegated to the underlying predicate, therefore the object is NOT reconstructable from its string representations. It is done on-purpose to avoid the disturbing of unique function IDs.

TrDOCA, C++ instance of LoKi::Track::DistanceOfClosestApproach()

The simple (bi)function, which evaluates Distance Of Closest Approach between two tracks:

 1000const LHCb::Track& track1 = ... ;
 1010const LHCb::Track& track2 = ... ;
 1020
 1030const bool doca = TrDOCA ( track1 , track2  ) ;

Attention:

• It is bi-function in Hlt terminology since it takes two arguments of type LHCb::Track.

TrDOWNSTREAM, the instance of TrEQUALTO(TrTYPE,LHCb::Track::Downstream )

Simple predicate which evaluates to true for the tracks of downstream type:

 1000const LHCb::Track& track = ... ;
 1010const bool isDown = TrDOWNSTREAM ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrEQUALTO, C++ type LoKi::EqualToValue<LHCb::Track>

Simple predicate which checks the quality of evaluation of some function to some predefined reference value:

 1000// some function
 1010TrFun fun = ... ;
 1020// check the equality to 0:
 1030TrCut isZero = TrEQUALTO ( fun , 0 ) ;
 1040
 1050const LHCb::Track& track = ... ;
 1060
 1070// the the predicate:
 1080const bool zero = isZero ( track ) ;

TrFALSE, the instance of LoKi::BooleanConstant<LHCb::Track> (false)

The most trivial predicate which always evaluates to false

TrFILTER, C++ type LoKi:Tracks::Selector

Simple predicate (wrapper) for ITrackSelector tool:

 1000// get the tool: 
 1010const ITrackSelector* selector = ... ;
 1020
 1030//create the predicate:
 1040TrCut accept = TrFILTER   ( selector ) ;
 1050     
 1060const LHCb::Track&    track = ... ;
 1070
 1080// use the presicate: 
 1090const bool OK = accept ( track ) ;

See also TrSELECTOR

TrHASINFO, C++ type LoKi::Tracks::HasInfo

Simple predicate which check the existence of extra-information for the track:

 1000const LHCb::Track& t = ... ;
 1010const int index = ... ;
 1020
 1030TrCut hasIndex = TrHASINFO( index ) ;
 1040      
 1050const bool good = hasIndex( p ) ;

See LHCb::Track::hasInfo().

TrHASSTATE, C++ type LoKi::Tracks::HasStateAt

Simple predicate which evaluates LHCb::Track::hasStateAt:

 1000const LHCb::Track& t = ... ;
 1010TrCut hasAtTT = TeHASSTATE ( LHCb::State::AtTT ) ;
 1020    
 1030const bool good = hasAtTT ( p ) ;
 1040  

TrINTES, the instance of LoKi::Tracks::InTES

The trivial predicate which checks if the track is registered in Transient Event Store.

TrINFO, C++ type LoKi::Tracks::Info

Simple function which evaluates LHCb::Track::info:

 1000const LHCb::Track& t = ... ;
 1010     
 1020const int index = ... ;
 1030     
 1040TrFun info = TrINFO( index , -1000 ) ;
 1050     
 1060const double result = info( t ) ;
 1070     

TrINVALID, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::Invalid )

The simple predicate which evaluates to true for invalid tracks:

 1000const LHCb::Track& track = ... ;
 1010const bool invalid = TrINVALID ( track ) ;

See LHCb::Track::checkFlag.

TrIPSELECTED, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::IPSelected )

The simple predicate which evaluates to true for IP-selected tracks:

 1000const LHCb::Track& track = ... ;
 1010const bool selectedByIP = TrIPSELECTED ( track ) ;

See LHCb::Track::checkFlag, TrISFLAG.

TrISFLAG, C++ type LoKi::Tracks::CheckFlag

The simple predicate which checks the type of the track:

 1000const LHCb::Track& track = ... ;
 1010TrCut invalid = TrISFLAG ( LHCb::Track::Invalid ) ;
 1020TrCut backward = TrISFLAG ( LHCb::Track::Backward ) ;

See LHCb::Track::checkFlag, TrBACKWARD, TrINVALID, TrCLONE, TrUSED, TrIPSELECTED, TrPIDSELECTED, TrSELECTED, TrL0CANDIDATE.

TrISONTRACK, C++ type LoKi::Tracks::IsOnTrack

Simple predicate which evaluates LHCb::Track::isOnTrack:

 1000const LHCb::Track& t = ... ;
 1010      
 1020const LHCb::LHCbID& id = ... ;
 1030TrCut onTrack = TrISONTRACK ( id ) ;
 1040     
 1050const bool ok = onTrack ( t ) ;
 1060   

TrKEY, the instance of LoKi::Tracks::Key

Simple function which returns the key of the track:

 1000const LHCb::Track& track = ... ;
 1010
 1020const bool keyIs15 = ( 15 == TrKEY ( track ) )  ;
 1030
 1040 

TrL0CANDIDATE, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::L0Candidate )

The simple predicate which evaluates to true for L0-candidates:

 1000const LHCb::Track& track = ... ;
 1010const bool l0 = TrL0CANDIDATE ( track ) ;

See LHCb::Track::checkFlag, TrISFLAG.

TrLONG, the instance of TrEQUALTO(TrTYPE,LHCb::Track::Long)

Simple predicate which evaluates to true for the tracks of long type:

 1000const LHCb::Track& track = ... ;
 1010const bool isLong = TrLONG ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrMUON, the instance of TrEQUALTO(TrTYPE,LHCb::Track::Muon)

Simple predicate which evaluates to true for the tracks of Muon type:

 1000const LHCb::Track& track = ... ;
 1010const bool isMuon  = TrMUON ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrNONE, the instance of LoKi::BooleanConstant<LHCb::Track> (false)

The most trivial predicate which always evaluates to false

TrONE, the instance of LoKi::Constant<LHCb::Track>(1)

The trivial function, which always return 1

TrP, the instance of LoKi::Tracks::Momentum

The function which evaluates LHCb::Track::p():

 1000const LHCb::Track& track = ... ;
 1010const double p = TrP ( track ) ;

TrPIDSELECTED, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::PIDSelected )

The simple predicate which evaluates to true for PID-selected tracks:

 1000const LHCb::Track& track = ... ;
 1010const bool selectedByPID = TrPIDSELECTED ( track ) ;

See LHCb::Track::checkFlag, TrISFLAG.

TrPLOT, C++ type LoKi::Monitoring::Plot<LHCb::Track>

The special monitoring function, which could be used for monitoring of other functions. The histogram (through its AIDA::IHistogram1D pointer) is filled with result of the function evaluation.

 1000// the function to be monitored
 1010TrFun fun = ... ;
 1020
 1030// the histogram
 1040AIDA::IHistogram1D* histo = ... ;
 1050
 1060// create the monitoring function:
 1070TrFun mon = TrPLOT ( fun , histo ) ;
 1080
 1090// use the function:
 1100for ( .... ) 
 1110{
 1120   ...
 1130   const LHCb::Track& track = ... ;
 1140   const double value = mon ( track ) ; ///< use the monitored function
 1150   ...
 1160}

The alternative and recommended way for creation of of monitored functions:

 1000// the function to be monitored 
 1010TrFun fun = ... ;
 1020
 1030// the monitored function:
 1040AIDA::IHistogram1D* histo = ... ; 
 1050TrFun mon = monitor ( fun , histo ) ;
 1060     

The substitution of the function by the monitored function could be done "on-flight" without the disturbing of the actual processing:

 1000// The function to be monitored
 1010TrFun fun = ... ;
 1020     
 1030if ( monitoring ) 
 1040 {
 1050    AIDA::IHistogram1D* histo = ... ;
 1060    fun = monitor ( fun , counter ( "Efficiency1" ) ) ;
 1070 }
 1080    

Attention:

• The string representation of the object is delegated to the underlying predicate, therefore the object is NOT reconstructable from its string representations. It is done on-purpose to avoid the disturbing of unique function IDs.

TrPROBCHI2, the instance of LoKi::Tracks::ProbChi2 ()

The simple function which evaluates -probability for the track:

 1000const LHCb::Track& track = ... ;
 1010const double prob = TrPROBCHI2 ( track ) ;

See LHCb::Track::probChi2().

TrPT, the instance of LoKi::Tracks::TransverseMomentum

The function which evaluates LHCb::Track::pt():

 1000const LHCb::Track& track = ... ;
 1010const double pt = TrPT ( track ) ;

TrQ, the instance of LoKi::Tracks::Charge

The function which evaluates LHCb::Track::charge():

 1000const LHCb::Track& track = ... ;
 1010const bool positive = 0 < TrQ ( track ) ;

TrSELECTED, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::Selected )

The simple predicate which evaluates to true for selected tracks:

 1000const LHCb::Track& track = ... ;
 1010const bool selected = TrSELECTED ( track ) ;

See LHCb::Track::checkFlag, TrISFLAG.

TrSELECTOR, C++ type LoKi:Tracks::Selector

Simple predicate (wrapper) for ITrackSelector tool:

 1000// get the tool: 
 1010const ITrackSelector* selector = ... ;
 1020
 1030//create the predicate:
 1040TrCut accept = TrSELECTOR   ( selector ) ;
 1050     
 1060const LHCb::Track&    track = ... ;
 1070
 1080// use the presicate: 
 1090const bool OK = accept ( track ) ;

See also [[#LoKiCutsTrFILTER[TrFILTER]].

TrSSWITCH, C++ type LoKi::SimpleSwitch<LHCb::Track>

The simple function whcuh acts according to the symbolic rule:

= result = condition( argument ) ? value1 : value2 =

Essentially it is the simplest way to convert predicate into function:

 1000// some complicated condition/predicate:
 1010TrCut cut = ... ;
 1020
 1030// effectively convert it into function:
 1040TrFun fun = TeSSWITCH ( cut , 1 , -1 ) ; 

TrSTAT, C++ type LoKi::Monitoring::Stat<LHCb::Track>

The special monitoring function, which could be used for monitoring of other functions. The generic Gaudi counter StatEntity is used for monitoring:

 1000// the function to be monitored
 1010TrFun fun = ... ;
 1020
 1030// the generic counter:
 1040StatEntity* counter = ... ;
 1050
 1060// create the monitoring function:
 1070TrFun mon = TrSTAT ( fun , counter ) ;
 1080
 1090// use the function:
 1100for ( .... ) 
 1110{
 1120   ...
 1130   const LHCb::Track& track = ... ;
 1140   const double value = mon ( track ) ; ///< use the monitored function
 1150   ...
 1160}
 1170...
 1180// inspect the counter:
 1190info () 
 1200   << " Monitoring results : "                 << endreq 
 1210   << " NEntries:  #" << counter->entries  ()  << endreq 
 1220   << " TotalSum:   " << counter->flag     ()  << endreq 
 1230   << " Mean+-RMS:  " << counter->flagMean () 
 1240   << "+="            << counter->flagRMS  ()  << endreq      
 1250   << " Min/Max:    " << counter->flagMin  ()  
 1260   << "/"             << counter->flagMax  ()  << endreq ;

The alternative and recommended way for creation of of monitored functions:

 1000// the function to be monitored 
 1010TrFun fun = ... ;
 1020
 1030// the monitored function: 
 1040TrFun mon = monitor ( fun , counter ( "SomeEffCounter" ) ) ;
 1050     

The substitution of the function by the monitored function could be done "on-flight" without the disturbing of the actual processing:

 1000// The function to be monitored
 1010TrFun fun = ... ;
 1020     
 1030if ( monitoring ) 
 1040 {
 1050    fun = monitor ( fun , counter ( "Efficiency1" ) ) ;
 1060 }
 1070    

Attention:

• The string representation of the object is delegated to the underlying predicate, therefore the object is NOT reconstructable from its string representations. It is done on-purpose to avoid the disturbing of unique function IDs.

TrSWITCH, C++ type LoKi::Switch<LHCb::Track>

The simple function which acts according to the symbolic rule:

= result = condition( argument ) ? function1( argument ) : function2( argument) =

Essentially it is the simplest way to convert predicate into function:

 1000// use negative Pt for "backward" tracks:
 1010TrFun pt = TrSWITCH ( TrBACKWARD , -1 * TrPT , TrPT ) ; 

TrTRUE, the instance of LoKi::BooleanConstant<LHCb::Track> (true)

The most trivial predicate which always evaluates to true

TrTTRACK, the instance of TrEQUALTO(TrTYPE,LHCb::Track::Ttrack)

Simple predicate which evaluates to true for the tracks of Ttrack type:

 1000const LHCb::Track& track = ... ;
 1010const bool isT = TrTTRACK ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrTYPE, the instance of LoKi::Tracks::Type ()

Simple function which returns the type of the track:

 1000const LHCb::Track& track = ... ;
 1010const bool isLong = LHCb::Track::Long == TrTYPE ( track ) ;

See LHCb::Track::type(), TrUNKNOWN, TrVELO, VELOR, TrLONG, TrUPSTREAM, TrDOWNSTREAM, TrTTRACK, TrMUON.

TrUNKNOWN, the instance of TrEQUALTO(TrTYPE,LHCb::Track::TypeUnknown)

Simple predicate which evaluates to true for the tracks of unknown type:

 1000const LHCb::Track& track = ... ;
 1010const bool isUnknown = TrUNKNOWN ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrUPSTREAM, the instance of TrEQUALTO(TrTYPE,LHCb::Track::Upstream)

Simple predicate which evaluates to true for the tracks of upstream type:

 1000const LHCb::Track& track = ... ;
 1010const bool isUp = TrUPSTREAM ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrUSED, the instance of LoKi::Tracks::CheckFlag ( LHCb::Track::Used )

The simple predicate which evaluates to true for the used tracks:

 1000const LHCb::Track& track = ... ;
 1010const bool isUsed = TrUSED( track ) ;

See LHCb::Track::checkFlag, TrISFLAG.

TrVELO, the instance of TrEQUALTO(TrTYPE,LHCb::Track::Velo)

Simple predicate which evaluates to true for the tracks of Velo type:

 1000const LHCb::Track& track = ... ;
 1010const bool isVelo = TrVELO ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrVELOR, the instance of TrEQUALTO(TrTYPE,LHCb::Track::VeloR)

Simple predicate which evaluates to true for the tracks of Velo-R type:

 1000const LHCb::Track& track = ... ;
 1010const bool isVeloR = TrVELOR ( track ) ;

See LHCb::Track::type(), TrTYPE and TrEQUALTO.

TrZERO, the instance of LoKi::Constant<LHCb::Track>(0)

The trivial function, which always return 0

---

-- Vanya Belyaev - 28 Jul 2007

---