T_AnalysisConfig_Tier0< T > Class Template Reference

#include <T_AnalysisConfig_Tier0.h>

Inheritance diagram for T_AnalysisConfig_Tier0< T >:

Collaboration diagram for T_AnalysisConfig_Tier0< T >:

Public Member Functions
	T_AnalysisConfig_Tier0 (const std::string &analysisInstanceName, const std::string &testChainName, const std::string &testType, const std::string &testKey, const std::string &referenceChainName, const std::string &referenceType, const std::string &referenceKey, TrackFilter *testFilter, TrackFilter *referenceFilter, TrackAssociator *associator, TrackAnalysis *analysis)
virtual	~T_AnalysisConfig_Tier0 ()
void	setRunPurity (bool b)
void	setShifter (bool b)
void	useBeamCondSvc (bool b)
void	containTracks (bool b)
void	addTestChain (const std::string &chainName, const std::string &type, const std::string &key)
void	addReferenceChain (const std::string &chainName, const std::string &type, const std::string &key)
void	addSelectionChain (const std::string &chainName, const std::string &type, const std::string &key)
void	addTestFilter (TrackFilter *filter)
void	addReferenceFilter (TrackFilter *filter)
void	addSelectionFilter (TrackFilter *filter)
virtual void	initialize (T *p, ToolHandle< Trig::TrigDecisionTool > *tdt)
virtual void	execute ()
const std::string &	name () const
const std::string	testChains () const
const std::string	referenceChains () const
const std::string	selectionChains () const
const TrackAnalysis *	analysis () const
void	setMCTruth (bool b=true)
bool	mcTruth () const
void	setBeamX (double d)
void	setBeamY (double d)
void	setBeamZ (double d)
double	beamX () const
double	beamY () const
double	beamZ () const
bool	genericFlag () const
void	setGenericFlag (bool b)
const std::string &	releaseData () const
void	keepAllEvents (bool b)
void	setUseHighestPT (bool b)
bool	getUseHighestPT () const
void	setVtxIndex (int i)
int	getVtxIndex () const
bool	filterOnRoi () const
bool	setFilterOnRoi (bool b)
void	setRequireDecision (bool b)
bool	requireDecision () const

Public Attributes
Analysis_Tier0 *	_analysis

Protected Member Functions
virtual void	loop ()
virtual void	book ()
virtual void	finalize ()
std::pair< typename Collection::const_iterator, typename Collection::const_iterator >	getCollection (const ElementLink< TrigRoiDescriptorCollection > &roi_link, const std::string &key="")
	new MT feature access
bool	select (std::vector< TIDA::Vertex > &vertices, xAOD::VertexContainer::const_iterator vtx_start, xAOD::VertexContainer::const_iterator vtx_end)
bool	selectTracks (TrigTrackSelector *selector, const ElementLink< TrigRoiDescriptorCollection > &roi_link, const std::string &key="")
StatusCode	retrieve (Collection const *&collection, const std::string &key="")
bool	selectTracksNotEmpty (TrigTrackSelector *selector, const std::string &key)
std::vector< double >	getBeamspot (const std::string &key)
unsigned	processElectrons (TrigTrackSelector &selectorRef, std::vector< TrackTrigObject > *elevec=0, const unsigned int selection=0, bool raw_track=false, double ETOffline=0, const std::string &containerName="ElectronAODCollection")
	select offline electrons
unsigned	processMuons (TrigTrackSelector &selectorRef, const unsigned int selection=0, double ETOffline=0, const std::string &containerName="StacoMuonCollection")
	select offlinqe muons
unsigned	processTaus (TrigTrackSelector &selectorRef, std::vector< TrackTrigObject > *tauvec=0, const unsigned selection=0, int requireNtracks=0, double EtCutOffline=0, const std::string &containerName="TauRecContainer")
	select offline taus

Protected Attributes
bool	m_useBeamCondSvc
TIDA::Event *	m_event
std::vector< ChainString >	m_chainNames
std::vector< Analysis_Tier0 * >	m_analyses
std::string	m_testType
bool	m_doOffline
bool	m_doMuons
bool	m_doElectrons
bool	m_doTaus
bool	m_doBjets
bool	m_hasTruthMap
bool	m_doTauThreeProng
bool	m_tauEtCutOffline
std::string	m_outputFileName
int	m_NRois
	output stats
int	m_NRefTracks
int	m_NTestTracks
bool	m_runPurity
bool	m_shifter
double	m_pTthreshold
bool	m_first
bool	m_containTracks
T *	m_provider
ToolHandle< Trig::TrigDecisionTool > *	m_tdt
std::string	m_analysisInstanceName
std::vector< std::vector< std::string > >	m_types
std::vector< std::vector< std::string > >	m_keys
std::string	m_refChainName
std::string	m_refChainKey
std::string	m_testChainName
std::string	m_testChainKey
std::vector< std::vector< TrackFilter * > >	m_filters
TrigTrackSelector *	m_selectorRef
TrigTrackSelector *	m_selectorTest
TrigTrackSelector *	m_selectorSel
TrackAssociator *	m_associator
TrackAnalysis *	m_analysis
bool	m_mcTruth
double	m_beamX
double	m_beamY
double	m_beamZ
int	m_genericFlag
std::string	m_releaseData
bool	m_keepAllEvents
bool	m_useHighestPT
int	m_vtxIndex
bool	m_filterOnRoi
bool	m_requireDecision

Detailed Description

template<typename T>
class T_AnalysisConfig_Tier0< T >

Definition at line 87 of file T_AnalysisConfig_Tier0.h.

Constructor & Destructor Documentation

T_AnalysisConfig_Tier0()

template<typename T>

T_AnalysisConfig_Tier0< T >::T_AnalysisConfig_Tier0 ( const std::string & analysisInstanceName, const std::string & testChainName, const std::string & testType, const std::string & testKey, const std::string & referenceChainName, const std::string & referenceType, const std::string & referenceKey, TrackFilter * testFilter, TrackFilter * referenceFilter, TrackAssociator * associator, TrackAnalysis * analysis )

inline

Definition at line 97 of file T_AnalysisConfig_Tier0.h.

                                        :
    T_AnalysisConfig<T>( analysisInstanceName,
             testChainName,      testType,      testKey,
             referenceChainName, referenceType, referenceKey,
             testFilter, referenceFilter,
             associator,
             analysis ),
    _analysis(0),
    m_useBeamCondSvc(false),
    m_doOffline(true),
    m_doMuons(false),
    m_doElectrons(false),
    m_doTaus(false),
    m_doBjets(false),
    m_hasTruthMap(false),
    m_doTauThreeProng(false),
    m_tauEtCutOffline(false),
    m_NRois(0),
    m_NRefTracks(0),
    m_NTestTracks(0),
    m_runPurity(false),
    m_shifter(false),
    m_pTthreshold(0),
    m_first(true),
    m_containTracks(false)
  {
    m_event = new TIDA::Event();
    m_chainNames.push_back(testChainName);
    
#if 0
    ChainString& chain = m_chainNames.back(); 
 
    std::cout << "\nT_AnalysisConfig_Tier0::name:                " << name() << "\t" << this << std::endl;
    std::cout <<  "T_AnalysisConfig_Tier0::chain specification: " << testChainName << " -> " << chain << "\t" << chain.raw() << std::endl;
    std::cout << "\tchain: " << chain.head()    << std::endl;
    std::cout << "\tkey:   " << chain.tail()    << std::endl;
    std::cout << "\troi:   " << chain.roi()     << std::endl;
    std::cout << "\tvtx:   " << chain.vtx()     << std::endl;
    std::cout << "\tte:    " << chain.element() << std::endl;
 
    std::cout << "\tpost:  " << chain.post()          << std::endl; 
    std::cout << "\tpt:    " << chain.postvalue("pt") << std::endl;
 
    std::cout << "\tcontainTracks: " << m_containTracks << std::endl; 
#endif
    
    m_testType = testType;
  }

~T_AnalysisConfig_Tier0()

template<typename T>

virtual T_AnalysisConfig_Tier0< T >::~T_AnalysisConfig_Tier0 ( )

inlinevirtual

Definition at line 151 of file T_AnalysisConfig_Tier0.h.

{ delete m_event; }

Member Function Documentation

addReferenceChain()

void T_AnalysisConfig< T >::addReferenceChain ( const std::string & chainName, const std::string & type, const std::string & key )

inlineinherited

Definition at line 203 of file T_AnalysisConfig.h.

                                                                                                  {
      m_chainNames[1].push_back(chainName); m_types[1].push_back(type); m_keys[1].push_back(key);
  }

addReferenceFilter()

void T_AnalysisConfig< T >::addReferenceFilter ( TrackFilter * filter )

inlineinherited

Definition at line 212 of file T_AnalysisConfig.h.

{ m_filters[1].push_back(filter); }

addSelectionChain()

void T_AnalysisConfig< T >::addSelectionChain ( const std::string & chainName, const std::string & type, const std::string & key )

inlineinherited

Definition at line 207 of file T_AnalysisConfig.h.

                                                                                                  {
      m_chainNames[2].push_back(chainName); m_types[2].push_back(type); m_keys[2].push_back(key);
  }

addSelectionFilter()

void T_AnalysisConfig< T >::addSelectionFilter ( TrackFilter * filter )

inlineinherited

Definition at line 213 of file T_AnalysisConfig.h.

{ m_filters[2].push_back(filter); }

addTestChain()

void T_AnalysisConfig< T >::addTestChain ( const std::string & chainName, const std::string & type, const std::string & key )

inlineinherited

Definition at line 199 of file T_AnalysisConfig.h.

                                                                                             {
      m_chainNames[0].push_back(chainName); m_types[0].push_back(type); m_keys[0].push_back(key);
  }

addTestFilter()

void T_AnalysisConfig< T >::addTestFilter ( TrackFilter * filter )

inlineinherited

Definition at line 211 of file T_AnalysisConfig.h.

{ m_filters[0].push_back(filter); }

analysis()

const TrackAnalysis * T_AnalysisConfig< T >::analysis ( ) const

inlineinherited

Definition at line 258 of file T_AnalysisConfig.h.

{return m_analysis;}

beamX()

double T_AnalysisConfig< T >::beamX ( ) const

inlineinherited

