AnalysisConfigMT_Ntuple Class Reference

#include <AnalysisConfigMT_Ntuple.h>

Inheritance diagram for AnalysisConfigMT_Ntuple:

Collaboration diagram for AnalysisConfigMT_Ntuple:

Public Member Functions
	AnalysisConfigMT_Ntuple (const std::vector< std::string > &chainNames, const std::string &outputFileName="TrkNtuple.root", double tauEtCutOffline=0.0, int TruthPdgId=0, bool keepAllEvents_=false, int parentTruthId=0)
virtual	~AnalysisConfigMT_Ntuple ()
void	set_fiducial_radius (double d)
void	set_ptmin (double d)
size_t	get_jets (Trig::FeatureContainer::combination_const_iterator citr, std::vector< TrackTrigObject > &objects, const std::string &key="")
	retrieve the jets from the Roi
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 (AthReentrantAlgorithm *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

Protected Member Functions
virtual void	loop ()
virtual void	book ()
	setup the analysis the analysis, retrieve the tools etc
virtual void	finalize ()
	finalise the analysis - take ratios for efficiencies etc
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
TFile *	m_File
TTree *	m_Tree
TDirectory *	m_Dir
std::vector< ChainString >	m_chainNames
bool	m_doOffline
bool	m_doVertices
bool	m_doMuons
bool	m_doMuonsSP
std::vector< std::string >	m_muonType
std::vector< bool >	m_muonIsLRT
std::vector< std::string >	m_electronType
std::vector< std::string >	m_rawElectrons
std::vector< bool >	m_electronIsLRT
std::vector< std::string >	m_tauType
std::vector< std::string >	m_tauProngs
std::vector< std::string >	m_vertexType
bool	m_doBjets
bool	m_hasTruthMap
bool	m_tauEtCutOffline
std::string	m_outputFileName
int	m_TruthPdgId
bool	m_finalised
bool	m_printInfo
int	m_parentTruthPdgId
AthReentrantAlgorithm *	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

Private Member Functions
std::set< std::string >	get_configured_chains ()

Private Attributes
double	m_fiducial_radius
double	m_ptmin

Detailed Description

Definition at line 24 of file AnalysisConfigMT_Ntuple.h.

Constructor & Destructor Documentation

AnalysisConfigMT_Ntuple()

AnalysisConfigMT_Ntuple::AnalysisConfigMT_Ntuple ( const std::vector< std::string > & chainNames, const std::string & outputFileName = "TrkNtuple.root", double tauEtCutOffline = 0.0, int TruthPdgId = 0, bool keepAllEvents_ = false, int parentTruthId = 0 )

inline

Definition at line 35 of file AnalysisConfigMT_Ntuple.h.

                                                                                                                  : 
    AnalysisConfig_Ntuple( chainNames, outputFileName, tauEtCutOffline, TruthPdgId, keepAllEvents_ , parentTruthId),
    m_fiducial_radius(47),
    m_ptmin(1000)
  { }  

~AnalysisConfigMT_Ntuple()

virtual AnalysisConfigMT_Ntuple::~AnalysisConfigMT_Ntuple ( )

inlinevirtual

Definition at line 42 of file AnalysisConfigMT_Ntuple.h.

{ }

Member Function Documentation

addReferenceChain()

void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::addReferenceFilter ( TrackFilter * filter )

inlineinherited

Definition at line 212 of file T_AnalysisConfig.h.

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

addSelectionChain()

void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::addSelectionFilter ( TrackFilter * filter )

inlineinherited

Definition at line 213 of file T_AnalysisConfig.h.

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

addTestChain()

void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::addTestFilter ( TrackFilter * filter )

inlineinherited

Definition at line 211 of file T_AnalysisConfig.h.

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

analysis()

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

inlineinherited

Definition at line 258 of file T_AnalysisConfig.h.

{return m_analysis;}

beamX()

double T_AnalysisConfig< AthReentrantAlgorithm >::beamX ( ) const

inlineinherited

Definition at line 266 of file T_AnalysisConfig.h.

{ return m_beamX; }

beamY()

double T_AnalysisConfig< AthReentrantAlgorithm >::beamY ( ) const

inlineinherited

Definition at line 267 of file T_AnalysisConfig.h.

{ return m_beamY; }

beamZ()

double T_AnalysisConfig< AthReentrantAlgorithm >::beamZ ( ) const

inlineinherited

Definition at line 268 of file T_AnalysisConfig.h.

{ return m_beamZ; }

book()

void AnalysisConfig_Ntuple::book ( )

protectedvirtualinherited

setup the analysis the analysis, retrieve the tools etc

flag should be called m_fileIsNotOpen really, so is if m_fileIsNotOpen open file, if !m_fileIsNotOpen, then close file etc

save the current directory so we can return there after

create a brand new ntple

update the ntple from the file

go back to original directory

Reimplemented from T_AnalysisConfig< AthReentrantAlgorithm >.

Definition at line 188 of file AnalysisConfig_Ntuple.cxx.

                                 { 
 
    m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::book() name " << name() << endmsg;   

    if ( !m_finalised ) { 
        m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::book() not booking " << name() << endmsg;   
        return;
    }
 
 
 
    // get the TriggerDecisionTool
 
    if( m_tdt->retrieve().isFailure() ) {
        m_provider->msg(MSG::FATAL) << " Unable to retrieve the TrigDecisionTool: Please check job options file" << endmsg;
        //    return StatusCode::FAILURE;
        return;
    }
 
    m_provider->msg(MSG::INFO) << "␛[91;1m" << " Successfully retrieved the TrigDecisionTool" << "␛[m" << endmsg;
    m_provider->msg(MSG::INFO) << "␛[91;1m" << " booking ntuple" << "␛[m" << endmsg;
    m_provider->msg(MSG::INFO) << "␛[91;1m" << " trying to create new ntple file" << "␛[m" << endmsg;

    TDirectory* dir = gDirectory;
 
    static std::atomic<bool> first_open = true;
 
    std::string outputFileName = m_outputFileName;
 
    if ( genericFlag() ) { 
        static std::atomic<int> file_index = 0;
        std::string::size_type pos = outputFileName.find(".root");
        if ( pos != std::string::npos ) outputFileName.erase(pos, outputFileName.size());
        char file_label[64];
        sprintf( file_label, "-%04d.root", file_index++ );
        outputFileName += file_label;
    } 
 
    m_provider->msg(MSG::INFO) << "book() Writing to file " << outputFileName << endmsg;
 
    if ( first_open || genericFlag() ) {
        m_File = new TFile( outputFileName.c_str(), "recreate");
 
        TTree*  dataTree = new TTree("dataTree", "dataTree");
        TString releaseData(m_releaseData.c_str());
        dataTree->Branch( "ReleaseMetaData", "TString", &releaseData);
        dataTree->Fill();
        dataTree->Write("", TObject::kOverwrite);
        delete dataTree;
 
 
        m_Tree = new TTree("tree", "tree");
        m_Tree->Branch( "TIDA::Event", "TIDA::Event", m_event, 6400, 1 );
 
        
    }
    else { 
        m_File = new TFile( outputFileName.c_str(), "update");
        m_Tree = (TTree *)m_File->Get("tree");
        m_Tree->SetBranchAddress( "TIDA::Event", &m_event );
    }
 
    m_Dir = gDirectory;
 
    first_open = false;
 
 
    m_provider->msg(MSG::DEBUG) << "change directory " << name() << "  " << dir->GetName() << endmsg;
 
    //  std::cout << "change directory " << name() << "  " << dir->GetName() << std::endl;
    dir->cd();
 
    //  gDirectory->pwd();
 
    m_finalised = false; // flag we have an open file that is not yet finalised
 
    m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::book() exiting" << endmsg;
 
}

execute()

virtual void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::filterOnRoi ( ) const

inlineinherited

Definition at line 284 of file T_AnalysisConfig.h.

{ return m_filterOnRoi; }

finalize()

void AnalysisConfig_Ntuple::finalize ( )

protectedvirtualinherited

finalise the analysis - take ratios for efficiencies etc

NB: flag this round the other way for multiple files

flag that we have finalised and closed this file

Reimplemented from T_AnalysisConfig< AthReentrantAlgorithm >.

Definition at line 279 of file AnalysisConfig_Ntuple.cxx.

                                     { 
 
    //  gDirectory->pwd();
 

    if ( m_finalised ) { 
        m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::finalise() flagged, not finalising  " << m_provider->name() << "\t" << m_Tree->GetEntries() << " entries" << endmsg;
        return;
    }
 
    m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::finalise() writing " << m_provider->name() << "\t" << m_Tree->GetEntries() << " entries" << endmsg;
 
    TDirectory* directory = gDirectory; 
 
    //  std::cout << "change directory " << name() << "  " << m_Dir->GetName() << std::endl;
 
    m_provider->msg(MSG::DEBUG) << "change directory " << name() << "  " << m_Dir->GetName() << endmsg;
 
 
    m_Dir->cd();
 
    //  gDirectory->pwd();
 
    m_Tree->Write("", TObject::kOverwrite);
 
    //  m_File->Write();
    if ( m_File ) m_File->Close();
 
 
    m_finalised = true; 
 
    // m_Tree "belongs" to the m_File so was (possibly) deleted on the m_File->Close();
    // so don't delete it ! 
    // delete m_Tree;
    delete m_File;
 
    m_Tree = 0;
    m_File = 0;
 
    //  f.Write();
    //  f.Close();
 
    //  std::cout << "change directory " << name() << "  " << directory->GetName() << std::endl;
 
    directory->cd();
 
    //  gDirectory->pwd();
 
}

genericFlag()

bool T_AnalysisConfig< AthReentrantAlgorithm >::genericFlag ( ) const

inlineinherited

Definition at line 270 of file T_AnalysisConfig.h.

{ return m_genericFlag; }

get_configured_chains()

std::set< std::string > AnalysisConfigMT_Ntuple::get_configured_chains ( )

private

handle wildcard chain selection - but only the first time

get chain

get matching chains

replace wildcard with actual matching chains ...

if this has a cosmic chain, set the fiducial radius to be very large to allow the production vertex of the cosmic to be included

Definition at line 43 of file AnalysisConfigMT_Ntuple.cxx.

                                                                 {
  std::set<std::string> chains;
  const std::vector<std::string> configuredChains = (*m_tdt)->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
 
  if (m_provider->msg().level() <= MSG::VERBOSE) {
    m_provider->msg(MSG::VERBOSE) << "␛[91;1m" << configuredChains.size() << " Configured Chains" << "␛[m" << endmsg;
  }
 
  for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
    if (m_provider->msg().level() <= MSG::VERBOSE) {
      m_provider->msg(MSG::VERBOSE) << "␛[91;1m" << "Chain " << configuredChains[i] << "   (ACN)␛[m" << endmsg;
    }
    chains.insert( configuredChains[i] );
  }
 
  std::vector<ChainString> chainNames;
  std::vector<ChainString>::iterator chainitr = m_chainNames.begin();

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

    ChainString& chainName = (*chainitr);

 
    std::vector<std::string> selectChains;
    selectChains.clear();
    if ( chainitr->head()=="" ) selectChains.push_back("");
    else                        selectChains = (*m_tdt)->getListOfTriggers( chainName.head() );
 
    for ( unsigned iselected=0 ; iselected<selectChains.size() ; iselected++ ) {
 
      selectChains[iselected] = chainName.subs( selectChains[iselected] );

      chainNames.push_back( ChainString(selectChains[iselected]) );
 
      m_provider->msg(MSG::INFO) << "␛[91;1m" << "Matching chain " << selectChains[iselected] << "␛[m" << endmsg;

      if ( selectChains[iselected].find("cosmic")!=std::string::npos ) m_fiducial_radius = 1e10;
 
    }
 
    ++chainitr;
  }
 
  m_chainNames = chainNames;
  return chains;
}