Definition at line 266 of file T_AnalysisConfig.h.

{ return m_beamX; }

beamY()

double T_AnalysisConfig< T >::beamY ( ) const

inlineinherited

Definition at line 267 of file T_AnalysisConfig.h.

{ return m_beamY; }

beamZ()

double T_AnalysisConfig< T >::beamZ ( ) const

inlineinherited

Definition at line 268 of file T_AnalysisConfig.h.

{ return m_beamZ; }

book()

template<typename T>

virtual void T_AnalysisConfig_Tier0< T >::book ( )

inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1192 of file T_AnalysisConfig_Tier0.h.

                      {
 
    if(m_provider->msg().level() <= MSG::VERBOSE)
      m_provider->msg(MSG::VERBOSE) << "AnalysisConfig_Tier0::book() " << name() << endmsg;
 
    m_provider->msg(MSG::ERROR) << "AnalysisConfig_Tier0::book() should no longer ever be called: " << name() << endmsg;
 
  }

containTracks()

template<typename T>

void T_AnalysisConfig_Tier0< T >::containTracks ( bool b )

inline

Definition at line 159 of file T_AnalysisConfig_Tier0.h.

{ m_containTracks = b; }

execute()

virtual void T_AnalysisConfig< T >::execute ( )

inlinevirtualinherited

Definition at line 225 of file T_AnalysisConfig.h.

                         {
      if ( !m_provider ) std::cerr << "ERROR T_AnalysisConfig::execute() called without initialising" << std::endl;
      loop();
  }

filterOnRoi()

bool T_AnalysisConfig< T >::filterOnRoi ( ) const

inlineinherited

Definition at line 284 of file T_AnalysisConfig.h.

{ return m_filterOnRoi; }

finalize()

template<typename T>

virtual void T_AnalysisConfig_Tier0< T >::finalize ( )

inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1203 of file T_AnalysisConfig_Tier0.h.

                          {
 
    if(m_provider->msg().level() <= MSG::VERBOSE)
      m_provider->msg(MSG::VERBOSE) << "AnalysisConfig_Tier0::finalise() " << m_provider->name() << endmsg;
 
    m_analysis->finalise();
 
    m_provider->msg(MSG::INFO) << m_provider->name() << " " << m_chainNames[0] << "   \tNRois processed: " << m_NRois << "\tRef tracks: " << m_NRefTracks << "\tTestTracks: " << m_NTestTracks << endmsg;
 
    if(m_provider->msg().level() <= MSG::VERBOSE)
      m_provider->msg(MSG::VERBOSE) << m_provider->name() << " finalised" << endmsg;
 
  }

genericFlag()

bool T_AnalysisConfig< T >::genericFlag ( ) const

inlineinherited

Definition at line 270 of file T_AnalysisConfig.h.

{ return m_genericFlag; }

getBeamspot()

std::vector< double > T_AnalysisConfig< T >::getBeamspot ( const std::string & key )

inlineprotectedinherited

Definition at line 634 of file T_AnalysisConfig.h.

                                                         {
    const Collection* collection = 0;
    std::vector<double> v;
 
    if ( key!="" ) {
      if ( m_provider->evtStore()->template contains<Collection>( key ) ) {
    StatusCode sc = retrieve( collection, key );
    if( sc.isSuccess() && collection ) {
      m_provider->msg(MSG::DEBUG) << "SG Collection->size() " << collection->size() << " (" << key << ")" << endmsg;
 
      typename Collection::const_iterator  trackitr = collection->begin();
      typename Collection::const_iterator  trackend = collection->end();
      if ( trackitr!=trackend ) {
        v.resize(3);
        v[0] = (*trackitr)->vx();
        v[1] = (*trackitr)->vy();
        v[2] = (*trackitr)->vz();
        return v;
      } // only need to look at the first track
    }
      }
    }
    return v;
  }

getCollection()

std::pair< typename Collection::const_iterator, typename Collection::const_iterator > T_AnalysisConfig< T >::getCollection ( const ElementLink< TrigRoiDescriptorCollection > & roi_link, const std::string & key = "" )

inlineprotectedinherited

new MT feature access

will need this printout for debugging the feature access, so leave this commented until it has been properly debugged, then it can be removed

will not use the te name here, but keep it on just the same for the time being, for subsequent development

Definition at line 299 of file T_AnalysisConfig.h.

                                    {

    //    std::cout << "try " << key << "\t" << m_provider->evtStore()->template transientContains<Collection>(key) << std::endl;

    std::string key_collection = key;
    std::string key_tename     = "";
    size_t pos = key_collection.find("/");
    if ( pos!=std::string::npos ) {
      key_collection = key.substr( pos+1, key.size()-pos );
      key_tename     = key.substr( 0, pos );
    }
 
    std::pair< typename Collection::const_iterator,
           typename Collection::const_iterator > itrpair;
 
    SG::ReadHandle<Collection> handle(key);
 
    CLID checkCLID;
    const std::string* keyStr = m_provider->evtStore()->keyToString(roi_link.key(), checkCLID);
    m_provider->msg(MSG::DEBUG) << "Requesting range over (" << key << ") associated to ROI from " << (keyStr == nullptr ? "UNKNOWN" : *keyStr) << endmsg;
 
    itrpair = (*m_tdt)->associateToEventView( handle, roi_link );
 
    return itrpair;
  }

getUseHighestPT()

bool T_AnalysisConfig< T >::getUseHighestPT ( ) const

inlineinherited

Definition at line 279 of file T_AnalysisConfig.h.

{ return m_useHighestPT; }

getVtxIndex()

int T_AnalysisConfig< T >::getVtxIndex ( ) const

inlineinherited

Definition at line 282 of file T_AnalysisConfig.h.

{ return m_vtxIndex; }

initialize()

virtual void T_AnalysisConfig< T >::initialize ( T * p, ToolHandle< Trig::TrigDecisionTool > * tdt )

inlinevirtualinherited

Definition at line 216 of file T_AnalysisConfig.h.

                                                                               {
      m_provider = p;
      m_tdt      = tdt;
      if ( m_tdt==0 ) m_analysis->initialise();
      
  }

keepAllEvents()

void T_AnalysisConfig< T >::keepAllEvents ( bool b )

inlineinherited

Definition at line 276 of file T_AnalysisConfig.h.

{ m_keepAllEvents = b; }

loop()

template<typename T>

virtual void T_AnalysisConfig_Tier0< T >::loop ( )

inlineprotectedvirtual

handle wildcard chain selection - but only the first time NB: also check all other chains as well - only set up an analysis for configured chains

get chain

get matching chains

replace wildcard with actual matching chains ...

end of first event setup

all this should perhaps be class variables

will need to add a vertex filter at some point probably

now start everything going for this event properly ...

(obviously) get the event info

first check whether the chains have actually run, otherwise there's no point doing anything

for Monte Carlo get the truth particles if requested to do so

get the offline vertices into our structure

add the truth particles if needed

now add the vertices

now add the offline tracks and reco objects

now loop over all relevant chains to get the trigger tracks...

create chains for ntpl

why does this need to be a class variable ???

and the index of the collection (if any)

Get chain combinations and loop on them

• loop made on chain selected as the one steering RoI creation

only use the TDT for extracting collections if this was a trigger analysis for fullscan "offline" type analyses (ie fullscan FTK) do not use this

dummy full scan chain

HLT and EF-like EDM

L2 track EDM

get vertex information

now also add xAOD vertices

leave this code commented so that we have a record of the change - as soon as we can fix the missing track multiplicity from the vertex this will need to go back

variances

quality

retrieve online vertices

loop over combinations

"offline" type chains

now loop over the rois (again)

This is nonsense and needs restructuring - why is the truth and offline selection done within this RoI loop? It means the complete offline and truth tracks will be retrieved for every RoI ! really we should have the structure

• check_a_trigger_chain_has_passed
• get_offline_or_truth_particles
• loop_over_rois
  • get_trigger_tracks
  • filter_offline_or_truth_reference
  • match_tracks
  • call_analyis_routine

will leave as it is for the time being

AOD

anything else?

selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );

now as a check go through the GenEvent collection

found this key

not found any truth collection

count of "events" - or interactions

count of particles

count of "events with some particles"

count of particles in this interaction

hooray! actually found a sensible event

if there were some particles in this interaction ...

need to be careful here, if not requiring truth only should not return

get offline tracks

what is this ???

what is this for ???

if we want a purity, we need to swap round which tracks are the reference tracks and which the test tracks

stats book keeping

match test and reference tracks

filter on highest pt track only if required

ignore all tracks belong the specific analysis pt threshold if set

stats book keeping

match test and reference tracks

get vertices for this roi - have to copy to a vector<Vertex*>

Implements T_AnalysisConfig< T >.