get_jets()

size_t AnalysisConfig_Ntuple::get_jets ( Trig::FeatureContainer::combination_const_iterator citr, std::vector< TrackTrigObject > & objects, const std::string & key = "" )

inherited

retrieve the jets from the Roi

Definition at line 134 of file AnalysisConfig_Ntuple.cxx.

                                                                                  {
 
  objects.clear();
 
  const std::vector< Trig::Feature<xAOD::JetContainer> >  jetfeatures = citr->get<xAOD::JetContainer>( key, TrigDefs::alsoDeactivateTEs );
  
  if ( jetfeatures.empty() ) return 0; 
 
  for ( size_t ifeature=0 ; ifeature<jetfeatures.size() ; ifeature++ ) { 
    Trig::Feature<xAOD::JetContainer> jetfeature = jetfeatures.at(ifeature);
 
    if ( jetfeature.empty() ) continue;
 
    const xAOD::JetContainer* jets = jetfeature.cptr();
    
    if ( jets == 0 ) continue;
 
    xAOD::JetContainer::const_iterator jitr = jets->begin();
 
    for ( int j=0 ; jitr!=jets->end() ; ++jitr, j++ ) { 
      
      const xAOD::Jet* ajet = (*jitr);
 
      long unsigned jetid  = (unsigned long)ajet;
 
      TrackTrigObject jet = TrackTrigObject( ajet->eta(), ajet->phi(), ajet->pt(), 0, ajet->type(), jetid );
 
      objects.push_back( jet );
 
    } 
  }
  
  return objects.size();
 
}

getBeamspot()

std::vector< double > T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::getUseHighestPT ( ) const

inlineinherited

Definition at line 279 of file T_AnalysisConfig.h.

{ return m_useHighestPT; }

getVtxIndex()

int T_AnalysisConfig< AthReentrantAlgorithm >::getVtxIndex ( ) const

inlineinherited

Definition at line 282 of file T_AnalysisConfig.h.

{ return m_vtxIndex; }

initialize()

virtual void T_AnalysisConfig< AthReentrantAlgorithm >::initialize ( AthReentrantAlgorithm * 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< AthReentrantAlgorithm >::keepAllEvents ( bool b )

inlineinherited

Definition at line 276 of file T_AnalysisConfig.h.

{ m_keepAllEvents = b; }

loop()

void AnalysisConfigMT_Ntuple::loop ( )

protectedvirtual

list the configured chains once

FIXME: should really have hardcoded limits encoded as const variables

use wide |eta|<5 range to allow for ITk studies also

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

bomb out if no chains passed and not told to keep all events

finished loop over chains

bomb out if no chains passed and not told to keep all events and found no offline objects

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

AOD

anything else?

anything else?

anything else?

get (offline) reference tracks

get offline tracks

get the offline vertices into our structure

add offline Vertices to the Offline chain

add the truth particles if needed

offline object counters // std::vector<TrackTrigObject> tidaVertexTracks;

now add the offline tracks

navigate through the requested storegate TEST chains

keep this printout here, but commented for usefull debug purposes ...

get the chain, collection and TE names and track index

here we only want collections with no specified chain name, then we look in storegate for the collections directly

now retrieve any verttices for the analysis

MT Vertex access

new electron selection

hmm, if we stored the types as a map it would be more straightforward than having to stick all this in a loop

get muons

get muons

new tau selection

hmm, if we stored the types as a map it would be more straightforward than having to stick all this in a loop

use same threshold for 1 and 3 prong ??

only add a tau collection if there are actually the relevant tausCH

get the chain name

and the name of the collection (if any)

now decide whether we want all the TEs for this chain, or just those that are still active

if the chain did not pass, skip this chain completely

new MT TDT feature access

a hack to fetch back the Rois with "_probe" in the name if the standard named RoiDescriptors are not actually present for this chain ...

count of how many rois processed so far

if no rois for this chain then move along

create the analysis chain

I really, really hate range based loops ...

don't extract any additional rois if a superRoi is requested: In this case, the superRoi would be shared between the different chains

check this is not a spurious TDT match

get the tracks

useful diagnostic - leave in place ... m_provider->msg(MSG::INFO) << "TIDARoi " << *roi_tmp << "\tcollectionName: " << collectionName << endmsg;

this should never be the case, and we should only run this bit of code once the first time round the loop anyhow

fetch vertices if available ...

MT Vertex access

Reimplemented from AnalysisConfig_Ntuple.

Definition at line 97 of file AnalysisConfigMT_Ntuple.cxx.

                                   {
 
        m_provider->msg(MSG::DEBUG) << "␛[91;1m" << "AnalysisConfigMT_Ntuple::loop() for " << m_analysisInstanceName 
                   << " compiled " << __DATE__ << " " << __TIME__ << "\t: " << date() << "␛[m" << endmsg;
 
 
    bool foundOffline = false;
 
    // get (offline) beam position
    double xbeam = 0;
    double ybeam = 0;
    double zbeam = 0;
    std::vector<double> beamline;
 
 
    // get (online) beam position
    double xbeam_online = 0;
    double ybeam_online = 0;
    double zbeam_online = 0;
 
    std::vector<double> beamline_online;
 
    //  m_provider->msg(MSG::INFO) << " offline beam position\tx=" << xbeam        << "\ty=" << ybeam        << "\tz=" << zbeam        << endmsg; 
    //  m_provider->msg(MSG::INFO) << " online  beam position\tx=" << xbeam_online << "\ty=" << ybeam_online << "\tz=" << zbeam_online << endmsg; 

    static const std::set<std::string> configuredHLTChains = get_configured_chains();
 
    Filter_AcceptAll filter;
    Filter_etaPT       filterRef(5,500);   
    Filter_etaPT       filter_etaPT(5.0,m_ptmin);
    Filter_pdgIdpTeta  filter_pdgIdpTeta(m_TruthPdgId,5.0,m_ptmin); // |eta|<5, pt>m_ptmin 
 
    TrackFilter*        truthFilter = &filter_etaPT;
 
    TrigTrackSelector selectorTruth( truthFilter, m_fiducial_radius, m_TruthPdgId, m_parentTruthPdgId); 
 
    TrigTrackSelector selectorRef( &filter_etaPT ); 
    TrigTrackSelector selectorTest( &filter ); 
 
    TIDAVertexBuilder vertexBuilder;
 
    if ( xbeam!=0 || ybeam!=0 ) { 
      selectorTruth.setBeamline( xbeam, ybeam, zbeam ); 
      selectorRef.setBeamline( xbeam, ybeam, zbeam );
    }
 
    if ( xbeam_online!=0 || ybeam_online!=0 ) { 
        selectorTest.setBeamline( xbeam_online, ybeam_online, zbeam_online ); 
    }
 
    selectorTruth.correctTracks( true );
    selectorRef.correctTracks( true );
    selectorTest.correctTracks( true );
    
 
    // clear the ntuple TIDA::Event class
    m_event->clear();
 
    const xAOD::EventInfo* pEventInfo = 0;
 
    unsigned           run_number         = 0;
    unsigned long long event_number       = 0;
    unsigned           lumi_block         = 0;
    unsigned           bunch_crossing_id  = 0;
    unsigned           time_stamp         = 0;
    double             mu_val             = 0;
 
    if ( retrieve(pEventInfo, "EventInfo").isFailure() ) {
        m_provider->msg(MSG::DEBUG) << "Failed to get EventInfo " << endmsg;
    } 
    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();
    }
 
    m_provider->msg(MSG::DEBUG) << "run "     << run_number 
                    << "\tevent " << event_number 
                    << "\tlb "    << lumi_block << endmsg;
 
    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);
 
    // build a chain group on the fly and use the reference
    const Trig::ChainGroup* L2chain=(*m_tdt)->getChainGroup("L2_.*");
    const Trig::ChainGroup* EFchain=(*m_tdt)->getChainGroup("EF_.*");
    const Trig::ChainGroup* HLTchain=(*m_tdt)->getChainGroup("HLT_.*");
 
    m_provider->msg(MSG::DEBUG) << "␛[91;1m" 
        << "L2 pass " << L2chain->isPassed()  << "\t" 
        << "EF pass " << EFchain->isPassed()  << "\t" 
        << "HLT pass " << HLTchain->isPassed() << "␛[m"
        << endmsg;
       
 
    bool analyse = false;
 
    unsigned decisiontype = TrigDefs::Physics;
    
 
    int passed_chains = 0;
 
    m_provider->msg(MSG::DEBUG) << "Checking " << m_chainNames.size() << " chains" << endmsg;
    
    if ( m_chainNames.empty() ) {
      m_provider->msg(MSG::WARNING) << "No chains to check" << endmsg;
      return;
    }
 
    for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
  
        std::string chainName = m_chainNames[ichain].head();
 
        // 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 ( configuredHLTChains.find(chainName)==configuredHLTChains.end() ) {
            m_provider->msg(MSG::WARNING) << "␛[91;1m" << "Chain " << chainName 
                << " is not configured for this event" << "␛[m"
                << endmsg;
            continue;
        }
        
        if ( m_chainNames[ichain].passed() ) decisiontype = TrigDefs::Physics;
        else                                 decisiontype = TrigDefs::includeFailedDecisions;
        
        std::string roistring = "";
        if ( m_chainNames[ichain].roi()!=""  ) roistring += "\troi " + m_chainNames[ichain].roi();  
 
        bool passPhysics = (*m_tdt)->isPassed(chainName); 
 
        m_provider->msg(MSG::DEBUG) << "Chain "  << chainName << "\troi " << roistring 
                       << "\tpres " << (*m_tdt)->getPrescale(chainName)
                       << ( passPhysics ? "␛[91;1m" : "" ) << "\tpass physics  " <<  passPhysics << ( passPhysics ? "␛[m" : "" ) 
                       << "\t: ( pass " << (*m_tdt)->isPassed(chainName, decisiontype ) << "\tdec type " << decisiontype << " ) " << endmsg;
 
        if ( (*m_tdt)->isPassed(chainName, decisiontype ) ||  !m_chainNames[ichain].passed() ) { 
          analyse = true;
          passed_chains++;
        }
 
    } 
 
 

    if ( !analyse && !m_keepAllEvents && !foundOffline ) { 
      m_provider->msg(MSG::DEBUG) << "No chains passed unprescaled - not processing this event: " << run_number << " " << event_number << " " << lumi_block << endmsg; 
      return;
    }
    
 
    m_provider->msg(MSG::DEBUG) << "Chains passed " << passed_chains << endmsg;
 

 
    //  const TruthParticleContainer*  mcpartTES = 0;
 
    selectorTruth.clear();
 
    m_provider->msg(MSG::DEBUG) << "MC Truth flag " << m_mcTruth << endmsg; 
    const TrigInDetTrackTruthMap* truthMap = 0;
 
    if ( m_mcTruth) { 
        m_provider->msg(MSG::DEBUG) << "getting Truth" << endmsg; 
        if ( retrieve(truthMap, "TrigInDetTrackTruthMap").isFailure()) {
                m_hasTruthMap = false;
        }
        else {
                m_hasTruthMap = true;
        }
        if (m_provider->evtStore()->contains<TruthParticleContainer>("INav4MomTruthEvent")) {
            //ESD
            selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );
        }
        else if (m_provider->evtStore()->contains<TruthParticleContainer>("SpclMC")) {
            selectTracks<TruthParticleContainer>( &selectorTruth, "SpclMC");
        }
        else if (m_provider->evtStore()->contains<TruthParticleContainer>("")) {
            selectTracks<TruthParticleContainer>( &selectorTruth, "");
        }
        else if (m_provider->evtStore()->contains<xAOD::TruthParticleContainer>("TruthParticles")) {
                selectTracks<xAOD::TruthParticleContainer>( &selectorTruth, "TruthParticles" );
        }
        else if (m_provider->evtStore()->contains<xAOD::TruthParticleContainer>("")) {
                selectTracks<xAOD::TruthParticleContainer>( &selectorTruth, "" );
        }
        else { 
            m_provider->msg(MSG::WARNING) << "Truth not found - none whatsoever!" << endmsg; 
        }
    }
 
 
    // clear the ntuple TIDA::Event class
    m_event->clear();


 
    m_provider->msg(MSG::DEBUG) << " Offline tracks " << endmsg;
 
    selectorRef.clear();
 
    if      (m_provider->evtStore()->contains<xAOD::TrackParticleContainer>("InDetTrackParticles")) {
      selectTracks<xAOD::TrackParticleContainer>( &selectorRef, "InDetTrackParticles" );
    }
    else if (m_provider->evtStore()->contains<Rec::TrackParticleContainer>("TrackParticleCandidate")) {
      selectTracks<Rec::TrackParticleContainer>( &selectorRef, "TrackParticleCandidate" );
        }
    else { 
      m_provider->msg(MSG::WARNING) << " Offline tracks not found " << endmsg;
    }
    

    for ( size_t iv=0; iv<m_vertexType.size(); iv++ ) {
 
        std::vector<TIDA::Vertex> vertices;
        
        std::string vertexType = "PrimaryVertices";
        std::string vertexChainname = "Vertex";
        if ( m_vertexType[iv]!="" ) { 
            vertexType = m_vertexType[iv];
            vertexChainname += ":" + vertexType;
        }
 
        m_provider->msg(MSG::VERBOSE) << "fetching offline AOD vertex container with key " << vertexType << endmsg;
 
        const xAOD::VertexContainer* xaodVtxCollection = 0;
 
        if ( retrieve( xaodVtxCollection, vertexType ).isFailure()) {
          if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "xAOD vertex container not found with key " << vertexType <<  endmsg;
        }
        
        if ( xaodVtxCollection!=0 ) { 
        
            m_provider->msg(MSG::DEBUG) << "xAOD vertex container " << vertexType << " found with " << xaodVtxCollection->size() <<  " entries" << endmsg;
            
            // Vertex types in some secondary vertex collections are not properly set and are all 0, 
            // allow these vertices if primary vertices are not used
            if ( vertexType.find("SecVtx") != std::string::npos ) {
                vertices = vertexBuilder.select( xaodVtxCollection, &selectorRef.tracks(), true );
            }
            else {
                vertices = vertexBuilder.select( xaodVtxCollection, &selectorRef.tracks() );
            }
        }
 
        // now add the offline vertices
        if ( m_doOffline || m_doVertices ) { 
            m_event->addChain( vertexChainname );
            m_event->back().addRoi(TIDARoiDescriptor(true));
            m_event->back().back().addVertices( vertices );
        }    
    }


    
    if ( m_mcTruth ) {
      m_event->addChain( "Truth" ); 
      m_event->back().addRoi(TIDARoiDescriptor(true));
      m_event->back().back().addTracks(selectorTruth.tracks());
    }
 