Definition at line 188 of file T_AnalysisConfig_Tier0.h.

                      {
 
    if( m_provider->msg().level() <= MSG::VERBOSE) {
      m_provider->msg(MSG::VERBOSE) <<  "AnalysisConfig_Tier0::loop() for " << T_AnalysisConfig<T>::m_analysisInstanceName <<  endmsg;
    }
 
    // get (offline) beam position
    double xbeam = 0;
    double ybeam = 0;
 
    if ( m_first ) {
 
      m_first = false;
      
      m_provider->msg(MSG::VERBOSE) << " using beam position\tx=" << xbeam << "\ty=" << ybeam << endmsg;
 
      if (m_provider->msg().level() <= MSG::VERBOSE) {
    
    std::vector<std::string> configuredChains  = (*(m_tdt))->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
    
        for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
      m_provider->msg(MSG::VERBOSE)  << "Chain " << configuredChains[i]  << endmsg;
        }
 
      }
 
 
      std::vector<ChainString>::iterator chainitr = m_chainNames.begin();
 
      std::vector<ChainString> chains;

      while ( chainitr!=m_chainNames.end() ) {

        ChainString& chainName = (*chainitr);
 
        m_provider->msg(MSG::INFO) << "process chain " << chainName << endmsg;
 
    if ( chainName.head() == "" ) { 
      
      std::string selectChain = chainName.raw();
 
      chains.push_back( ChainString(selectChain) );
        
      if ( m_provider->msg().level() <= MSG::VERBOSE ) {
        m_provider->msg(MSG::VERBOSE) << "Matching chain " << selectChain << " (" << chainName.head() << ")" << endmsg;
      }
 
    }
    else { 

      std::vector<std::string> selectChains  = (*(m_tdt))->getListOfTriggers( chainName.head() );
      
      
      for ( unsigned iselected=0 ; iselected<selectChains.size() ; iselected++ ) {
        
        selectChains[iselected] = chainName.subs( selectChains[iselected] );
 
#if 0
        std::cout << "sorting:: chain specification: " << chainName << "\traw:" << chainName.raw() << std::endl;
        std::cout << "\tchain: " << chainName.head()    << std::endl;
        std::cout << "\tkey:   " << chainName.tail()    << std::endl;
        std::cout << "\troi:   " << chainName.roi()     << std::endl;
        std::cout << "\tvtx:   " << chainName.vtx()     << std::endl;
        std::cout << "\tte:    " << chainName.element() << std::endl;
        std::cout << "\tind:   " << chainName.extra()   << std::endl;
#endif
        
        chains.push_back( ChainString(selectChains[iselected]) );
        
        if(m_provider->msg().level() <= MSG::VERBOSE) {
          m_provider->msg(MSG::VERBOSE) << "Matching chain " << selectChains[iselected] << " (" << chainName.head() << ")" << endmsg;
        }
        
      }
    }
 
        ++chainitr;
      }
 
      // m_chainNames.insert( m_chainNames.end(), chains.begin(), chains.end() );
      m_chainNames = chains;
 
      for ( unsigned ic=0 ; ic<m_chainNames.size() ; ic++ ) m_provider->msg(MSG::VERBOSE) << "Analyse chain " << m_chainNames[ic] << endmsg;
 
    } 
 

    Filter_True filter;
 
    Filter_etaPT     filter_etaPT(5,200);
    Filter_Combined filter_truth( &filter_etaPT,   &filter_etaPT);

    // Filter_Combined filterRef (&filter_offline, &filter_vertex);
 
    int iRefFilter  = 1;
    int iTestFilter = 0;
 
    if ( m_runPurity ) { 
      iRefFilter  = 0;
      iTestFilter = 1;
    }
    
    Filter_Combined filterRef(   m_filters[iRefFilter][0],  &filter );
    Filter_Combined filterTest(  m_filters[iTestFilter][0], &filter );
 
    TrigTrackSelector selectorTruth( &filter_truth );
    TrigTrackSelector selectorRef( &filterRef );
    m_selectorRef = &selectorRef;
    TrigTrackSelector selectorTest( &filterTest );
    m_selectorTest = &selectorTest;
 
    if ( xbeam!=0 || ybeam!=0 ) { 
      m_selectorRef->setBeamline(  xbeam, ybeam );
    }  

 
    // clear the ntuple TIDA::Event class
    m_event->clear();

#ifndef  XAODTRACKING_TRACKPARTICLE_H
    const EventInfo* pEventInfo;
#else
    const xAOD::EventInfo* pEventInfo;
#endif
    unsigned           run_number        = 0;
    uint64_t           event_number      = 0;
    unsigned           lumi_block        = 0;
    unsigned           bunch_crossing_id = 0;
    unsigned           time_stamp        = 0;
    double             mu_val            = 0;
 
    if ( this->template retrieve(pEventInfo, "EventInfo").isFailure() ) {
      m_provider->msg(MSG::WARNING) << "Failed to get EventInfo " << endmsg;
    } else {
 
#ifndef  XAODTRACKING_TRACKPARTICLE_H
      run_number        = pEventInfo->event_ID()->run_number();
      event_number      = pEventInfo->event_ID()->event_number();
      lumi_block        = pEventInfo->event_ID()->lumi_block();
      time_stamp        = pEventInfo->event_ID()->time_stamp();
      bunch_crossing_id = pEventInfo->event_ID()->bunch_crossing_id();
      mu_val            = pEventInfo->averageInteractionsPerCrossing();
#else
      run_number        = pEventInfo->runNumber();
      event_number      = pEventInfo->eventNumber();
      lumi_block        = pEventInfo->lumiBlock();
      time_stamp        = pEventInfo->timeStamp();
      bunch_crossing_id = pEventInfo->bcid();
      mu_val            = pEventInfo->averageInteractionsPerCrossing();
#endif
    }
  
    if(m_provider->msg().level() <= MSG::VERBOSE){
      m_provider->msg(MSG::VERBOSE) << "run "     << run_number
                                    << "\tevent " << event_number
                                    << "\tlb "    << lumi_block << endmsg;
    }
    
    //      m_provider->msg(MSG::INFO) << "run "     << run_number
    //               << "\tevent " << event_number
    //               << "\tlb "    << lumi_block << endmsg;
 
    // std::cout << "run "     << run_number  << "\tevent " << event_number  << "\tlb "    << lumi_block << std::endl;
 
 
    // clear the ntuple TIDA::Event class
    m_event->clear();
 
    m_event->run_number(run_number);
    m_event->event_number(event_number);
    m_event->lumi_block(lumi_block);
    m_event->time_stamp(time_stamp);
    m_event->bunch_crossing_id(bunch_crossing_id);
    m_event->mu(mu_val);

 
    bool analyse = false;
  
    // Check HLTResult
 
    for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
 
      const std::string& chainname = m_chainNames[ichain].head();
 
      if ( chainname == "" ) analyse = true;
      else { 
 
    //Only for trigger chains
    if ( chainname.find("L2")  == std::string::npos &&
         chainname.find("EF")  == std::string::npos &&
         chainname.find("HLT") == std::string::npos ) continue;
    
    if ( m_provider->msg().level() <= MSG::DEBUG ) {
      m_provider->msg(MSG::DEBUG) << "Chain "  << chainname
                      << "\tpass " << (*m_tdt)->isPassed(chainname)
                      << "\tpres " << (*m_tdt)->getPrescale(chainname) << endmsg;
    }
    
    //      std::cout << "Chain "  << chainname << "\tpass " << (*m_tdt)->isPassed(chainname)
    //          << "\tpres " << (*m_tdt)->getPrescale(chainname) << std::endl;
    
    if ( (*(m_tdt))->isPassed(chainname) || (*(m_tdt))->getPrescale(chainname) ) analyse = true;
    
      }
    }
    
    //  Remove this code to skip on truncated HLT results
    //  Need to leave the code here for the time being however, since we will
    //  still need in the future a more robust test to achieve this same
    //  functionality
    // 
    //    if ( (*m_tdt)->ExperimentalAndExpertMethods().isHLTTruncated() ) {
    //      m_provider->msg(MSG::WARNING) << "HLTResult truncated, skipping event" << endmsg;
    //      return;
    //    }
    
    if ( !this->m_keepAllEvents && !analyse ) {
      //     m_provider->msg(MSG::VERBOSE) << "No chains passed unprescaled - not processing this event" << endmsg;
      if(m_provider->msg().level() <= MSG::VERBOSE)
        m_provider->msg(MSG::VERBOSE) << "No chains passed unprescaled - not processing this event" << endmsg;
      return;
    }

 
    selectorTruth.clear();
 
    if(m_provider->msg().level() <= MSG::VERBOSE)
      m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
 
    const TrigInDetTrackTruthMap* truthMap = 0;
 
    if ( m_mcTruth ) {
      if(m_provider->msg().level() <= MSG::VERBOSE ) m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
 
      if ( this->template retrieve(truthMap, "TrigInDetTrackTruthMap").isFailure()) {
        if(m_provider->msg().level() <= MSG::VERBOSE)
          m_provider->msg(MSG::VERBOSE) << "TrigInDetTrackTruthMap not found" << endmsg;
        m_hasTruthMap = false;
      }
      else {
        if(m_provider->msg().level() <= MSG::VERBOSE)
          m_provider->msg(MSG::VERBOSE) << "TrigInDetTrackTruthMap found" << endmsg;
        m_hasTruthMap = true;
      }
    }
    

 
    std::vector<TIDA::Vertex> vertices;
    std::vector<TIDA::Vertex> vertices_rec;
 
    std::vector<double> refbeamspot;
    std::vector<double> testbeamspot;
 
 
 
#ifndef XAODTRACKING_TRACKPARTICLE_H
 
    const VxContainer* primaryVtxCollection;
 
    if ( m_doOffline ) {
      if ( m_provider->evtStore()->template contains<VxContainer>("VxPrimaryCandidate") ) {
        if ( this->template retrieve(primaryVtxCollection, "VxPrimaryCandidate").isFailure()) {
          if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "Primary vertex container not found" << endmsg;
        }
        else {
          VxContainer::const_iterator vtxitr = primaryVtxCollection->begin();
          for ( ; vtxitr != primaryVtxCollection->end(); ++vtxitr) {
            if ( (*vtxitr)->vxTrackAtVertex()->size()>0 ) {
              vertices.push_back( TIDA::Vertex( (*vtxitr)->recVertex().position().x(),
                        (*vtxitr)->recVertex().position().y(),
                        (*vtxitr)->recVertex().position().z(),
                        0,0,0,
                        (*vtxitr)->vxTrackAtVertex()->size() ) );
            }
          }
        }
    
        // filter_vertex.setVertex(vertices);
      }
    }
 
#else
 
    //std::vector<TIDA::Vertex> vertices;
    
    m_provider->msg(MSG::VERBOSE) << "fetching AOD Primary vertex container" << endmsg;
 
    const xAOD::VertexContainer* xaodVtxCollection = 0;
 
    if ( this->template retrieve( xaodVtxCollection, "PrimaryVertices" ).isFailure()) {
      if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "xAOD Primary vertex container not found with key " << "PrimaryVertices" <<  endmsg;
    }
    
    if ( xaodVtxCollection!=0 ) { 
        
      m_provider->msg(MSG::VERBOSE) << "xAOD Primary vertex container " << xaodVtxCollection->size() <<  " entries" << endmsg;
 
      xAOD::VertexContainer::const_iterator vtxitr = xaodVtxCollection->begin();
      for ( ; vtxitr != xaodVtxCollection->end(); ++vtxitr ) {
    if ( (*vtxitr)->nTrackParticles()>0 && (*vtxitr)->vertexType()!=0 ) {
      vertices.push_back( TIDA::Vertex( (*vtxitr)->x(),
                        (*vtxitr)->y(),
                        (*vtxitr)->z(),
                        (*vtxitr)->covariancePosition()(Trk::x,Trk::x),
                        (*vtxitr)->covariancePosition()(Trk::y,Trk::y),
                        (*vtxitr)->covariancePosition()(Trk::z,Trk::z),
                        (*vtxitr)->nTrackParticles(),
                        (*vtxitr)->chiSquared(),
                        (*vtxitr)->numberDoF() ) );
    }
      }
    }
 
 