#if 0
    for ( unsigned i=0 ; i<vertices.size() ; i++ )  { 
      m_provider->msg(MSG::DEBUG) << "vertex " << i << " " << vertices[i] << endmsg;
      m_event->addVertex(vertices[i]);
    }
#endif  

 
    int Noff  = 0;
    int Nmu   = 0;
    int Nel   = 0;
    int Ntau  = 0;

 
    if ( m_doOffline ) { 
      
      m_event->addChain( "Offline" );
      m_event->back().addRoi(TIDARoiDescriptor(true));
      m_event->back().back().addTracks(selectorRef.tracks());
    
      if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) { 
        std::vector<double> beamline_;
        beamline_.push_back( selectorRef.getBeamX() );
        beamline_.push_back( selectorRef.getBeamY() );
        beamline_.push_back( selectorRef.getBeamZ() );
        m_event->back().back().addUserData(beamline_);
      }
 
 
      Noff = selectorRef.tracks().size();
      
      m_provider->msg(MSG::DEBUG) << "ref tracks.size() " << selectorRef.tracks().size() << endmsg; 
      for ( int ii=selectorRef.tracks().size() ; ii-- ; ) m_provider->msg(MSG::DEBUG) << "  ref track " << ii << " " << *selectorRef.tracks()[ii] << endmsg;  
      
    }

    for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {  
      
      //      m_provider->msg(MSG::INFO)<< "chain:\t" << m_chainNames[ichain] << endmsg;

      std::string chainname      = m_chainNames[ichain].head();
      std::string collectionname = m_chainNames[ichain].tail();
      std::string vtx_name       = m_chainNames[ichain].vtx();
 
 
      if ( chainname!="" )      continue;
      if ( collectionname=="" ) continue;
 
      chainname = collectionname;
      if ( vtx_name!="" ) chainname += ":" + vtx_name; 
  
      // useful debug information - leave this here

 
      selectorTest.clear();
 
      bool found = false;
      
      std::string collection_test = collectionname;
      size_t pos = collectionname.find("/");
      if ( pos!=std::string::npos ) collection_test = collectionname.substr( pos+1, collectionname.size()-pos );
 
      if (m_provider->evtStore()->contains<Rec::TrackParticleContainer>(collection_test)) {
        found = selectTracks<Rec::TrackParticleContainer>( &selectorTest, collectionname );
      }
      else if (m_provider->evtStore()->contains<xAOD::TrackParticleContainer>(collection_test)) {
        found = selectTracks<xAOD::TrackParticleContainer>( &selectorTest, collectionname );
      }
      else if (m_provider->evtStore()->contains<TrigInDetTrackCollection>(collection_test)) {
        found = selectTracks<TrigInDetTrackCollection>( &selectorTest, collectionname );
      }
      else if (m_provider->evtStore()->contains<TrackCollection>(collection_test)) {
        found = selectTracks<TrackCollection>( &selectorTest, collectionname );
      }
      else { 
        m_provider->msg(MSG::WARNING) << "\tcollection " << collectionname << " not found" << endmsg;
      }
      

 
      std::vector<TIDA::Vertex> tidavertices;
 
      m_provider->msg(MSG::DEBUG) << "\tFetch xAOD::VertexContainer with key " << vtx_name << endmsg;
        
      if ( vtx_name!="" ) { 
            
        m_provider->msg(MSG::DEBUG) << "\tFetch xAOD::VertexContainer with key " << vtx_name << endmsg;
            
            
        const xAOD::VertexContainer* xaodVtxCollection = 0;
        
        if ( retrieve( xaodVtxCollection, vtx_name ).isFailure() ) {
          if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "xAOD vertex container not found with key " << vtx_name <<  endmsg;
        }
        
        if ( xaodVtxCollection!=0 ) { 
                
          m_provider->msg(MSG::DEBUG) << "\txAOD::VertexContainer found with size  " << xaodVtxCollection->size()
                      << "\t" << vtx_name << endmsg;
 
          // Vertex types in some secondary vertex collections are not properly set and are all 0, 
          // allow these vertices if primary vertices are not used
          if ( vtx_name.find("SecVtx") != std::string::npos ) {
            tidavertices = vertexBuilder.select( xaodVtxCollection, 0, true );
          }
          else {
            tidavertices = vertexBuilder.select( xaodVtxCollection );
          }        
        }
 
      }
 
 
      if ( found ) { 
        
        m_event->addChain( chainname );
        m_event->back().addRoi(TIDARoiDescriptor(true));
        if ( vtx_name!="" ) m_event->back().back().addVertices( tidavertices );
        m_event->back().back().addTracks(selectorTest.tracks());
 
        if ( selectorTest.getBeamX()!=0 || selectorTest.getBeamY()!=0 || selectorTest.getBeamZ()!=0 ) { 
          std::vector<double> beamline_;
          beamline_.push_back( selectorTest.getBeamX() );
          beamline_.push_back( selectorTest.getBeamY() );
          beamline_.push_back( selectorTest.getBeamZ() );
          m_event->back().back().addUserData(beamline_);
        }
        
        int Ntest = selectorTest.tracks().size();
        
        m_provider->msg(MSG::DEBUG) << "collection " << collectionname << "\ttest tracks.size() " << Ntest << endmsg; 
        for ( int ii=Ntest ; ii-- ; ) m_provider->msg(MSG::DEBUG) << "  test track " << ii << " " << *selectorTest.tracks()[ii] << endmsg;
      }
    }     
 
 
    std::string ElectronRef[7] =  { 
      "", 
      "TightCB", "MediumCB", "LooseCB",
      "TightLH", "MediumLH", "LooseLH" };
 

 
    for ( size_t ielec=0 ; ielec<m_electronType.size() ; ielec++ ) {
 
      int itype = -1;
      for ( int it=0 ; it<7 ; it++ ) if ( m_electronType[ielec]==ElectronRef[it] ) itype = it; 
      if ( itype<0 ) continue;
 
      std::vector<TrackTrigObject> elevec;
      
      std::string echain = std::string("Electrons");
      if (m_electronIsLRT[ielec]) echain = std::string("LRTElectrons");
 
      int Nel_ = processElectrons( selectorRef, &elevec, itype, ( m_rawElectrons[ielec]=="raw" ? true : false ), 0.0, echain );
      
      if ( Nel_ < 1 ) continue;
      
      Nel += Nel_;  
 
      if ( m_electronType[ielec]!="" )    echain += "_" + m_electronType[ielec];
      if ( m_rawElectrons[ielec]=="raw" ) echain += "_raw";
      
      m_event->addChain( echain );
      m_event->back().addRoi(TIDARoiDescriptor(true));
      m_event->back().back().addTracks(selectorRef.tracks());
      m_event->back().back().addObjects( elevec );
 
      if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) { 
        std::vector<double> beamline_;
        beamline_.push_back( selectorRef.getBeamX() );
        beamline_.push_back( selectorRef.getBeamY() );
        beamline_.push_back( selectorRef.getBeamZ() );
        m_event->back().back().addUserData(beamline_);
      }
 
    }
    
 
    std::string MuonRef[5] =  { "", "Tight", "Medium", "Loose", "VeryLoose" };

    for ( size_t imuon=0 ; imuon<m_muonType.size() ; imuon++ ) {
      
      m_provider->msg(MSG::DEBUG) << "fetching offline muons " << endmsg; 
 
          int muonType = -1;
          for ( int it=0 ; it<5 ; it++ ) if ( m_muonType[imuon] == MuonRef[it] ) muonType=it; 
          if ( muonType<0 ) continue; 
 
        std::string mchain = "Muons";
        if (m_muonIsLRT[imuon]) mchain = "MuonsLRT";
 
        int Nmu_ = processMuons( selectorRef, muonType, 0, mchain );
 
          if ( Nmu_ < 1 ) continue;
 
          Nmu += Nmu_;
 
      m_provider->msg(MSG::DEBUG) << "found " << Nmu << " offline muons " << endmsg; 
 
          if ( m_muonType[imuon]!="" )  mchain += "_" + m_muonType[imuon];
 
      m_event->addChain(mchain);
      m_event->back().addRoi(TIDARoiDescriptor(true));
      m_event->back().back().addTracks(selectorRef.tracks());
 
      if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) { 
          std::vector<double> beamline_;
          beamline_.push_back( selectorRef.getBeamX() );
          beamline_.push_back( selectorRef.getBeamY() );
          beamline_.push_back( selectorRef.getBeamZ() );
          m_event->back().back().addUserData(beamline_);
      }
 
      m_provider->msg(MSG::DEBUG) << "ref muon tracks.size() " << selectorRef.tracks().size() << endmsg; 
      for ( int ii=selectorRef.tracks().size() ; ii-- ; ) m_provider->msg(MSG::DEBUG) << "  ref muon track " << ii << " " << *selectorRef.tracks()[ii] << endmsg;  
    }
 

    if ( m_doMuonsSP ) { 
      
      m_provider->msg(MSG::DEBUG) << "fetching offline muons " << endmsg; 
 
          int muonType = 0;
 
      Nmu += processMuons( selectorRef, muonType );
 
      m_provider->msg(MSG::DEBUG) << "found " << Nmu << " offline muons " << endmsg; 
 
      m_event->addChain("MuonsSP");
      m_event->back().addRoi(TIDARoiDescriptor(true));
      m_event->back().back().addTracks(selectorRef.tracks());
 
      m_provider->msg(MSG::DEBUG) << "ref muon tracks.size() " << selectorRef.tracks().size() << endmsg; 
      for ( int ii=selectorRef.tracks().size() ; ii-- ; ) m_provider->msg(MSG::DEBUG) << "  ref muon track " << ii << " " << *selectorRef.tracks()[ii] << endmsg;  
    }
    
 

    std::string TauRef[4] = { "", "Tight", "Medium", "Loose" };
    
 
    for ( size_t itau=0 ; itau<m_tauType.size() ; itau++ ) {
 
      int itype = -1;
      for ( int it=0 ; it<4 ; it++ ) if ( m_tauType[itau]==TauRef[it] ) itype = it; 
      if ( itype<0 ) continue;

      int requireNtracks = 0;
      if  ( m_tauProngs[itau]=="3Prong" ) requireNtracks = 3;    
      if  ( m_tauProngs[itau]=="1Prong" ) requireNtracks = 1;
 
      std::vector<TrackTrigObject> tauvec; 
 
      int Ntau_ = processTaus( selectorRef, &tauvec, itype, requireNtracks, 20000 ); 
 
      Ntau += Ntau_;
 
      if ( Ntau_ > 0 ) { 
 
        std::string tchain = std::string("Taus");
        if (   m_tauType[itau] != "" ) tchain += "_" + m_tauType[itau];
        if ( m_tauProngs[itau] != "" ) tchain += "_" + m_tauProngs[itau];
        
        m_event->addChain( tchain );
        m_event->back().addRoi(TIDARoiDescriptor(true));
        m_event->back().back().addTracks(selectorRef.tracks());
        m_event->back().back().addObjects( tauvec ) ; 
 
        if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) { 
          std::vector<double> beamline_;
          beamline_.push_back( selectorRef.getBeamX() );
          beamline_.push_back( selectorRef.getBeamY() );
          beamline_.push_back( selectorRef.getBeamZ() );
          m_event->back().back().addUserData(beamline_);
        }
 
      }
    }
    
    if ( Nmu==0 && Noff==0 && Nel==0 && Ntau==0 ) m_provider->msg(MSG::DEBUG) << "No offline objects found " << endmsg;
    else foundOffline = true;
 
 
    // now loop over all relevant chains to get the trigger tracks...
 
    for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {  
 
        // create chains for ntpl

        const std::string&  chainName = m_chainNames[ichain].head();

        const std::string& collectionName = m_chainNames[ichain].tail();
 
        if( chainName.find("L2_")==std::string::npos && 
            chainName.find("EF_")==std::string::npos && 
            chainName.find("HLT_")==std::string::npos ) continue;
 
        if ( m_chainNames[ichain].passed() ) decisiontype = TrigDefs::Physics;
        else                                 decisiontype = TrigDefs::includeFailedDecisions;
 
 
        m_provider->msg(MSG::DEBUG) << "chain " << chainName 
                        << "\tprescale " << (*m_tdt)->getPrescale(chainName)
                        << "\tpass "     << (*m_tdt)->isPassed(chainName) << " physics " 
                        << "  (req dec " << (*m_tdt)->isPassed(chainName, decisiontype ) << " dec type " << decisiontype << ")"
                        << endmsg;
        

        if ( !(*m_tdt)->isPassed( chainName, decisiontype ) ) continue;

        
 
        std::string roi_key  = m_chainNames[ichain].roi();
        std::string vtx_name = m_chainNames[ichain].vtx();
 
 
#if 0
 
 
        if ( roi_name!="" ) { 
 
          std::string roi_name_tmp = roi_name;
          std::string roi_tename   = "";
          
          if ( roi_name.find("/")!=std::string::npos ) { 
            roi_name_tmp = roi_name.substr( roi_name.find("/")+1, roi_name.size()-roi_name.find("/") );
            roi_tename   = roi_name.substr( 0, roi_name.find("/") );
          }
          
          roist = comb->get<TrigRoiDescriptor>( roi_name_tmp, decisiontype, roi_tename );
          
          if ( roist.size()>0 ) { 
            for ( unsigned ir=0 ; ir<roist.size() ; ir++ ) m_provider->msg(MSG::DEBUG) << "\t\tRetrieved roi  " << roi_name << "\t" << *roist[ir].cptr() << endmsg; 
          }
          else { 
            m_provider->msg(MSG::WARNING) << "\t\tRequested roi  " << roi_name << " not found" << endmsg; 
          }
          
        }
        else { 
          roist = comb->get<TrigRoiDescriptor>("forID1"); 
          if ( roist.empty() ) roist = comb->get<TrigRoiDescriptor>("forID"); 
          if ( roist.empty() ) roist = comb->get<TrigRoiDescriptor>(""); 
          if ( roist.empty() ) roist = comb->get<TrigRoiDescriptor>("initialRoI"); 
        }             
#endif
        
 
        unsigned feature_type = TrigDefs::lastFeatureOfType;
 
        if ( roi_key!="" ) feature_type = TrigDefs::allFeaturesOfType;
 
        int leg = -1;
 
        if ( m_chainNames[ichain].element()!="" ) { 
          leg = std::atoi(m_chainNames[ichain].element().c_str());
        }
 
 
        std::string rgex = roi_key;
 
        std::vector< TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection> > rois = 
          (*m_tdt)->template features<TrigRoiDescriptorCollection>( Trig::FeatureRequestDescriptor( chainName,  
                                                        decisiontype, 
                                                        rgex,
                                                        feature_type,
                                                        "roi", 
                                                        leg ) );

        if ( rois.empty() ) {
          if ( !rgex.empty() ) {
            rgex += "_probe";
            rois = (*m_tdt)->template features<TrigRoiDescriptorCollection>( Trig::FeatureRequestDescriptor( chainName,  
                                                             decisiontype, 
                                                             rgex,
                                                             feature_type,
                                                             "roi", 
                                                             leg ) );
          }
        }
 
        int iroi = 0; 

 
        if ( rois.size()==0 ) continue;

 
        m_event->addChain( m_chainNames[ichain] );
 
        TIDA::Chain& chain = m_event->back();

        for ( const TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection>& roi_info : rois ) {
          
          iroi++;
          
 
          if ( roi_key=="SuperRoi" && iroi>1 ) continue;
 
          if ( roi_key.find("JetSuper")!=std::string::npos && iroi>1 ) continue; 
          
          const ElementLink<TrigRoiDescriptorCollection> roi_link = roi_info.link;

          if ( roi_key!="" && roi_link.dataID()!=rgex ) continue;
 
          const TrigRoiDescriptor* const* roiptr = roi_link.cptr();
 
          if ( roiptr == 0 ) { 
            //    std::cerr << "\treadback link is null  DAMMIT !!!" << std::endl;
            continue;
          }  
 
          if (m_provider->msg().level() <= MSG::VERBOSE) {
            m_provider->msg(MSG::VERBOSE) << " RoI descriptor for seeded chain " << chainName << " " << **roiptr << endmsg;
          }
 
          TIDARoiDescriptor* roi_tmp = new TIDARoiDescriptor( TIDARoiDescriptorBuilder(**roiptr) );        


                  
                  
          selectorTest.clear();
 
 
          if ( chainName.find("HLT_")!=std::string::npos ) {
            if ( selectTracks<xAOD::TrackParticleContainer>( &selectorTest, roi_link,  collectionName ) ); 
            else {
              if (m_provider->msg().level() <= MSG::DEBUG) {
            m_provider->msg(MSG::WARNING) << "\tNo track collection " << collectionName << " found"  << endmsg;  
              }
            }
          }
          
          
          std::vector<TIDA::Vertex> tidavertices;   
          
          if ( vtx_name!="" ) { 
            
            m_provider->msg(MSG::DEBUG) << "\tFetch xAOD::VertexContainer for chain " << chainName << " with key " << vtx_name << endmsg;
            
            
            std::pair< xAOD::VertexContainer::const_iterator, 
                   xAOD::VertexContainer::const_iterator > vtx_itrpair = getCollection<xAOD::VertexContainer>( roi_link, vtx_name );
            
            if ( vtx_itrpair.first == vtx_itrpair.second ) { 
              if ( m_provider->msg().level() <= MSG::DEBUG ) {
            m_provider->msg(MSG::WARNING) << "\tNo xAOD::Vertex for chain " << chainName << " for key " << vtx_name << endmsg;
              }
            }
            else {
              
              m_provider->msg(MSG::DEBUG) << "\txAOD::VertexContainer found with size  " << (vtx_itrpair.second - vtx_itrpair.first) 
                         << "\t" << vtx_name << endmsg;
 
              // Vertex types in some secondary vertex collections are not properly set and are all 0, 
              // allow these vertices if primary vertices are not used
              if ( vtx_name.find("SecVtx") != std::string::npos ) {
                tidavertices = vertexBuilder.select( vtx_itrpair.first, vtx_itrpair.second, &selectorRef.tracks(), true );
              }
              else {
                tidavertices = vertexBuilder.select( vtx_itrpair.first, vtx_itrpair.second, &selectorTest.tracks() );
              }           
            }
          }
 
#if 0 
          // now get the jets if they are present
          std::vector<TrackTrigObject> jets; 
          if ( chainName.find("HLT_j")!=std::string::npos ) { 
            if ( get_jets( comb, jets ) == 0 ) m_provider->msg(MSG::WARNING) << "\tjets could not be retrieved " << endmsg; 
          }                     
#endif
          
          const std::vector<TIDA::Track*>& testTracks = selectorTest.tracks();
          m_provider->msg(MSG::DEBUG) << "\ttest tracks.size() " << testTracks.size() << endmsg; 
          for (unsigned int ii=0; ii < testTracks.size(); ii++) {
            m_provider->msg(MSG::DEBUG) << "  test track " << ii << "for chain " << chainName + ":" + collectionName << " " << *testTracks[ii] << endmsg;  
          }
          
          
          // only add chain if there are any rois - also add beamline position for postprocessing
          
          
          if ( roi_tmp == 0 ) { 
            if ( testTracks.size()>0 ) m_provider->msg(MSG::WARNING) << "\ttest tracks.size() " << testTracks.size() << "found but no roi!!!" << endmsg;
            roi_tmp = new TIDARoiDescriptor(true);
          }
          
          chain.addRoi( *roi_tmp );
 
          chain.back().addTracks(testTracks);
          chain.back().addVertices(tidavertices);
 
#if 0
          if ( chainName.find("HLT_j")!=std::string::npos ) chain.back().addObjects( jets );
#endif
          
          if ( selectorTest.getBeamX()!=0 || selectorTest.getBeamY()!=0 || selectorTest.getBeamZ()!=0 ) { 
            std::vector<double> beamline_;
            beamline_.push_back( selectorTest.getBeamX() );
            beamline_.push_back( selectorTest.getBeamY() );
            beamline_.push_back( selectorTest.getBeamZ() );
            chain.back().addUserData(beamline_);
          }
      
          delete roi_tmp;
          roi_tmp = 0;
 
        }
        
    }
 