#endif
 

 
    if ( m_mcTruth ) {
      m_event->addChain( "Truth" );
      m_event->back().addRoi(TIDARoiDescriptor());
      m_event->back().back().addTracks(selectorTruth.tracks());
    }

 
    if ( m_doOffline ) {
      for ( unsigned i=0 ; i<vertices.size() ; i++ )  {
        if(m_provider->msg().level() <= MSG::VERBOSE)
          m_provider->msg(MSG::VERBOSE) << "vertex " << i << " " << vertices[i] << endmsg;
        m_event->addVertex(vertices[i]);
      }
    }

 
    // int Noff = 0;
    std::vector<TIDA::Track*> offline_tracks;
    std::vector<TIDA::Track*> electron_tracks;
    std::vector<TIDA::Track*> muon_tracks;
 
    std::vector<TIDA::Track*> ref_tracks;
    std::vector<TIDA::Track*> test_tracks;
 
    offline_tracks.clear();
    electron_tracks.clear();
    muon_tracks.clear();
 
    ref_tracks.clear();
    test_tracks.clear();

    for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
 
      test_tracks.clear();

 
      // std::string& chainname = chains[ichain];
      const std::string& chainname = m_chainNames[ichain].head();
      const std::string&       key = m_chainNames[ichain].tail();
      const std::string&  vtx_name = m_chainNames[ichain].vtx();
      //no currently used but retained in case
      //const std::string&  roi_name = m_chainNames[ichain].roi();
      //const std::string&   te_name = m_chainNames[ichain].element();
 
      m_pTthreshold = 0;  
 
      if ( m_chainNames[ichain].postcount() ) { 
        std::string ptvalue = m_chainNames[ichain].postvalue("pt");
    if ( ptvalue!="" ) m_pTthreshold = std::stod(ptvalue);
      }
 
      //      std::cout << "\tchain " << m_chainNames[ichain] << "\tchainname " << chainname << "\tvtx " << vtx_name << "\troi " << roi_name << std::endl;
 
      unsigned _decisiontype = TrigDefs::Physics;
      unsigned  decisiontype;
     
      if ( this->requireDecision() ) _decisiontype =  TrigDefs::requireDecision;
      
      
      if ( m_chainNames[ichain].passed() ) decisiontype = _decisiontype;
      else                                 decisiontype = TrigDefs::alsoDeactivateTEs;
 
      //      if ( decisiontype==TrigDefs::requireDecision ) std::cout << "\tSUTT TrigDefs::requireDecision " << decisiontype << std::endl;
      //      if ( decisiontype==TrigDefs::Physics )         std::cout << "\tSUTT TrigDefs::Physics "         << decisiontype << std::endl;
 

      const std::string& key_index_string = m_chainNames[ichain].extra();
      unsigned key_index = 0;
      if ( key_index_string!="" ) key_index = std::atoi( key_index_string.c_str() );
 
      if ( chainname!="" && m_provider->msg().level() <= MSG::VERBOSE ) {
 
        m_provider->msg(MSG::VERBOSE) << "status for chain " << chainname
                                      << "\tpass "           << (*m_tdt)->isPassed(chainname)
                                      << "\tprescale "       << (*m_tdt)->getPrescale(chainname) << endmsg;
 
        m_provider->msg(MSG::VERBOSE) << "fetching features for chain " << chainname << endmsg;
    
        m_provider->msg(MSG::VERBOSE) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << endmsg;
      }
 
      //      std::cout << "\tstatus for chain " << chainname
      //        << "\tpass "           << (*m_tdt)->isPassed( chainname )
      //        << "\tpassdt "         << (*m_tdt)->isPassed( chainname, decisiontype )
      //        << "\tprescale "       << (*m_tdt)->getPrescale( chainname ) << std::endl;
    
 
      //   m_provider->msg(MSG::INFO) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << "\t" << m_chainNames[ichain] << "\trun " << run_number << "\tevent " << event_number << endmsg;
 
 
      if ( chainname!="" && !this->m_keepAllEvents && !(*m_tdt)->isPassed( chainname, decisiontype ) ) continue;

      // Trig::FeatureContainer f = (*m_tdt)->features( chainname, TrigDefs::alsoDeactivateTEs);
     
 
      ChainString& chainConfig = m_chainNames[ichain];
 
      std::string chainName = chainConfig.head();
 
      m_event->addChain( chainConfig );
    
      TIDA::Chain& chain = m_event->back();
    
      if ( chainName == "" ) { 
 
        m_selectorTest->clear();
    
 
    TIDARoiDescriptor* roiInfo = new TIDARoiDescriptor(true);
        
        chain.addRoi( *roiInfo );
    
 
#       ifdef XAODTRACKING_TRACKPARTICLE_H
    if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>(key) ) {
      this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, key );
      refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( key );
    }
#       endif
 
        const std::vector<TIDA::Track*>& testtracks = m_selectorTest->tracks();
 
        chain.back().addTracks(testtracks);
    
        delete roiInfo;
 
      }
      else {
 
    Trig::FeatureContainer f = (*m_tdt)->features( chainname, decisiontype );
    Trig::FeatureContainer::combination_const_iterator c(f.getCombinations().begin());
    Trig::FeatureContainer::combination_const_iterator cEnd(f.getCombinations().end());
    
 
    if ( c==cEnd ) {
      if(m_provider->msg().level() <= MSG::VERBOSE){
        m_provider->msg(MSG::VERBOSE) << "No combinations: skipping this chain " << chainname << endmsg;
      }
      continue;
    }
    
    if(m_provider->msg().level() <= MSG::VERBOSE) {
      m_provider->msg(MSG::VERBOSE) << "combinations for chain " << chainname << " " << (cEnd-c) << endmsg;
    }
    
    unsigned icomb = 0;
    
    for( ; c!=cEnd ; ++c ) {
      
      icomb++;
      
      //   now add rois to this ntuple chain
      
      // Get seeding RoI
      // std::vector< Trig::Feature<TrigRoiDescriptor> > initRois = c->get<TrigRoiDescriptor>("initialRoI", TrigDefs::alsoDeactivateTEs);
      // std::vector< Trig::Feature<TrigRoiDescriptor> > initRois = c->get<TrigRoiDescriptor>("forID", TrigDefs::alsoDeactivateTEs);
      
      std::vector< Trig::Feature<TrigRoiDescriptor> > initRois;
      
      std::string roi_key = m_chainNames[ichain].roi();
      
      if ( roi_key=="SuperRoi" && icomb>1 ) continue;
      
      if ( roi_key!="" ) { 
        initRois = c->get<TrigRoiDescriptor>(roi_key, decisiontype );
      }
      else { 
        initRois = c->get<TrigRoiDescriptor>("forID", decisiontype ); 
        if ( initRois.empty() ) initRois = c->get<TrigRoiDescriptor>("", decisiontype ); 
        if ( initRois.empty() ) initRois = c->get<TrigRoiDescriptor>("initialRoI", decisiontype );
      }
      
      //    std::cout << "initRois.size() " << initRois.size() << std::endl;
      
      if ( initRois.empty() ) continue;
      
      
      //    for ( unsigned ir=0 ; ir<initRois.size() ; ir++ ) { 
      //      std::cout << "\t" << ir << "\t" << *initRois[ir].cptr() << std::endl;
      //    }
      
      // Skip chains seeded by multiple RoIs: not yet implemented
      if(initRois.size()>1 && roi_key!="SuperRoi" ) {
        if(m_provider->msg().level() <= MSG::VERBOSE)
          m_provider->msg(MSG::VERBOSE) << " More than one initial RoI found for seeded chain " << chainname << ": not yet supported" << endmsg;
        continue;
      }
      
      TIDARoiDescriptor* roiInfo = 0;
      
      if( !initRois.empty() ) {
        const TrigRoiDescriptor* roid = initRois[0].cptr();
        
        if(m_provider->msg().level() <= MSG::VERBOSE)
          m_provider->msg(MSG::VERBOSE) << " RoI descriptor for seeded chain " << chainname << " " << *roid << endmsg;
        
        roiInfo = new TIDARoiDescriptor(TIDARoiDescriptorBuilder(*roid));
        //  roiInfo->etaHalfWidth(m_roiInfo->etaHalfWidth());
        //  roiInfo->phiHalfWidth(m_roiInfo->phiHalfWidth());
        //  roiInfo->etaHalfWidth(roid->etaHalfWidth());
        //  roiInfo->phiHalfWidth(roid->phiHalfWidth());
        //  roiInfo->zedHalfWidth(roid->zedHalfWidth());
        
        if(m_provider->msg().level() <= MSG::VERBOSE)
          m_provider->msg(MSG::VERBOSE) << "using chain roi " << *roid << endmsg;
        
      }
      else {
        roiInfo = new TIDARoiDescriptor();
        //  roiInfo->etaHalfWidth(5);
        //  roiInfo->phiHalfWidth(M_PI);
        //  roiInfo->zedHalfWidth(m_roiInfo->zedHalfWidth());
        
        if(m_provider->msg().level() <= MSG::WARNING)
          m_provider->msg(MSG::WARNING) << "roi not found" <<  endmsg;
        
      }
      
      if(m_provider->msg().level() <= MSG::VERBOSE) m_provider->msg(MSG::VERBOSE) << *roiInfo << endmsg;
      
      m_selectorTest->clear();
      
      m_provider->msg(MSG::VERBOSE) << "Searching for collection " << key << endmsg;
      // std::cout << "Searching for collection " << key << std::endl;
      
      if ( key.find("InDetTrigParticleCreation")!=std::string::npos ||
           key.find("_IDTrig")!=std::string::npos ||
           key.find("_EFID")!=std::string::npos ||
           chainName.find("EF_")!=std::string::npos ||
           chainName.find("HLT_")!=std::string::npos ) {
#         ifdef XAODTRACKING_TRACKPARTICLE_H
        if      ( this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, c, key ) ) testbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( c, key );
        else if ( this->template selectTracks<Rec::TrackParticleContainer>( m_selectorTest, c, key ) );
#         else
        if ( this->template selectTracks<Rec::TrackParticleContainer>( m_selectorTest, c, key ) );
#         endif
        else if ( this->template selectTracks<TrackCollection>( m_selectorTest, c, key ) );
        else if ( this->template selectTracks<TrigInDetTrackCollection>( m_selectorTest, c, truthMap, key, key_index ) );
        else { 
          //m_provider->msg(MSG::WARNING) << "No track collection " << key << " found"  << endmsg;
        }
      }
      else {
        if ( chainName.find("L2_")!=std::string::npos ) {
          if      ( this->template selectTracks<TrigInDetTrackCollection>( m_selectorTest, c, truthMap, key, key_index ) );
          else if ( this->template selectTracks<Rec::TrackParticleContainer>( m_selectorTest, c, key ) );
          else if ( this->template selectTracks<TrackCollection>( m_selectorTest, c, key ) );
#           ifdef XAODTRACKING_TRACKPARTICLE_H
          else if ( this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, c, key ) ) testbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( c, key );
#           endif
          else m_provider->msg(MSG::WARNING) << "No track collection " << key << " found"  << endmsg;
        }
      }
      
      
      const std::vector<TIDA::Track*>& testtracks = m_selectorTest->tracks();
      
      m_provider->msg(MSG::VERBOSE) << "test tracks.size() " << testtracks.size() << endmsg;
      // std::cout << "test tracks.size() " << testtracks.size() << std::endl;
      
      //    std::cout  << "\ttest tracks.size() " << testtracks.size() << std::endl;
      
      if ( m_provider->msg().level() <= MSG::VERBOSE ) {
        m_provider->msg(MSG::VERBOSE) << "test tracks.size() " << testtracks.size() << endmsg;
        for ( int ii=testtracks.size() ; ii-- ; ) {
          m_provider->msg(MSG::VERBOSE) << "  test track " << ii << " " << *testtracks[ii] << endmsg;
          //test_tracks.push_back(testtracks.at(ii));
        }
      }
      
      chain.addRoi( *roiInfo );
      
      chain.back().addTracks(testtracks);
      
      delete roiInfo;
      
      
      
      //    std::cout << "vertex " << vtx_name << "\tchain " << chainName << "\tconfig " << chainConfig << std::endl;
      
      if ( vtx_name!="" ) { 
        
        m_provider->msg(MSG::VERBOSE) << "\tFetch xAOD::VertexContainer for chain " << chainConfig << " with key " << vtx_name << endmsg;
        
        std::vector< Trig::Feature<xAOD::VertexContainer> > xaodtrigvertices = c->get<xAOD::VertexContainer>(vtx_name);
        
        if ( xaodtrigvertices.empty() ) { 
          if ( m_provider->msg().level() <= MSG::DEBUG ) {
        m_provider->msg(MSG::WARNING) << "\tNo xAOD::VertexContainer for chain " << chainConfig << " for key " << vtx_name << endmsg;
          }
        }
        else {
          
          m_provider->msg(MSG::VERBOSE) << "\txAOD::VertexContainer found with size  " << xaodtrigvertices.size() << "\t" << vtx_name << endmsg;
          
          for (  unsigned iv=0  ;  iv<xaodtrigvertices.size()  ;  iv++ ) {
        
        const xAOD::VertexContainer* vert = xaodtrigvertices[iv].cptr();
        
        m_provider->msg(MSG::VERBOSE) << "\t" << iv << "  xAOD VxContainer for " << chainConfig << " " << vert << " key " << vtx_name << endmsg;
        
        xAOD::VertexContainer::const_iterator vtxitr = vert->begin();
        
        for ( ; vtxitr != vert->end(); ++vtxitr) {
          //  if ( ( (*vtxitr)->nTrackParticles()>0 && (*vtxitr)->vertexType()!=0 ) || vtx_name=="EFHistoPrmVtx" ) {
          if ( (*vtxitr)->vertexType()!=0 || vtx_name=="EFHistoPrmVtx" ) {
            chain.back().addVertex( TIDA::Vertex( (*vtxitr)->x(),
                              (*vtxitr)->y(),
                              (*vtxitr)->z(),
                              (*vtxitr)->covariancePosition()(Trk::x,Trk::x),
                              (*vtxitr)->covariancePosition()(Trk::y,Trk::y),
                              (*vtxitr)->covariancePosition()(Trk::z,Trk::z),
                              (*vtxitr)->nTrackParticles(),
                              (*vtxitr)->chiSquared(),
                              (*vtxitr)->numberDoF() ) );
            
          }
        }
          }
          
        }
        
      } 
      
    } 
 
      } 
    
    
      if ( m_provider->msg().level() <= MSG::VERBOSE ) {
    m_provider->msg(MSG::VERBOSE) << "event: " << *m_event << endmsg;
      }
      
      
      for ( unsigned iroi=0 ; iroi<chain.size() ; iroi++ ) {
    
    m_selectorRef->clear();
    
    if ( this->filterOnRoi() ) { 
      filterRef.setRoi( &chain.rois().at(iroi).roi() ); 
      filterRef.containtracks( m_containTracks ); 
    }
    else filterRef.setRoi( 0 );
    
    test_tracks.clear();
    
    
 
        if ( m_provider->msg().level() <= MSG::VERBOSE )
          m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
 
        bool foundTruth = false;
 
        if ( !m_doOffline && m_mcTruth ) {
 
      if ( this->filterOnRoi() )  filter_truth.setRoi( &chain.rois().at(iroi).roi() );
      else                        filter_truth.setRoi( 0 ); // don't filter on RoI unless needed  
 
          selectorTruth.clear();
 
          if ( m_provider->msg().level() <= MSG::VERBOSE )
            m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
 
          if ( m_provider->evtStore()->template contains<TruthParticleContainer>("INav4MomTruthEvent") ) {
            //ESD
            this->template selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );
            foundTruth = true;
          }
          else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("SpclMC") ) {
            this->template selectTracks<TruthParticleContainer>( &selectorTruth, "SpclMC");
            foundTruth = true;
          }
          else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("") ) {
            this->template selectTracks<TruthParticleContainer>( &selectorTruth, "");
            foundTruth = true;
          }
          else
            if ( m_provider->msg().level() <= MSG::VERBOSE ) {
              m_provider->msg(MSG::VERBOSE) << "Truth not found - none whatsoever!" << endmsg;
        }
    }
 
      
        if ( !m_doOffline && m_mcTruth && !foundTruth ) {
          
      if ( m_provider->msg().level() <= MSG::VERBOSE ) { 
            m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
      }

 
          const DataHandle<McEventCollection> mcevent;

 
          std::string keys[4] = { "GEN_AOD", "TruthEvent", "", "G4Truth" };
 
          std::string key = "";
 
          bool foundcollection = false;
 
          for ( int ik=0 ; ik<4 ; ik++ ) {
         
        if ( m_provider->msg().level() <= MSG::VERBOSE ) {
              m_provider->msg(MSG::VERBOSE) << "Try McEventCollection: " << keys[ik] << endmsg;
            }
 
            if ( !m_provider->evtStore()->template contains<McEventCollection>(keys[ik]) ) {
              if( m_provider->msg().level() <= MSG::VERBOSE )
                m_provider->msg(MSG::VERBOSE) << "No McEventCollection: " << keys[ik] << endmsg;
              continue;
            }
 
            if ( m_provider->msg().level() <= MSG::VERBOSE )
              m_provider->msg(MSG::VERBOSE) << "evtStore()->retrieve( mcevent, " << keys[ik] << " )" << endmsg;
 
            if ( this->template retrieve( mcevent, keys[ik] ).isFailure() ) {
              if ( m_provider->msg().level() <= MSG::VERBOSE )
                m_provider->msg(MSG::VERBOSE) << "Failed to get McEventCollection: " << keys[ik] << endmsg;
            }
            else {
              key = keys[ik];
              if(m_provider->msg().level() <= MSG::VERBOSE)
                m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << endmsg;
              foundcollection = true;
              break;
            }
          }

          if ( !foundcollection ) {
            if(m_provider->msg().level() <= MSG::VERBOSE)
              m_provider->msg(MSG::WARNING) << "No MC Truth Collections of any sort, whatsoever!!!" << endmsg;
 
            //    m_tree->Fill();
            //    return StatusCode::FAILURE;
 
            return;
          }
 
          if ( m_provider->msg().level() <= MSG::VERBOSE ) {
            m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << "\tNevents " << mcevent->size() << endmsg;
          }
 
          McEventCollection::const_iterator evitr = mcevent->begin();
          McEventCollection::const_iterator evend = mcevent->end();
 
          unsigned ie = 0; 
          unsigned ip = 0; 
 
          unsigned ie_ip = 0; 
 
          while ( evitr!=evend ) {
 
            int _ip = 0; 
 
            int pid = HepMC::signal_process_id((*evitr));
 
            //The logic should be clarified here
            if ( pid!=0 ) { 
 
              for  (auto pitr: *(*evitr)) {
 
                selectorTruth.selectTrack( pitr );
 
                ++_ip;
 
              }
 
            }
            ++ie;
            ++evitr;
 
            if ( _ip>0 ) {
              //      m_provider->msg(MSG::VERBOSE) << "Found " << ie << "\tpid " << pid << "\t with " << ip << " TruthParticles (GenParticles)" << endmsg;
              ++ie_ip;
              ip += _ip;
            }
          }
 
          if(m_provider->msg().level() <= MSG::VERBOSE){
            m_provider->msg(MSG::VERBOSE) << "Found " << ip << " TruthParticles (GenParticles) in " << ie_ip << " GenEvents out of " << ie << endmsg;
            m_provider->msg(MSG::VERBOSE) << "selected " << selectorTruth.size() << " TruthParticles (GenParticles)" << endmsg;
          }
 
          if(selectorTruth.size() > 0) foundTruth = true;
 
          if ( !(ip>0) ) {
            if (m_provider->msg().level() <= MSG::VERBOSE) m_provider->msg(MSG::WARNING) << "NO TRUTH PARTICLES - returning" << endmsg;
        return; 
          }
      
        }
    
 
        // m_provider->msg(MSG::VERBOSE) << " Offline tracks " << endmsg;
    
        if ( m_doOffline ) {
      
#         ifdef XAODTRACKING_TRACKPARTICLE_H
          if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>("InDetTrackParticles") ) {
            this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorRef, "InDetTrackParticles" );
        refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( "InDetTrackParticles" );
          }
          else if (m_provider->evtStore()->template contains<Rec::TrackParticleContainer>("TrackParticleCandidate") ) {
            this->template selectTracks<Rec::TrackParticleContainer>( m_selectorRef, "TrackParticleCandidate" );
          }