#if 0
 
    { 
 
      if ( filterOnRoi() || m_ptmin>0 ) { 
        
        TIDA::Chain* offline = 0;
        
        std::vector<std::string> chainnames = m_event->chainnames();
        
        
        for ( size_t ic=chainnames.size() ; ic-- ; ) {
          if ( chainnames[ic] == "Offline" ) {
        offline = &(m_event->chains()[ic]);
        break;
          }
        }
        
        if ( offline ) { 
          
          std::vector<TIDA::Chain>& chains = m_event->chains();
          std::vector<TIDA::Chain>::iterator citr = chains.begin();
          
          std::vector<std::pair<double,double> > philims;
          
          for ( ; citr!=chains.end() ; ++citr ) {
        if ( citr->name().find("HLT_")!=std::string::npos ) { 
          for ( size_t ir=0 ; ir<citr->size() ; ir++ ) {
            TIDARoiDescriptor& roi = citr->rois()[ir].roi();
            if ( roi.composite() ) { 
              for ( size_t isub=0 ; isub<roi.size() ; isub++ ) { 
            philims.push_back( std::pair<double,double>( roi[isub]->phiMinus(), roi[isub]->phiPlus() ) ); 
              }
            }
            else philims.push_back( std::pair<double,double>( roi.phiMinus(), roi.phiPlus() ) ); 
          }
        }
          }
          
          remove_duplicates( philims );
 
          for ( size_t iroi=0 ; iroi<offline->size() ; iroi++ ) {
        
        std::vector<TIDA::Track>& tracks = offline->rois()[iroi].tracks();
        
        //  size_t Noffline = tracks.size();
 
        for ( std::vector<TIDA::Track>::iterator it=tracks.begin() ; it<tracks.end() ; ) {
          bool inc = true;
          if ( m_ptmin>0 ) { 
            if ( std::fabs(it->pT())<m_ptmin ) { inc=false; tracks.erase( it ); }
          }
          if ( inc && filterOnRoi() ) { 
            bool remove_track = true;
            for ( size_t isub=0 ; isub<philims.size() ; isub++ ) { 
              
              if ( philims[isub].first < philims[isub].second ) { 
            if ( it->phi()>=philims[isub].first && it->phi()<=philims[isub].second ) { 
              remove_track = false; 
              break;
            }
              }
              else  {
            if ( it->phi()>=philims[isub].first || it->phi()<=philims[isub].second ) { 
              remove_track = false; 
              break;
            }
              }
            }
            if ( remove_track ) { inc=false; tracks.erase( it ); }
          }
          if ( inc ) ++it;
        }
        
        //  m_provider->msg(MSG::DEBUG) << "TIDA::Roi offline track reduction: " << Noffline << " -> " << tracks.size() << endmsg;
        
          }
         
        }
                
      }
    }
 
#endif
 
    if ( m_Tree ) m_Tree->Fill();
    
}

mcTruth()

bool T_AnalysisConfig< AthReentrantAlgorithm >::mcTruth ( ) const

inlineinherited

Definition at line 261 of file T_AnalysisConfig.h.

{ return m_mcTruth; }

name()

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

inlineinherited

Definition at line 235 of file T_AnalysisConfig.h.

{return m_analysisInstanceName;}

processElectrons()

unsigned T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::releaseData ( ) const

inlineinherited

Definition at line 273 of file T_AnalysisConfig.h.

{ return m_releaseData; }

requireDecision()

bool T_AnalysisConfig< AthReentrantAlgorithm >::requireDecision ( ) const

inlineinherited

Definition at line 288 of file T_AnalysisConfig.h.

{ return m_requireDecision; }

retrieve()

StatusCode T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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;   
    }

set_fiducial_radius()

void AnalysisConfigMT_Ntuple::set_fiducial_radius ( double d )

inline

Definition at line 44 of file AnalysisConfigMT_Ntuple.h.

{ m_fiducial_radius = d; }

set_ptmin()

void AnalysisConfigMT_Ntuple::set_ptmin ( double d )

inline

Definition at line 45 of file AnalysisConfigMT_Ntuple.h.