#         else
          if (m_provider->evtStore()->template contains<Rec::TrackParticleContainer>("TrackParticleCandidate") ) {
            this->template selectTracks<Rec::TrackParticleContainer>( m_selectorRef, "TrackParticleCandidate" );
          }
#         endif
          else if ( m_provider->msg().level() <= MSG::WARNING ) {
            m_provider->msg(MSG::WARNING) << " Offline tracks not found " << endmsg;
      }
 
          ref_tracks = m_selectorRef->tracks();
 
      if ( m_provider->msg().level() <= MSG::VERBOSE ) {
        m_provider->msg(MSG::VERBOSE) << "ref tracks.size() " << m_selectorRef->tracks().size() << endmsg;
            for ( int ii=m_selectorRef->tracks().size() ; ii-- ; ) {
              m_provider->msg(MSG::VERBOSE) << "  ref track " << ii << " " << *m_selectorRef->tracks()[ii] << endmsg;
        }
      }
 
        }
    else { 
      if ( m_mcTruth && foundTruth ){
        ref_tracks=selectorTruth.tracks();
      }
    }     
 
    
 
        test_tracks.clear();
 
        for ( unsigned itrk=0 ; itrk<chain.rois().at(iroi).tracks().size() ; itrk++ ) {
          test_tracks.push_back(&(chain.rois().at(iroi).tracks().at(itrk)));
        }
    
    
    //  std::cout << "sutt track multiplicities: offline " << offline_tracks.size() << "\ttest " << test_tracks.size() << std::endl;
 
        _analysis->setvertices( vertices.size() );  
 
    if ( refbeamspot.size()>0 )  _analysis->setBeamRef(   refbeamspot ); 
    if ( testbeamspot.size()>0 ) _analysis->setBeamTest( testbeamspot ); 

 
    if ( m_runPurity ) {
 
      if ( this->getUseHighestPT() ) HighestPTOnly( test_tracks );
 
      if ( m_pTthreshold>0 ) FilterPT( test_tracks, m_pTthreshold );

      m_NRois++;
      m_NRefTracks  += test_tracks.size();
      m_NTestTracks += ref_tracks.size();
          
      m_associator->match( test_tracks, ref_tracks );
      
      _analysis->execute( test_tracks, ref_tracks, m_associator );
 
    }
    else { 

 
      if ( this->getUseHighestPT() ) HighestPTOnly( ref_tracks );

      
      if ( m_pTthreshold>0 )         FilterPT( ref_tracks, m_pTthreshold );

      m_NRois++;
      m_NRefTracks  += ref_tracks.size();
      m_NTestTracks += test_tracks.size();
      
      m_associator->match( ref_tracks, test_tracks );
     
      //      std::cout << "SUTT: execute : N tracks " << ref_tracks.size() << " " << test_tracks.size() << std::endl; 
    
      _analysis->setroi( &chain.rois().at(iroi).roi() );  
      _analysis->execute( ref_tracks, test_tracks, m_associator );
      
      //      std::cout << "chain " << m_chainNames[ichain]  << " " << "\tvtx name " << vtx_name << std::endl;
 
      if ( vtx_name!="" ) { 
        std::vector<TIDA::Vertex> vr = chain.rois().at(iroi).vertices();
        std::vector<TIDA::Vertex*> vtx_rec;    
        for ( unsigned iv=0 ; iv<vr.size() ; iv++ ) vtx_rec.push_back( &vr[iv] );
 
        std::vector<TIDA::Vertex*> vtx;
        if ( this->getVtxIndex()<0 ) { 
          for ( unsigned iv=0 ; iv<vertices.size() ; iv++ ) vtx.push_back( &vertices[iv] );
        }
        else { 
          if ( vertices.size()>unsigned(this->getVtxIndex()) ) vtx.push_back( &vertices[this->getVtxIndex()] );
        }
 
        _analysis->execute_vtx( vtx, vtx_rec, m_event );
      }
 
    }
 
    if ( _analysis->debug() ) { 
      m_provider->msg(MSG::INFO) << "Missing track for " << m_chainNames[ichain]  
                     << "\trun "             << run_number 
                     << "\tevent "           << event_number 
                     << "\tlb "              << lumi_block << endmsg;     
    }
 
      }
 
    }
    
    if ( m_provider->msg().level() <= MSG::VERBOSE ) {
      m_provider->msg(MSG::VERBOSE) << "\n\nEvent " << *m_event << endmsg;
    }
  }

mcTruth()

bool T_AnalysisConfig< T >::mcTruth ( ) const

inlineinherited

Definition at line 261 of file T_AnalysisConfig.h.

{ return m_mcTruth; }

name()

const std::string & T_AnalysisConfig< T >::name ( ) const

inlineinherited

Definition at line 235 of file T_AnalysisConfig.h.

{return m_analysisInstanceName;}

processElectrons()

unsigned T_AnalysisConfig< T >::processElectrons ( TrigTrackSelector & selectorRef, std::vector< TrackTrigObject > * elevec = 0, const unsigned int selection = 0, bool raw_track = false, double ETOffline = 0, const std::string & containerName = "ElectronAODCollection" )

inlineprotectedinherited

select offline electrons

Definition at line 703 of file T_AnalysisConfig.h.

                    {
 
    m_provider->msg(MSG::DEBUG) << "Fetching offline electrons: " << containerName << endmsg;
 
    selectorRef.clear();
 
#   ifdef XAODTRACKING_TRACKPARTICLE_H
    typedef xAOD::ElectronContainer     Container;
#   else
    typedef ElectronContainer           Container;
#   endif
 
 
    const Container* container = 0;
 
    if( ! m_provider->evtStore()->template contains<Container>(containerName) ) {
      m_provider->msg(MSG::WARNING) << "Error No Electron Container " << containerName << " !" << endmsg;
      return 0;
    }
 
    StatusCode sc = retrieve( container, containerName);
    if( sc.isFailure() || !container ) {
      m_provider->msg(MSG::WARNING) << "Error retrieving container: " << containerName << " !" << endmsg;
      return 0;
    }
 
    m_provider->msg(MSG::DEBUG) << "Event with " <<  container->size() << " Electron object(s) " << endmsg;
 
    Container::const_iterator elec     = container->begin();
    Container::const_iterator elec_end = container->end();
 
    for( ; elec!=elec_end ; ++elec ){
      //m_provider->msg(MSG::DEBUG) << " Electron "       << (*elec)
      //           << ",  eta "          << (*elec)->eta()
      //           << ",  phi "          << (*elec)->phi()
      //           << ",  ET "           << (*elec)->pt()
      //           << ",  author "       << (*elec)->author()
      //           << ",  trackParticle " << (*elec)->trackParticle()
      //           << ",  conversion "    << (*elec)->conversion()
      //           << ",  mediumPP "      << ((*elec)->isem(egammaPID::ElectronMediumPP)==0)
      //           << endmsg;
 
      bool good_electron = false;
#     ifdef XAODTRACKING_TRACKPARTICLE_H
      good_electron = TIDA::isGoodOffline( *(*elec), selection, ETOffline );
#     else
      good_electron = TIDA::isGoodOffline( *(*elec));
#     endif
 
      if (good_electron) {
    const xAOD::Electron_v1& eleduff = *(*elec);
    long unsigned   eleid  = (unsigned long)(&eleduff) ;
    TrackTrigObject eleobj = TrackTrigObject( (*elec)->eta(),
                          (*elec)->phi(),
                          (*elec)->pt(),
                          0,
                          (*elec)->type(),
                          eleid );
 
    bool trk_added ;
    if ( raw_track ) trk_added = selectorRef.selectTrack( xAOD::EgammaHelpers::getOriginalTrackParticle( *elec ) );
    else             trk_added = selectorRef.selectTrack( (*elec)->trackParticle() );
 
    if (trk_added) eleobj.addChild( selectorRef.tracks().back()->id() );
    if (elevec)    elevec->push_back( eleobj );
      }
    }
 
    return selectorRef.tracks().size();
  }

processMuons()

unsigned T_AnalysisConfig< T >::processMuons ( TrigTrackSelector & selectorRef, const unsigned int selection = 0, double ETOffline = 0, const std::string & containerName = "StacoMuonCollection" )

inlineprotectedinherited

select offlinqe muons

Definition at line 789 of file T_AnalysisConfig.h.

                    {
 
#   ifdef XAODTRACKING_TRACKPARTICLE_H
    typedef xAOD::MuonContainer     Container;
#   else
    typedef Analysis::MuonContainer Container;
#   endif
 
    m_provider->msg(MSG::DEBUG) << " Offline muons (" << containerName << ")" << endmsg;
 
    selectorRef.clear();
 
    const Container*     container = 0;
 
    if( ! m_provider->evtStore()->template contains<Container>(containerName) ) {
      m_provider->msg(MSG::WARNING) << "Error No MuonCollection" << containerName << " !" << endmsg;
      return 0;
    }
 
    StatusCode sc = retrieve( container, containerName );
    if( sc.isFailure() || !container ) {
      m_provider->msg(MSG::WARNING) << "Error retrieving " << containerName << " !" << endmsg;
      return 0;
    }
 
    auto muon     = container->begin();
    auto muon_end = container->end();
 
    //    std::cout << "SUTT Offline muons " << container->size() << "\t threshold " << ETOffline << std::endl;
 
    for( ; muon!=muon_end ; ++muon ){
#     ifdef XAODTRACKING_TRACKPARTICLE_H
      if ( TIDA::isGoodOffline(*(*muon), selection, ETOffline ) ) selectorRef.selectTrack(*((*muon)->inDetTrackParticleLink()));
#     else
      if ( TIDA::isGoodOffline(*(*muon)) ) selectorRef.selectTrack((*muon)->inDetTrackParticle());
#     endif
    }
 
 
    //    std::cout <<              "SUTT found  " << selectorRef.tracks().size() << " muons for " << containerName << std::endl;
    m_provider->msg(MSG::DEBUG) << "found  " << selectorRef.tracks().size() << " muons for " << containerName << endmsg;
 
    return selectorRef.tracks().size();
}

processTaus()

unsigned T_AnalysisConfig< T >::processTaus ( TrigTrackSelector & selectorRef, std::vector< TrackTrigObject > * tauvec = 0, const unsigned selection = 0, int requireNtracks = 0, double EtCutOffline = 0, const std::string & containerName = "TauRecContainer" )

inlineprotectedinherited

select offline taus

Definition at line 846 of file T_AnalysisConfig.h.

                 {
 
# ifdef XAODTRACKING_TRACKPARTICLE_H
  typedef xAOD::TauJetContainer     Container;
# else
  typedef Analysis::TauJetContainer Container;
# endif
 
  selectorRef.clear();
 
  const Container* container = 0;
 
  selectorRef.clear();
 
  m_provider->msg(MSG::DEBUG) << " Offline taus " << containerName << endmsg;
 
  if ( !m_provider->evtStore()->template contains<Container>(containerName)) {
    m_provider->msg(MSG::WARNING) << " Offline taus not found" << endmsg;
    return 0;
  }
 
  StatusCode sc = retrieve( container, containerName);
  if (sc != StatusCode::SUCCESS) {
    m_provider->msg(MSG::WARNING) << " Offline tau retrieval not successful" << endmsg;
    return 0;
  }
 
  Container::const_iterator tau     = container->begin();
  Container::const_iterator tau_end = container->end();
 
 
  for ( ; tau!=tau_end ; ++tau ) {
 
#   ifdef XAODTRACKING_TRACKPARTICLE_H
    //      unsigned N = (*tau)->nTracks();
 
#   ifndef XAODTAU_VERSIONS_TAUJET_V3_H
    int N = (*tau)->nTracks();
    // std::cout << "SUTT no tau detail " << N << "\t3prong: " << doThreeProng << std::endl;
#   else
    int N=0;
    (*tau)->detail( xAOD::TauJetParameters::nChargedTracks, N );
    // std::cout << "SUTT tau detail: N " << N << "\t3prong: " << doThreeProng << std::endl;
#   endif
 
#   else
    unsigned N = (*tau)->numTrack();
#   endif
 
 
    bool good_tau = false;
#   ifdef XAODTRACKING_TRACKPARTICLE_H
    good_tau = TIDA::isGoodOffline( *(*tau), selection, requireNtracks, EtCutOffline );
#   else
    good_tau = TIDA::isGoodOffline( *(*tau), requireNtracks, EtCutOffline );
#   endif
 
    //   std::cout << "SUTT tau ntracks: " << N << "\tgoodtau: " << good_tau << "\tpt: " << (*tau)->p4().Et() << "\t3prong: " << doThreeProng << std::endl;
 
    if (good_tau){
      const xAOD::TauJet_v3& duff = *(*tau);
      long unsigned tauid = (unsigned long)(&duff) ;
      TrackTrigObject tauobj = TrackTrigObject( (*tau)->eta(),
                        (*tau)->phi(),
                        (*tau)->pt(),
                        0,
                        (*tau)->type(),
                        tauid );
 
      bool trk_added = false;
 
      for ( unsigned i=N ; i-- ; )  {
#       ifdef XAODTAU_TAUTRACK_H
    
        std::vector< ElementLink<xAOD::TrackParticleContainer> > alink = (*tau)->track(i)->trackLinks();
    
    trk_added = false;
    
    for ( size_t ilink=0 ; ilink<alink.size() ; ilink++ ) {
      if ( alink[ilink].isValid() ) trk_added = selectorRef.selectTrack((*alink[ilink]));
    }
    //        trk_added = selectorRef.selectTrack((*tau)->track(i)->track());
#       else
    trk_added = selectorRef.selectTrack((*tau)->track(i));
#       endif
    if ( trk_added ) tauobj.addChild( selectorRef.tracks().back()->id() );
      }
      if ( tauvec ) tauvec->push_back( tauobj );
    }
  }
 
  return selectorRef.tracks().size();
 
}

referenceChains()

const std::string T_AnalysisConfig< T >::referenceChains ( ) const

inlineinherited

Definition at line 244 of file T_AnalysisConfig.h.

                                          {
      std::string name;
      for(unsigned int i=0; i<m_chainNames[1].size(); i++)
    name += (m_chainNames[1][i]+"::"+m_types[1][i]+"::"+m_keys[1][i]+" ");
      return name;
  }

releaseData()

const std::string & T_AnalysisConfig< T >::releaseData ( ) const

inlineinherited

Definition at line 273 of file T_AnalysisConfig.h.

{ return m_releaseData; }

requireDecision()

bool T_AnalysisConfig< T >::requireDecision ( ) const

inlineinherited

Definition at line 288 of file T_AnalysisConfig.h.

{ return m_requireDecision; }

retrieve()

StatusCode T_AnalysisConfig< T >::retrieve ( Collection const *& collection, const std::string & key = "" )

inlineprotectedinherited

old implementation - leave in place until after the full validation ... return m_provider->evtStore()->retrieve( container, containerName);

commented code intentionally left for development purposes ... std::cout << "\t\t\t T_AnalysisConfig::selectTracks() - > TrackSelector" << std::endl;

Definition at line 573 of file T_AnalysisConfig.h.

                                                                                {
    if ( m_provider->evtStore()->template contains<Collection>( key ) ) {
      SG::ReadHandle<Collection> handle(key);
      if ( handle.isValid() ) {
    collection = handle.cptr();
    return StatusCode::SUCCESS;
      }
    }
    return StatusCode::FAILURE;
  }

select()

bool T_AnalysisConfig< T >::select ( std::vector< TIDA::Vertex > & vertices, xAOD::VertexContainer::const_iterator vtx_start, xAOD::VertexContainer::const_iterator vtx_end )

inlineprotectedinherited

variances

quality

Definition at line 342 of file T_AnalysisConfig.h.

                                                       { 
    
    xAOD::VertexContainer::const_iterator vtxitr = vtx_start;
 
    for (  ; vtxitr!=vtx_end  ;  ++vtxitr ) {
      if ( (*vtxitr)->vertexType()!=0 ) {
    m_provider->msg(MSG::VERBOSE) << "\tvertex " << (*vtxitr)->z() << endmsg;
 
    vertices.push_back( TIDA::Vertex( (*vtxitr)->x(),
                      (*vtxitr)->y(),
                      (*vtxitr)->z(),
                      (*vtxitr)->covariancePosition()(Trk::x,Trk::x),
                      (*vtxitr)->covariancePosition()(Trk::y,Trk::y),
                      (*vtxitr)->covariancePosition()(Trk::z,Trk::z),
                      (*vtxitr)->nTrackParticles(),
                      (*vtxitr)->chiSquared(),
                      (*vtxitr)->numberDoF() ) );
    
      }
    }
    
    return true;
  }

selectionChains()

const std::string T_AnalysisConfig< T >::selectionChains ( ) const

inlineinherited

Definition at line 251 of file T_AnalysisConfig.h.

                                          {
      std::string name;
      for(unsigned int i=0; i<m_chainNames[2].size(); i++)
    name += (m_chainNames[2][i]+"::"+m_types[2][i]+"::"+m_keys[2][i]+" ");
      return name;
  }

selectTracks()

bool T_AnalysisConfig< T >::selectTracks ( TrigTrackSelector * selector, const ElementLink< TrigRoiDescriptorCollection > & roi_link, const std::string & key = "" )

inlineprotectedinherited

will need this printout for debugging the feature access, so leave this commented until it has been properly debugged, then it can be removed

will not use the te name here, but keep it on just the same for the time being, for subsequent development

Definition at line 441 of file T_AnalysisConfig.h.

                                        {
 

    //    std::cout << "try " << key << "\t" << m_provider->evtStore()->template transientContains<Collection>(key) << std::endl;

    std::string key_collection = key;
    std::string key_tename     = "";
    size_t pos = key_collection.find("/");
    if ( pos!=std::string::npos ) {
      key_collection = key.substr( pos+1, key.size()-pos );
      key_tename     = key.substr( 0, pos );
    }
 
    std::pair< typename Collection::const_iterator,
           typename Collection::const_iterator > itrpair;
 
    SG::ReadHandle<Collection> handle(key);
 
    CLID checkCLID;
    const std::string* keyStr = m_provider->evtStore()->keyToString(roi_link.key(), checkCLID);
    m_provider->msg(MSG::DEBUG) << "Requesting range over (" << key << ") associated to ROI from " << (keyStr == nullptr ? "UNKNOWN" : *keyStr) << endmsg;
 
    itrpair = (*m_tdt)->associateToEventView( handle, roi_link );
 
    if ( itrpair.first != itrpair.second ) {
      selector->selectTracks( itrpair.first, itrpair.second );
      return true;
    }
    else {
      m_provider->msg(MSG::DEBUG) << "TDT TrackFeature collection (" << key << ") is empty " << endmsg;
      return false;
    }
  }

selectTracksNotEmpty()

bool T_AnalysisConfig< T >::selectTracksNotEmpty ( TrigTrackSelector * selector, const std::string & key )

inlineprotectedinherited

Definition at line 608 of file T_AnalysisConfig.h.

                                                                                 {
    const Collection* collection = nullptr;
    if ( key.empty() ) return false;
    if ( !m_provider->evtStore()->template contains<Collection>( key ) ) return false;
 
    StatusCode sc = retrieve( collection, key );
 
    if ( !( sc.isSuccess() && collection ) ) return false;
 
    m_provider->msg(MSG::DEBUG) << "SG Collection->size() " << collection->size() << " (" << key << ")" << endmsg;
 
    // added to fix muon samples bug
    if ( collection->size() == 0 ) {
      m_provider->msg(MSG::WARNING) << "no particles in collection" << endmsg;
      return false;
    }                   
                                                  
      selector->selectTracks( collection );
      return true;   
    }

setBeamX()

void T_AnalysisConfig< T >::setBeamX ( double d )