{ m_ptmin = d; }

setBeamX()

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

inlineinherited

Definition at line 263 of file T_AnalysisConfig.h.

{ m_beamX=d; }

setBeamY()

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

inlineinherited

Definition at line 264 of file T_AnalysisConfig.h.

{ m_beamY=d; }

setBeamZ()

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

inlineinherited

Definition at line 265 of file T_AnalysisConfig.h.

{ m_beamZ=d; }

setFilterOnRoi()

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

inlineinherited

Definition at line 285 of file T_AnalysisConfig.h.

{ return m_filterOnRoi=b; }

setGenericFlag()

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

inlineinherited

Definition at line 271 of file T_AnalysisConfig.h.

{ m_genericFlag=b; }

setMCTruth()

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

inlineinherited

Definition at line 260 of file T_AnalysisConfig.h.

{ m_mcTruth=b; }

setRequireDecision()

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

inlineinherited

Definition at line 287 of file T_AnalysisConfig.h.

{ m_requireDecision=b; }

setUseHighestPT()

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

inlineinherited

Definition at line 278 of file T_AnalysisConfig.h.

{ m_useHighestPT=b; }

setVtxIndex()

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

inlineinherited

Definition at line 281 of file T_AnalysisConfig.h.

{ m_vtxIndex=i; }

testChains()

const std::string T_AnalysisConfig< AthReentrantAlgorithm >::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;
  }

Member Data Documentation

m_analysis

TrackAnalysis* T_AnalysisConfig< AthReentrantAlgorithm >::m_analysis

protectedinherited

Definition at line 986 of file T_AnalysisConfig.h.

m_analysisInstanceName

std::string T_AnalysisConfig< AthReentrantAlgorithm >::m_analysisInstanceName

protectedinherited

Definition at line 965 of file T_AnalysisConfig.h.

m_associator

TrackAssociator* T_AnalysisConfig< AthReentrantAlgorithm >::m_associator

protectedinherited

Definition at line 985 of file T_AnalysisConfig.h.

m_beamX

double T_AnalysisConfig< AthReentrantAlgorithm >::m_beamX

protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

m_beamY

double T_AnalysisConfig< AthReentrantAlgorithm >::m_beamY

protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

m_beamZ

double T_AnalysisConfig< AthReentrantAlgorithm >::m_beamZ

protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

m_chainNames

std::vector<ChainString> AnalysisConfig_Ntuple::m_chainNames

protectedinherited

Definition at line 166 of file AnalysisConfig_Ntuple.h.

m_Dir

TDirectory* AnalysisConfig_Ntuple::m_Dir

protectedinherited

Definition at line 164 of file AnalysisConfig_Ntuple.h.

m_doBjets

bool AnalysisConfig_Ntuple::m_doBjets

protectedinherited

Definition at line 185 of file AnalysisConfig_Ntuple.h.

m_doMuons

bool AnalysisConfig_Ntuple::m_doMuons

protectedinherited

Definition at line 170 of file AnalysisConfig_Ntuple.h.

m_doMuonsSP

bool AnalysisConfig_Ntuple::m_doMuonsSP

protectedinherited

Definition at line 171 of file AnalysisConfig_Ntuple.h.

m_doOffline

bool AnalysisConfig_Ntuple::m_doOffline

protectedinherited

Definition at line 168 of file AnalysisConfig_Ntuple.h.

m_doVertices

bool AnalysisConfig_Ntuple::m_doVertices

protectedinherited

Definition at line 169 of file AnalysisConfig_Ntuple.h.

m_electronIsLRT

std::vector<bool> AnalysisConfig_Ntuple::m_electronIsLRT

protectedinherited

Definition at line 178 of file AnalysisConfig_Ntuple.h.

m_electronType

std::vector<std::string> AnalysisConfig_Ntuple::m_electronType

protectedinherited

Definition at line 176 of file AnalysisConfig_Ntuple.h.

m_event

TIDA::Event* AnalysisConfig_Ntuple::m_event

protectedinherited

Definition at line 160 of file AnalysisConfig_Ntuple.h.

m_fiducial_radius

double AnalysisConfigMT_Ntuple::m_fiducial_radius

private

Definition at line 55 of file AnalysisConfigMT_Ntuple.h.

m_File

TFile* AnalysisConfig_Ntuple::m_File

protectedinherited

Definition at line 162 of file AnalysisConfig_Ntuple.h.

m_filterOnRoi

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_filterOnRoi

protectedinherited

Definition at line 1001 of file T_AnalysisConfig.h.

m_filters

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

protectedinherited

Definition at line 979 of file T_AnalysisConfig.h.

m_finalised

bool AnalysisConfig_Ntuple::m_finalised

protectedinherited

Definition at line 193 of file AnalysisConfig_Ntuple.h.

m_genericFlag

int T_AnalysisConfig< AthReentrantAlgorithm >::m_genericFlag

protectedinherited

Definition at line 992 of file T_AnalysisConfig.h.

m_hasTruthMap

bool AnalysisConfig_Ntuple::m_hasTruthMap

protectedinherited

Definition at line 186 of file AnalysisConfig_Ntuple.h.

m_keepAllEvents

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_keepAllEvents

protectedinherited

Definition at line 995 of file T_AnalysisConfig.h.

m_keys

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

protectedinherited

Definition at line 970 of file T_AnalysisConfig.h.

m_mcTruth

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_mcTruth

protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

m_muonIsLRT

std::vector<bool> AnalysisConfig_Ntuple::m_muonIsLRT

protectedinherited

Definition at line 174 of file AnalysisConfig_Ntuple.h.

m_muonType

std::vector<std::string> AnalysisConfig_Ntuple::m_muonType

protectedinherited

Definition at line 173 of file AnalysisConfig_Ntuple.h.

m_outputFileName

std::string AnalysisConfig_Ntuple::m_outputFileName

protectedinherited

Definition at line 189 of file AnalysisConfig_Ntuple.h.

m_parentTruthPdgId

int AnalysisConfig_Ntuple::m_parentTruthPdgId

protectedinherited

Definition at line 201 of file AnalysisConfig_Ntuple.h.

m_printInfo

bool AnalysisConfig_Ntuple::m_printInfo

protectedinherited

Definition at line 197 of file AnalysisConfig_Ntuple.h.

m_provider

AthReentrantAlgorithm* T_AnalysisConfig< AthReentrantAlgorithm >::m_provider

protectedinherited

Definition at line 957 of file T_AnalysisConfig.h.

m_ptmin

double AnalysisConfigMT_Ntuple::m_ptmin

private

Definition at line 56 of file AnalysisConfigMT_Ntuple.h.

m_rawElectrons

std::vector<std::string> AnalysisConfig_Ntuple::m_rawElectrons

protectedinherited

Definition at line 177 of file AnalysisConfig_Ntuple.h.

m_refChainKey

std::string T_AnalysisConfig< AthReentrantAlgorithm >::m_refChainKey

protectedinherited

Definition at line 973 of file T_AnalysisConfig.h.

m_refChainName

std::string T_AnalysisConfig< AthReentrantAlgorithm >::m_refChainName

protectedinherited

Definition at line 972 of file T_AnalysisConfig.h.

m_releaseData

std::string T_AnalysisConfig< AthReentrantAlgorithm >::m_releaseData

protectedinherited

Definition at line 993 of file T_AnalysisConfig.h.

m_requireDecision

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_requireDecision

protectedinherited

Definition at line 1003 of file T_AnalysisConfig.h.

m_selectorRef

TrigTrackSelector* T_AnalysisConfig< AthReentrantAlgorithm >::m_selectorRef

protectedinherited

Definition at line 981 of file T_AnalysisConfig.h.

m_selectorSel

TrigTrackSelector* T_AnalysisConfig< AthReentrantAlgorithm >::m_selectorSel

protectedinherited

Definition at line 983 of file T_AnalysisConfig.h.

m_selectorTest

TrigTrackSelector* T_AnalysisConfig< AthReentrantAlgorithm >::m_selectorTest

protectedinherited

Definition at line 982 of file T_AnalysisConfig.h.

m_tauEtCutOffline

bool AnalysisConfig_Ntuple::m_tauEtCutOffline

protectedinherited

Definition at line 187 of file AnalysisConfig_Ntuple.h.

m_tauProngs

std::vector<std::string> AnalysisConfig_Ntuple::m_tauProngs

protectedinherited

Definition at line 181 of file AnalysisConfig_Ntuple.h.

m_tauType

std::vector<std::string> AnalysisConfig_Ntuple::m_tauType

protectedinherited

Definition at line 180 of file AnalysisConfig_Ntuple.h.

m_tdt

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

protectedinherited

Definition at line 959 of file T_AnalysisConfig.h.

m_testChainKey

std::string T_AnalysisConfig< AthReentrantAlgorithm >::m_testChainKey

protectedinherited

Definition at line 976 of file T_AnalysisConfig.h.

m_testChainName

std::string T_AnalysisConfig< AthReentrantAlgorithm >::m_testChainName

protectedinherited

Definition at line 975 of file T_AnalysisConfig.h.

m_Tree

TTree* AnalysisConfig_Ntuple::m_Tree

protectedinherited

Definition at line 163 of file AnalysisConfig_Ntuple.h.

m_TruthPdgId

int AnalysisConfig_Ntuple::m_TruthPdgId

protectedinherited

Definition at line 191 of file AnalysisConfig_Ntuple.h.

m_types

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

protectedinherited

Definition at line 969 of file T_AnalysisConfig.h.

m_useBeamCondSvc

bool AnalysisConfig_Ntuple::m_useBeamCondSvc

protectedinherited

Definition at line 158 of file AnalysisConfig_Ntuple.h.

m_useHighestPT

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_useHighestPT

protectedinherited

Definition at line 997 of file T_AnalysisConfig.h.

m_vertexType

std::vector<std::string> AnalysisConfig_Ntuple::m_vertexType

protectedinherited

Definition at line 183 of file AnalysisConfig_Ntuple.h.

m_vtxIndex

int T_AnalysisConfig< AthReentrantAlgorithm >::m_vtxIndex

protectedinherited

Definition at line 999 of file T_AnalysisConfig.h.

---

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

• AnalysisConfigMT_Ntuple.h
• AnalysisConfigMT_Ntuple.cxx