inlineinherited

Definition at line 263 of file T_AnalysisConfig.h.

{ m_beamX=d; }

setBeamY()

void T_AnalysisConfig< T >::setBeamY ( double d )

inlineinherited

Definition at line 264 of file T_AnalysisConfig.h.

{ m_beamY=d; }

setBeamZ()

void T_AnalysisConfig< T >::setBeamZ ( double d )

inlineinherited

Definition at line 265 of file T_AnalysisConfig.h.

{ m_beamZ=d; }

setFilterOnRoi()

bool T_AnalysisConfig< T >::setFilterOnRoi ( bool b )

inlineinherited

Definition at line 285 of file T_AnalysisConfig.h.

{ return m_filterOnRoi=b; }

setGenericFlag()

void T_AnalysisConfig< T >::setGenericFlag ( bool b )

inlineinherited

Definition at line 271 of file T_AnalysisConfig.h.

{ m_genericFlag=b; }

setMCTruth()

void T_AnalysisConfig< T >::setMCTruth ( bool b = true )

inlineinherited

Definition at line 260 of file T_AnalysisConfig.h.

{ m_mcTruth=b; }

setRequireDecision()

void T_AnalysisConfig< T >::setRequireDecision ( bool b )

inlineinherited

Definition at line 287 of file T_AnalysisConfig.h.

{ m_requireDecision=b; }

setRunPurity()

template<typename T>

void T_AnalysisConfig_Tier0< T >::setRunPurity ( bool b )

inline

Definition at line 153 of file T_AnalysisConfig_Tier0.h.

{ m_runPurity=b; }

setShifter()

template<typename T>

void T_AnalysisConfig_Tier0< T >::setShifter ( bool b )

inline

Definition at line 155 of file T_AnalysisConfig_Tier0.h.

{ m_shifter=b; }

setUseHighestPT()

void T_AnalysisConfig< T >::setUseHighestPT ( bool b )

inlineinherited

Definition at line 278 of file T_AnalysisConfig.h.

{ m_useHighestPT=b; }

setVtxIndex()

void T_AnalysisConfig< T >::setVtxIndex ( int i )

inlineinherited

Definition at line 281 of file T_AnalysisConfig.h.

{ m_vtxIndex=i; }

testChains()

const std::string T_AnalysisConfig< T >::testChains ( ) const

inlineinherited

Definition at line 237 of file T_AnalysisConfig.h.

                                     {
      std::string name;
      for(unsigned int i=0; i<m_chainNames[0].size(); i++)
    name += (m_chainNames[0][i]+"::"+m_types[0][i]+"::"+m_keys[0][i]+" ");
      return name;
  }

useBeamCondSvc()

template<typename T>

void T_AnalysisConfig_Tier0< T >::useBeamCondSvc ( bool b )

inline

Definition at line 157 of file T_AnalysisConfig_Tier0.h.

{ m_useBeamCondSvc = b; }

Member Data Documentation

_analysis

template<typename T>

Analysis_Tier0* T_AnalysisConfig_Tier0< T >::_analysis

Definition at line 163 of file T_AnalysisConfig_Tier0.h.

m_analyses

template<typename T>

std::vector<Analysis_Tier0*> T_AnalysisConfig_Tier0< T >::m_analyses

protected

Definition at line 1225 of file T_AnalysisConfig_Tier0.h.

m_analysis

TrackAnalysis* T_AnalysisConfig< T >::m_analysis

protectedinherited

Definition at line 986 of file T_AnalysisConfig.h.

m_analysisInstanceName

std::string T_AnalysisConfig< T >::m_analysisInstanceName

protectedinherited

Definition at line 965 of file T_AnalysisConfig.h.

m_associator

TrackAssociator* T_AnalysisConfig< T >::m_associator

protectedinherited

Definition at line 985 of file T_AnalysisConfig.h.

m_beamX

double T_AnalysisConfig< T >::m_beamX

protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

m_beamY

double T_AnalysisConfig< T >::m_beamY

protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

m_beamZ

double T_AnalysisConfig< T >::m_beamZ

protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

m_chainNames

template<typename T>

std::vector<ChainString> T_AnalysisConfig_Tier0< T >::m_chainNames

protected

Definition at line 1224 of file T_AnalysisConfig_Tier0.h.

m_containTracks

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_containTracks

protected

Definition at line 1252 of file T_AnalysisConfig_Tier0.h.

m_doBjets

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_doBjets

protected

Definition at line 1232 of file T_AnalysisConfig_Tier0.h.

m_doElectrons

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_doElectrons

protected

Definition at line 1230 of file T_AnalysisConfig_Tier0.h.

m_doMuons

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_doMuons

protected

Definition at line 1229 of file T_AnalysisConfig_Tier0.h.

m_doOffline

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_doOffline

protected

Definition at line 1228 of file T_AnalysisConfig_Tier0.h.

m_doTaus

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_doTaus

protected

Definition at line 1231 of file T_AnalysisConfig_Tier0.h.

m_doTauThreeProng

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_doTauThreeProng

protected

Definition at line 1234 of file T_AnalysisConfig_Tier0.h.

m_event

template<typename T>

TIDA::Event* T_AnalysisConfig_Tier0< T >::m_event

protected

Definition at line 1222 of file T_AnalysisConfig_Tier0.h.

m_filterOnRoi

bool T_AnalysisConfig< T >::m_filterOnRoi

protectedinherited

Definition at line 1001 of file T_AnalysisConfig.h.

m_filters

std::vector< std::vector<TrackFilter*> > T_AnalysisConfig< T >::m_filters

protectedinherited

Definition at line 979 of file T_AnalysisConfig.h.

m_first

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_first

protected

Definition at line 1250 of file T_AnalysisConfig_Tier0.h.

m_genericFlag

int T_AnalysisConfig< T >::m_genericFlag

protectedinherited

Definition at line 992 of file T_AnalysisConfig.h.

m_hasTruthMap

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_hasTruthMap

protected

Definition at line 1233 of file T_AnalysisConfig_Tier0.h.

m_keepAllEvents

bool T_AnalysisConfig< T >::m_keepAllEvents

protectedinherited

Definition at line 995 of file T_AnalysisConfig.h.

m_keys

std::vector< std::vector<std::string> > T_AnalysisConfig< T >::m_keys

protectedinherited

Definition at line 970 of file T_AnalysisConfig.h.

m_mcTruth

bool T_AnalysisConfig< T >::m_mcTruth

protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

m_NRefTracks

template<typename T>

int T_AnalysisConfig_Tier0< T >::m_NRefTracks

protected

Definition at line 1241 of file T_AnalysisConfig_Tier0.h.

m_NRois

template<typename T>

int T_AnalysisConfig_Tier0< T >::m_NRois

protected

output stats

Definition at line 1240 of file T_AnalysisConfig_Tier0.h.

m_NTestTracks

template<typename T>

int T_AnalysisConfig_Tier0< T >::m_NTestTracks

protected

Definition at line 1242 of file T_AnalysisConfig_Tier0.h.

m_outputFileName

template<typename T>

std::string T_AnalysisConfig_Tier0< T >::m_outputFileName

protected

Definition at line 1237 of file T_AnalysisConfig_Tier0.h.

m_provider

T* T_AnalysisConfig< T >::m_provider

protectedinherited

Definition at line 957 of file T_AnalysisConfig.h.

m_pTthreshold

template<typename T>

double T_AnalysisConfig_Tier0< T >::m_pTthreshold

protected

Definition at line 1248 of file T_AnalysisConfig_Tier0.h.

m_refChainKey

std::string T_AnalysisConfig< T >::m_refChainKey

protectedinherited

Definition at line 973 of file T_AnalysisConfig.h.

m_refChainName

std::string T_AnalysisConfig< T >::m_refChainName

protectedinherited

Definition at line 972 of file T_AnalysisConfig.h.

m_releaseData

std::string T_AnalysisConfig< T >::m_releaseData

protectedinherited

Definition at line 993 of file T_AnalysisConfig.h.

m_requireDecision

bool T_AnalysisConfig< T >::m_requireDecision

protectedinherited

Definition at line 1003 of file T_AnalysisConfig.h.

m_runPurity

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_runPurity

protected

Definition at line 1244 of file T_AnalysisConfig_Tier0.h.

m_selectorRef

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorRef

protectedinherited

Definition at line 981 of file T_AnalysisConfig.h.

m_selectorSel

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorSel

protectedinherited

Definition at line 983 of file T_AnalysisConfig.h.

m_selectorTest

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorTest

protectedinherited

Definition at line 982 of file T_AnalysisConfig.h.

m_shifter

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_shifter

protected

Definition at line 1246 of file T_AnalysisConfig_Tier0.h.

m_tauEtCutOffline

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_tauEtCutOffline

protected

Definition at line 1235 of file T_AnalysisConfig_Tier0.h.

m_tdt

ToolHandle<Trig::TrigDecisionTool>* T_AnalysisConfig< T >::m_tdt

protectedinherited

Definition at line 959 of file T_AnalysisConfig.h.

m_testChainKey

std::string T_AnalysisConfig< T >::m_testChainKey

protectedinherited

Definition at line 976 of file T_AnalysisConfig.h.

m_testChainName

std::string T_AnalysisConfig< T >::m_testChainName

protectedinherited

Definition at line 975 of file T_AnalysisConfig.h.

m_testType

template<typename T>

std::string T_AnalysisConfig_Tier0< T >::m_testType

protected

Definition at line 1226 of file T_AnalysisConfig_Tier0.h.

m_types

std::vector< std::vector<std::string> > T_AnalysisConfig< T >::m_types

protectedinherited

Definition at line 969 of file T_AnalysisConfig.h.

m_useBeamCondSvc

template<typename T>

bool T_AnalysisConfig_Tier0< T >::m_useBeamCondSvc

protected

Definition at line 1220 of file T_AnalysisConfig_Tier0.h.

m_useHighestPT

bool T_AnalysisConfig< T >::m_useHighestPT

protectedinherited

Definition at line 997 of file T_AnalysisConfig.h.

m_vtxIndex

int T_AnalysisConfig< T >::m_vtxIndex

protectedinherited

Definition at line 999 of file T_AnalysisConfig.h.

---

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

• T_AnalysisConfig_Tier0.h