#include <T_AnalysisConfigR3_Tier0.h>

Inheritance diagram for T_AnalysisConfigR3_Tier0< T, A >:

Collaboration diagram for T_AnalysisConfigR3_Tier0< T, A >:

Public Member Functions
	T_AnalysisConfigR3_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, TagNProbe *TnP_tool=0)
virtual	~T_AnalysisConfigR3_Tier0 ()
void	initialise ()
void	setRunPurity (bool b)
void	setShifter (bool b)
void	useBeamCondSvc (bool b)
void	containTracks (bool b)
void	setPdgID (int i=0)
void	setParentPdgID (int i=0)
void	setMCTruthRef (bool b)
void	setOfflineRef (bool b)
void	setTypes (const std::vector< std::string > &t)
void	set_monTool (ToolHandle< GenericMonitoringTool > *m)
ToolHandle< GenericMonitoringTool > *	monTool ()
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
A *	m_manalysis

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="Electrons")
	select offline electrons
unsigned	processMuons (TrigTrackSelector &selectorRef, const unsigned int selection=0, double ETOffline=0, const std::string &containerName="Muons")
	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="TauJets")
	select offline taus

Protected Attributes
bool	m_useBeamCondSvc
std::vector< ChainString >	m_chainNames
std::vector< A * >	m_analyses
std::string	m_testType
bool	m_doOffline
bool	m_doMuons
bool	m_doElectrons
bool	m_doTaus
bool	m_doBjets
bool	m_doTauThreeProng
bool	m_tauEtCutOffline
std::vector< std::string >	m_offline_types
std::vector< std::string >	m_types
std::string	m_outputFileName
int	m_pdgID
int	m_parent_pdgID
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
TagNProbe *	m_TnP_tool
bool	m_tnp_flag
ToolHandle< GenericMonitoringTool > *	m_monTool
TIDA::Histogram< float > *	m_invmass
TIDA::Histogram< float > *	m_invmass_obj
T *	m_provider
ToolHandle< Trig::TrigDecisionTool > *	m_tdt
std::string	m_analysisInstanceName
std::vector< std::vector< std::string > >	m_keys
std::vector< std::vector< TrackFilter * > >	m_filters
std::string	m_refChainName
std::string	m_refChainKey
std::string	m_testChainName
std::string	m_testChainKey
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, typename A = AnalysisR3_Tier0>
class T_AnalysisConfigR3_Tier0< T, A >

Definition at line 89 of file T_AnalysisConfigR3_Tier0.h.

Constructor & Destructor Documentation

◆ T_AnalysisConfigR3_Tier0()

template<typename T, typename A = AnalysisR3_Tier0>

T_AnalysisConfigR3_Tier0< T, A >::T_AnalysisConfigR3_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,
		TagNProbe *	TnP_tool = 0 )

inline

leave in for development std::cout << "chain size: " << m_chainNames.size() << "(" << this << ")" << std::endl;

std::cout << "chain size: " << m_chainNames.size() << "(" << this << ")" << std::endl;

Definition at line 100 of file T_AnalysisConfigR3_Tier0.h.

                                           :
    T_AnalysisConfig<T>( analysisInstanceName,
             testChainName,      testType,      testKey,
             referenceChainName, referenceType, referenceKey,
             testFilter, referenceFilter,
             associator,
             analysis),
    m_manalysis(0),
    m_useBeamCondSvc(false),
    m_doOffline(true),
    m_doMuons(false),
    m_doElectrons(false),
    m_doTaus(false),
    m_doBjets(false),
    m_doTauThreeProng(false),
    m_tauEtCutOffline(false),
    m_pdgID(0),
    m_parent_pdgID(0),
    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_tnp_flag(false),
    m_monTool(0),
    m_invmass(0),
    m_invmass_obj(0)
  {
 
    m_chainNames.push_back(testChainName);
 
 
    m_TnP_tool = TnP_tool;
    
#if 0
    ChainString& chain = m_chainNames.back(); 
 
    std::cout << "\nT_AnalysisConfigR3_Tier0::name:                " << name() << "\t" << this << std::endl;
    std::cout <<  "T_AnalysisConfigR3_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 << "\textra: " << chain.extra()   << 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;
 
    if ( m_TnP_tool ) m_tnp_flag = true;
 
  }

◆ ~T_AnalysisConfigR3_Tier0()

template<typename T, typename A = AnalysisR3_Tier0>

virtual T_AnalysisConfigR3_Tier0< T, A >::~T_AnalysisConfigR3_Tier0 ( )

inlinevirtual

Definition at line 174 of file T_AnalysisConfigR3_Tier0.h.

                                      {
    if ( m_TnP_tool )    delete m_TnP_tool;
    if ( m_invmass )     delete m_invmass;
    if ( m_invmass_obj ) delete m_invmass_obj;
  }

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 157 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 166 of file T_AnalysisConfig.h.

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

T_AnalysisConfig< T >::m_filters

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

Definition T_AnalysisConfig.h:874

◆ addSelectionChain()

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

inlineinherited

Definition at line 161 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 167 of file T_AnalysisConfig.h.

167{ 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 153 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 165 of file T_AnalysisConfig.h.

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

◆ analysis()

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

inlineinherited

Definition at line 212 of file T_AnalysisConfig.h.

212{return m_analysis;}

T_AnalysisConfig< T >::m_analysis

TrackAnalysis * m_analysis

Definition T_AnalysisConfig.h:887

◆ beamX()

double T_AnalysisConfig< T >::beamX ( ) const

inlineinherited

Definition at line 220 of file T_AnalysisConfig.h.

220{ return m_beamX; }

T_AnalysisConfig< T >::m_beamX

double m_beamX

Definition T_AnalysisConfig.h:891

◆ beamY()

double T_AnalysisConfig< T >::beamY ( ) const

inlineinherited

Definition at line 221 of file T_AnalysisConfig.h.

221{ return m_beamY; }

T_AnalysisConfig< T >::m_beamY

double m_beamY

Definition T_AnalysisConfig.h:891

◆ beamZ()

double T_AnalysisConfig< T >::beamZ ( ) const

inlineinherited

Definition at line 222 of file T_AnalysisConfig.h.

222{ return m_beamZ; }

T_AnalysisConfig< T >::m_beamZ

double m_beamZ

Definition T_AnalysisConfig.h:891

◆ book()

template<typename T, typename A = AnalysisR3_Tier0>

virtual void T_AnalysisConfigR3_Tier0< T, A >::book ( )

inlineprotectedvirtual

get list of configured triggers

don't use test_type now ?

these are the Expert / non-Shifter histograms - encode the full chain names

add trigger element and roi descriptor names

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1096 of file T_AnalysisConfigR3_Tier0.h.

                      {
    
    if(m_provider->msg().level() <= MSG::VERBOSE)
      m_provider->msg(MSG::VERBOSE) << "AnalysisConfigR3_Tier0::book() " << name() << endmsg;
 
    // get the TriggerDecisionTool
 
    if( m_tdt->retrieve().isFailure() ) {
      if(m_provider->msg().level() <= MSG::ERROR)
        m_provider->msg(MSG::ERROR) << " Unable to retrieve the TrigDecisionTool: Please check job options file" << endmsg;
      return;
    }
 
    if(m_provider->msg().level() <= MSG::VERBOSE) {
      m_provider->msg(MSG::VERBOSE) << " Successfully retrieved the TrigDecisionTool"  << endmsg;
    }
 
    if (m_provider->msg().level() <= MSG::VERBOSE) {
      std::vector<std::string> configuredChains  = (*(m_tdt))->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
 
      m_provider->msg(MSG::VERBOSE)  << "Configured chains" << endmsg;
      for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
        if( m_provider->msg().level() <= MSG::VERBOSE)
          m_provider->msg(MSG::VERBOSE)  << " Chain " << configuredChains[i]  << endmsg;
      }
    }
 
 
    for ( unsigned ic=0 ; ic<m_chainNames.size() ; ic++ ) {
 
      if ( ic>0 ) { 
    m_provider->msg(MSG::WARNING) << "more than one chain configured for this analysis - skipping " << m_chainNames[ic] << endmsg;
    continue;
      }
 
      m_provider->msg(MSG::VERBOSE) << "Analyse chain " << m_chainNames[ic] << endmsg;
 
      // m_provider->msg(MSG::VERBOSE)  << "--------------------------------------------------" << endmsg;
      
      std::string folder_name = "";
      
      if ( name()!="" )  folder_name = name(); 
      else               folder_name = "HLT/TRIDT/IDMon";  
      
      if( m_testType != "" ) folder_name = folder_name + "/" + m_testType;
      
      std::string mongroup;
      
#if 0   
   
      if ( name().find("Shifter")!=std::string::npos || m_shifter ) {
    if      ( m_chainNames.at(ic).tail().find("_FTF") != std::string::npos )              mongroup = folder_name + "/FTF";
    else if ( m_chainNames.at(ic).tail().find("_IDTrig") != std::string::npos || 
          m_chainNames.at(ic).tail().find("_EFID") != std::string::npos )             mongroup = folder_name + "/EFID";
    else if ( m_chainNames.at(ic).tail().find("InDetTrigParticle") != std::string::npos ) mongroup = folder_name + "/EFID_RUN1";
    else if ( m_chainNames.at(ic).tail().find("_GSF")      != std::string::npos )         mongroup = folder_name + "/GSF";
    else                                                                                  mongroup = folder_name + "/Unknown";
 
    if ( m_chainNames.at(ic).vtx()!="" ) mongroup += "/" + m_chainNames.at(ic).vtx();
 
      }
#endif 
      //      else {
 
    if ( m_chainNames[ic].head() == "" ) mongroup = folder_name + "/Fullscan";
    else                                 mongroup = folder_name + "/" + m_chainNames[ic].head();
 
    std::string track_collection = ""; 
 
    if ( m_chainNames.at(ic).tail()!="" )  { 
      track_collection =  "/" + m_chainNames.at(ic).tail();
      if ( m_chainNames.at(ic).extra()!="" ) track_collection += "_" + m_chainNames.at(ic).extra();
    }
 
    if ( m_chainNames.at(ic).roi()!="" ) { 
      if ( track_collection!="" ) track_collection += "_" + m_chainNames[ic].roi();
      else                        track_collection = "/" + m_chainNames[ic].roi();
    }
 
    if ( m_chainNames.at(ic).vtx()!="" ) { 
      if ( track_collection!="" ) track_collection += "_" + m_chainNames[ic].vtx();
      else                        track_collection  = "/" + m_chainNames[ic].vtx();
    }
    if ( m_chainNames.at(ic).element()!="" ) { 
      if ( track_collection!="" ) track_collection += "_" + m_chainNames[ic].element();
      else                        track_collection  = "/" + m_chainNames[ic].element();
    }
    
    if ( track_collection!="" )  mongroup += track_collection;
 
    if ( !m_chainNames.at(ic).passed() )      mongroup += "/DTE";
 
    //      }
      
      m_provider->msg(MSG::VERBOSE) << " book mongroup " << mongroup << endmsg;
      
      m_manalysis = dynamic_cast<A*>(m_analysis);
 
      if ( monTool() ) m_manalysis->set_monTool( monTool() );
 
      m_analysis->initialise();
      
      if(m_provider->msg().level() <= MSG::VERBOSE) {
    m_provider->msg(MSG::VERBOSE) << "AnalysisConfigR3_Tier0::book() done" << endmsg;
      }
    }
 
  }

◆ containTracks()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::containTracks ( bool b )

inline

Definition at line 204 of file T_AnalysisConfigR3_Tier0.h.

204{ m_containTracks = b; }

◆ execute()

virtual void T_AnalysisConfig< T >::execute ( )

inlinevirtualinherited

Definition at line 179 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 238 of file T_AnalysisConfig.h.

238{ return m_filterOnRoi; }

T_AnalysisConfig< T >::m_filterOnRoi

bool m_filterOnRoi

Definition T_AnalysisConfig.h:902

◆ finalize()

template<typename T, typename A = AnalysisR3_Tier0>

virtual void T_AnalysisConfigR3_Tier0< T, A >::finalize ( )

inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1216 of file T_AnalysisConfigR3_Tier0.h.

                          {
 
    if(m_provider->msg().level() <= MSG::VERBOSE){
      m_provider->msg(MSG::VERBOSE) << "AnalysisConfigR3_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 224 of file T_AnalysisConfig.h.

224{ return m_genericFlag; }

T_AnalysisConfig< T >::m_genericFlag

int m_genericFlag

Definition T_AnalysisConfig.h:893

◆ getBeamspot()

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

inlineprotectedinherited

Definition at line 585 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 253 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 233 of file T_AnalysisConfig.h.

233{ return m_useHighestPT; }

T_AnalysisConfig< T >::m_useHighestPT

bool m_useHighestPT

Definition T_AnalysisConfig.h:898

◆ getVtxIndex()

int T_AnalysisConfig< T >::getVtxIndex ( ) const

inlineinherited

Definition at line 236 of file T_AnalysisConfig.h.

236{ return m_vtxIndex; }

T_AnalysisConfig< T >::m_vtxIndex

int m_vtxIndex

Definition T_AnalysisConfig.h:900

◆ initialise()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::initialise ( )

inline

Definition at line 181 of file T_AnalysisConfigR3_Tier0.h.

                    { 
 
    if ( m_tnp_flag ) {
      if ( m_invmass==0 )     m_invmass     = new TIDA::Histogram<float>( monTool(), "invmass" );
      if ( m_invmass_obj==0 ) m_invmass_obj = new TIDA::Histogram<float>( monTool(), "invmass_obj" );
    }
 
    for ( size_t it=0 ; it<m_types.size() ; it++ ) {
      if ( m_types[it]=="" ) m_offline_types.push_back( "InDetTrackParticles" );
      else                   m_offline_types.push_back( m_types[it] );      
    }
 
    if ( m_offline_types.empty() ) m_offline_types.push_back( "InDetTrackParticles" );
 
  }

◆ initialize()

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

inlinevirtualinherited

Definition at line 170 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 230 of file T_AnalysisConfig.h.

230{ m_keepAllEvents = b; }

T_AnalysisConfig< T >::m_keepAllEvents

bool m_keepAllEvents

Definition T_AnalysisConfig.h:896

◆ loop()

template<typename T, typename A = AnalysisR3_Tier0>

virtual void T_AnalysisConfigR3_Tier0< T, A >::loop ( )

inlineprotectedvirtual

this isn't working yet - will renable once we have a workaround

will need to add a vertex filter at some point probably

switch reference selector to truth if requested

this isn't working yet - will renable once we have a workaround if ( xbeam!=0 || ybeam!=0 ) { std::cerr << "Oh no ! setBeamLine() : " << xbeam << " " << ybeam << std::endl; pselectorRef->setBeamline( xbeam, ybeam ); }

now start everything going for this event properly ...

the fourth value will store the number of vertices

(obviously) get the event info

for debugging ...

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

for debugging ...

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

get the offline vertices into our structure

fetch offline vertices ...

add the truth particles if needed

now add the vertices

now add the offline tracks and reco objects

FIXME: most of the different truth selection can go

AOD

xAOD::TruthParticles

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

clone the asociator

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

create chains for ntpl

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

useful debug information to be kept in for the time being

useful debug information to be kept in

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

do we still want the blind chain access for track collections ???

dummy full scan chain

MT Vertex access

new Roi based feature access

new FeatureRequestDescriptor with leg 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

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

check this is not a spurious TDT match

invalid feature links can happen for missing (or truncated) Aux containers

for debug ...

get the tracks

create analysis chain

get tracks

now get the vertices

retrieve online vertices

"offline" of "roi" type chains

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

debug ...

get the beamline

the original code sets a class variable on the fill class this will not be reentrant, as another instance could overwrite it, but will keep it in for now. MAybe we could clone the analysis class each time we have an instance. Need to investigate whether such an event-by-event might be fast enough. Foe the time being, leave the original code here, but commented

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

should be included - but leave commented out here to allow study of rois with *no relevant truth particles !!!

stats book keeping

match test and reference tracks

this setting of the roi is not thread safe so it has been diabled for the time being in principle we may be able to remove it completely, but we need to check whether we can do without this functionality, so leave the code in place until we either fix it properly in the future, or determine that it is not needed

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

Implements T_AnalysisConfig< T >.

Definition at line 239 of file T_AnalysisConfigR3_Tier0.h.

                      {
 
    const TagNProbe* pTnP_tool = m_TnP_tool;
 
    if( m_provider->msg().level() <= MSG::VERBOSE) {
      m_provider->msg(MSG::VERBOSE) <<  "AnalysisConfigR3_Tier0::loop() for " << T_AnalysisConfig<T>::m_analysisInstanceName <<  endmsg;
    }
    // get (offline) beam position
    //    double xbeam = 0;
    //    double ybeam = 0;
 
#if 0
 
    if ( m_first ) {      
 
      m_first = false;
      
      if ( m_provider->msg().level() <= MSG::VERBOSE ) {
    m_provider->msg(MSG::VERBOSE) << " using beam position\tx=" << xbeam << "\ty=" << ybeam << endmsg;
    
    std::vector<std::string> configuredChains  = (*(m_tdt))->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
    
        for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
      //    std::cout << "Configured chain " << configuredChains[i]  << std::endl;
      m_provider->msg(MSG::VERBOSE)  << "Chain " << configuredChains[i]  << endmsg;
    }
      }
    
      //      std::cout << "\tloop() analyse chains " << m_chainNames.size() << std::endl;
    
    }
 
#endif
 
    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;
    }
    
    
    TrackFilter* rfilter = m_filters[iRefFilter][0];
    TrackFilter* tfilter = m_filters[iTestFilter][0];
 
    Filter_Combined filterRef(   rfilter, &filter );
    Filter_Combined filterTest(  tfilter, &filter );
 
    TrigTrackSelector  selectorTruth( &filter_truth, m_pdgID, m_parent_pdgID );
 
    TrigTrackSelector  selectorRef( &filterRef );
    TrigTrackSelector* pselectorRef = &selectorRef;
 
    TrigTrackSelector  selectorTest( &filterTest );
    TrigTrackSelector* pselectorTest = &selectorTest;
    
    if ( m_mcTruth ) pselectorRef = &selectorTruth;
 
    TIDA::Event   event;
    TIDA::Event*  eventp = &event;
 
    double beamline[4] = { 0, 0, 0, 0 }; 
     
    // clear the ntuple TIDA::Event class
    eventp->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;
    //    std::cout << "\tloop() get EventInfo" << std::endl;
 
    if ( this->template retrieve( pEventInfo, "EventInfo" ).isFailure() ) {
      m_provider->msg(MSG::WARNING) << "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();
    }
  
    if(m_provider->msg().level() <= MSG::VERBOSE){
      m_provider->msg(MSG::VERBOSE) << "run "     << run_number
                                    << "\tevent " << event_number
                                    << "\tlb "    << lumi_block << endmsg;
    }
 
    // clear the ntuple TIDA::Event class
    eventp->clear();
 
    eventp->run_number(run_number);
    eventp->event_number(event_number);
    eventp->lumi_block(lumi_block);
    eventp->time_stamp(time_stamp);
    eventp->bunch_crossing_id(bunch_crossing_id);
    eventp->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 << "\tChain "  << chainname << "\tpass " << (*m_tdt)->isPassed(chainname)
    //        << "\tpres " << (*m_tdt)->getPrescale(chainname) << std::endl;
    
    if ( (*(m_tdt))->isPassed(chainname) ) analyse = true;
    
      }
 
    }
    
    
    if ( !this->m_keepAllEvents && !analyse ) {
      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;
 
    std::vector<TIDA::Vertex> vertices;
    std::vector<TIDA::Vertex> vertices_rec;
 
    std::vector<double> refbeamspot;
    std::vector<double> testbeamspot;
 
    m_provider->msg(MSG::VERBOSE) << "fetching AOD Primary vertex container" << endmsg;
 
    if ( !this->select( vertices, "PrimaryVertices" ) ) { 
      m_provider->msg(MSG::VERBOSE) << "could not retrieve the 'PrimaryVertices' vertex collection" << std::endl;
    }
 
    if ( m_mcTruth ) {
      eventp->addChain( "Truth" );
      eventp->back().addRoi(TIDARoiDescriptor());
      eventp->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;
        eventp->addVertex(vertices[i]);
      }
    }
 
 
 
    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();
 
    // offline track retrieval now done once for each chain rather than each roi
    if ( m_provider->msg().level() <= MSG::VERBOSE )
      m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
 
    bool foundTruth = false;
 
    if ( m_mcTruth ) {
 
      filter_truth.setRoi( 0 ); // don't filter on RoI yet (or until 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<xAOD::TruthParticleContainer>("TruthParticles") ) {
    this->template selectTracks<xAOD::TruthParticleContainer>( &selectorTruth, "TruthParticles");
    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_mcTruth && !foundTruth ) {
          
      if ( m_provider->msg().level() <= MSG::VERBOSE ) { 
    m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
      }
 
      const McEventCollection* mcevent = nullptr;
 
      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 ipc = 0; 
 
    int pid = HepMC::signal_process_id((*evitr));
 
    //The logic should be clarified here
    if ( pid!=0 ) { 
 
          // For HepMC2-based builds the following two functions return
          // GenEvent::particle_const_iterator
          // while for HepMC3-based builds they return
          // std::vector<HepMC3::ConstGenParticlePtr>::const_iterator
          // see AtlasHepMC/GenEvent.h for function definitions.
          auto pitr(HepMC::begin(**evitr));
          const auto pend(HepMC::end(**evitr));
 
      while ( pitr!=pend ) {
 
        selectorTruth.selectTrack( *pitr++ );
 
        ++ipc;
                
      }
 
    }
    ++ie;
    ++evitr;
 
    if ( ipc>0 ) {
      //      m_provider->msg(MSG::VERBOSE) << "Found " << ie << "\tpid " << pid << "\t with " << ip << " TruthParticles (GenParticles)" << endmsg;
      ++ie_ip;
      ip += ipc;
    }
      }
 
      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; 
      }
      
    }
 
    if ( m_doOffline && !m_mcTruth) {
 
      for ( size_t it=0 ; it<m_offline_types.size() ; it++ ) {
    if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>( m_offline_types[it] ) ) {
      this->template selectTracks<xAOD::TrackParticleContainer>( pselectorRef, m_offline_types[it] );
      refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( m_offline_types[it] );
    }
    else { 
      m_provider->msg(MSG::WARNING) << "Offline tracks not found: " << m_offline_types[it] << endmsg;
    }
      }
      
    }
 
    std::unique_ptr<TrackAssociator> associator = m_associator->uclone();
 
    //    std::cout << "\tloop() loop over chains proper ..." << std::endl;
    for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
 
      // 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();
  
      // Not used left just 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);
      }
 
 
      unsigned decisiontype = TrigDefs::Physics;
    
      if ( !m_chainNames[ichain].passed() ) decisiontype = TrigDefs::includeFailedDecisions;
      //      if ( decisiontype==TrigDefs::requireDecision ) std::cout << "\tSUTT TrigDefs::requireDecision " << decisiontype << std::endl;
      //      if ( decisiontype==TrigDefs::Physics )         std::cout << "\tSUTT TrigDefs::Physics "         << decisiontype << std::endl;
 
      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);
     
 
      // tag and probe analysis processes multiple chains passed in the tag and probe tool at once so loop over vector of chains
      std::vector<std::string> chainNames ;
            
      if ( !m_tnp_flag ) {
    chainNames.push_back(m_chainNames[ichain].raw()) ;
      }
      else {
    chainNames.push_back(pTnP_tool->tag());
    chainNames.push_back(pTnP_tool->probe());
      }
 
      // loop over new chainNames vector but doing the same stuff
      for ( size_t i=0 ; i<chainNames.size() ; i++ ) {
 
    ChainString chainConfig = chainNames[i] ;
    std::string chainName   = chainConfig.head();
    
    eventp->addChain( chainNames[i] ); 
    
    TIDA::Chain& chain = eventp->back();
    
    if ( chainName == "" ) { 
 
      pselectorTest->clear();
    
 
      //      TIDARoiDescriptor roifs(true);
        
      // chain.addRoi( roifs );
 
      chain.addRoi( TIDARoiDescriptor(true) );
    
      if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>(key) ) {
        this->template selectTracks<xAOD::TrackParticleContainer>( pselectorTest, key );
        refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( key );
      }
 
      const std::vector<TIDA::Track*>& testtracks = pselectorTest->tracks();
 
      chain.back().addTracks(testtracks);
    
      if ( vtx_name!="" ) { 
      
 
        m_provider->msg(MSG::VERBOSE) << "\tFetch xAOD::VertexContainer with key " << vtx_name << endmsg;
 
        std::vector<TIDA::Vertex> tidavertices;
 
        if ( this->select( tidavertices, vtx_name ) ) chain.back().addVertices( tidavertices );  
      }
    
 
      //      if ( roiInfo ) delete roiInfo;
 
    }
    else {
      
      //std::string roi_key = m_chainNames[ichain].roi();
 
      std::string roi_key = chainConfig.roi();
    
      unsigned feature_type =TrigDefs::lastFeatureOfType;
 
      if ( roi_key!="" ) feature_type= TrigDefs::allFeaturesOfType;
      
      int leg = -1;
      
      if ( chainConfig.element()!="" ) { 
        leg = std::atoi(chainConfig.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; 
      
      for ( const TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection>& roi_info : rois ) {
 
        iroi++;
 
        if ( roi_key=="SuperRoi" && iroi>1 ) continue; 
    
        //    std::cout << "\troi: get link " << roi_key << " ..." << std::endl;
 
        const ElementLink<TrigRoiDescriptorCollection> roi_link = roi_info.link;
        if ( roi_key!="" && roi_link.dataID()!=rgex ) continue;
        if ( !roi_link.isValid() ) continue;
 
        const TrigRoiDescriptor* const* roiptr = roi_link.cptr();
 
        if ( roiptr == 0 ) continue;
        
        //    std::cout << "\troi: link deref ..." << *roiptr << std::endl;
 
        if (m_provider->msg().level() <= MSG::VERBOSE) {
          m_provider->msg(MSG::VERBOSE) << " RoI descriptor for seeded chain " << chainname << " " << **roiptr << endmsg;
        }
     
        TIDARoiDescriptor* roiInfo = new TIDARoiDescriptor( TIDARoiDescriptorBuilder(**roiptr) );
     
        //    if ( dbg ) std::cout << "\troi " << iroi << " " << *roiInfo << std::endl;
 
        pselectorTest->clear();
 
        if ( this->template selectTracks<xAOD::TrackParticleContainer>( pselectorTest, roi_link,  key ) ) { } 
 
        // beamspot stuff not needed for xAOD::TrackParticles
 
        chain.addRoi( *roiInfo );
    
 
        const std::vector<TIDA::Track*>& testtracks = pselectorTest->tracks();
 
        chain.back().addTracks(testtracks);
    
      
        if ( vtx_name!="" ) { 
 
          std::vector<TIDA::Vertex> tidavertices;
 
          this->select( tidavertices, roi_link, vtx_name );
 
          chain.back().addVertices( tidavertices );
        
        } 
      
 
#if 0
        if ( dbg ) { 
          std::cout << "\tTIDA analysis for chain: " << chainname << "\t key: " << key << "\t" << **roiptr << std::endl;
          std::cout << "\tcollections: " << chain.back() << std::endl; 
        }
#endif
      
        delete roiInfo;
      
      }
 
 
    } 
 
      } // end of loop chainNames vector loop
    
    
      if ( m_provider->msg().level() <= MSG::VERBOSE ) {
    m_provider->msg(MSG::VERBOSE) << "event: " << *eventp << endmsg;
      }
 
    }
 
    // close previous loop over chains and open new one
    
    for ( unsigned ichain=0 ; ichain<eventp->size() ; ichain++ ) {
      
      TIDA::Chain& chain = (*eventp)[ichain];
      ChainString chainConfig(chain.name());        
      const std::string&  vtx_name = chainConfig.vtx();
 
      // skip tag chains to avoid performing standard analysis on them (done for tnp at the same time as probes)
      if ( m_tnp_flag && chainConfig.extra().find("_tag")!=std::string::npos ) continue ;
      
      std::vector<TIDA::Roi*> rois ;
      
      if (m_tnp_flag) {
    // needs to be done AFTER retrieving offline tracks as pselectorRef passed as arguement, hence restructuring
    rois = pTnP_tool->GetRois( eventp->chains(), pselectorRef, &filterRef, m_invmass, m_invmass_obj );
      }
      else {
        rois.reserve( chain.size() );
        for ( size_t ir=0 ; ir<chain.size() ; ir++ ) {
      rois.push_back( &(chain.rois()[ir]) );
    }
      }
 
      // now loop over the rois (again)
 
      for ( unsigned iroi=0 ; iroi<rois.size() ; iroi++ ) {
 
    if ( this->filterOnRoi() ) { 
      filterRef.setRoi( &(rois.at(iroi)->roi() ) ); 
      filterRef.containtracks( m_containTracks ); 
    }
    else filterRef.setRoi( 0 );
    
    test_tracks.clear();
    
    // this block is before the track retrieval in the original, is it working the same here?
    
 
        if ( m_provider->msg().level() <= MSG::VERBOSE )
          m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
 
    if ( m_mcTruth ) {
      if ( this->filterOnRoi() )  filter_truth.setRoi( &(rois.at(iroi)->roi() ) );
      ref_tracks = pselectorRef->tracks(&filter_truth);
    }
    else { // ie. if ( m_doOffline )
      ref_tracks = pselectorRef->tracks(&filterRef) ; 
    }
    
    if ( m_provider->msg().level() <= MSG::VERBOSE ) {
      m_provider->msg(MSG::VERBOSE) << "ref tracks.size() " << pselectorRef->tracks().size() << endmsg;
      for ( int ii=pselectorRef->tracks().size() ; ii-- ; ) {
        m_provider->msg(MSG::VERBOSE) << "  ref track " << ii << " " << *pselectorRef->tracks()[ii] << endmsg;
      }
    }
 
        test_tracks.clear();
 
 
        for ( unsigned itrk=0 ; itrk<rois.at(iroi)->tracks().size() ; itrk++ ) {
          test_tracks.push_back(&(rois.at(iroi)->tracks().at(itrk)));
        }   
    
    //  std::cout << "sutt track multiplicities: offline " << offline_tracks.size() << "\ttest " << test_tracks.size() << std::endl;
    
    beamline[0] = pselectorTest->getBeamX();
    beamline[1] = pselectorTest->getBeamY();
    beamline[2] = pselectorTest->getBeamZ();
 
    beamline[3] = vertices.size();
    //  m_manalysis->setvertices( vertices.size() );  /// what is this for ??? /// is this thread safe ??? 
 
    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();
      associator->match( test_tracks, ref_tracks );
      
      m_manalysis->execute( test_tracks, ref_tracks, associator.get(), eventp, beamline );
 
    }
    else { 
      if ( this->getUseHighestPT() ) HighestPTOnly( ref_tracks );
      
      if ( m_pTthreshold>0 )         FilterPT( ref_tracks, m_pTthreshold );
      // if ( ref_tracks.size()==0 ) continue;
      m_NRois++;
      m_NRefTracks  += ref_tracks.size();
      m_NTestTracks += test_tracks.size();
      associator->match( ref_tracks, test_tracks );
    
      //      m_manalysis->setroi( &rois.at(iroi)->roi() );  
      m_manalysis->execute( ref_tracks, test_tracks, associator.get(), eventp, beamline, &(rois.at(iroi)->roi()) );
 
      if ( vtx_name!="" ) { 
        std::vector<TIDA::Vertex> vr = 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()] );
        }
 
        m_manalysis->execute_vtx( vtx, vtx_rec, eventp );
      }
 
    }
 
    if ( m_manalysis->debug() ) { 
      m_provider->msg(MSG::INFO) << "Missing track for " << m_chainNames[ichain]  
                     << "\trun "             << run_number 
                     << "\tevent "           << event_number 
                     << "\tlb "              << lumi_block << endmsg;     
    }
 
      }
 
    }
    
    //    delete associator;
 
    if ( m_provider->msg().level() <= MSG::VERBOSE ) {
      m_provider->msg(MSG::VERBOSE) << "\n\nEvent " << *eventp << endmsg;
    }
 
  }

◆ mcTruth()

bool T_AnalysisConfig< T >::mcTruth ( ) const

inlineinherited

Definition at line 215 of file T_AnalysisConfig.h.

215{ return m_mcTruth; }

◆ monTool()

template<typename T, typename A = AnalysisR3_Tier0>

ToolHandle< GenericMonitoringTool > * T_AnalysisConfigR3_Tier0< T, A >::monTool ( )

inline

Definition at line 218 of file T_AnalysisConfigR3_Tier0.h.

218{ return m_monTool; }

◆ name()

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

inlineinherited

Definition at line 189 of file T_AnalysisConfig.h.

189{return m_analysisInstanceName;}

T_AnalysisConfig< T >::m_analysisInstanceName

std::string m_analysisInstanceName

Definition T_AnalysisConfig.h:867

◆ 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 = "Electrons" )

inlineprotectedinherited

select offline electrons

Definition at line 654 of file T_AnalysisConfig.h.

                    {
 
    m_provider->msg(MSG::DEBUG) << "Fetching offline electrons: " << containerName << endmsg;
 
    selectorRef.clear();
 
    typedef xAOD::ElectronContainer     Container;
 
    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;
      good_electron = TIDA::isGoodOffline( *(*elec), selection, ETOffline );
 
      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 = "Muons" )

inlineprotectedinherited

select offlinqe muons

Definition at line 727 of file T_AnalysisConfig.h.

                    {
 
    typedef xAOD::MuonContainer     Container;
 
    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 ){
      if ( TIDA::isGoodOffline(*(*muon), selection, ETOffline ) ) selectorRef.selectTrack((*muon)->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle));
    }
 
 
    //    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 = "TauJets" )

inlineprotectedinherited

select offline taus

the previous version of the code ...

used the link to the Trk::Track

Definition at line 772 of file T_AnalysisConfig.h.

                 {
 
  typedef xAOD::TauJetContainer     Container;
 
  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 ) {
 
#   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
 
    bool good_tau = false;
    good_tau = TIDA::isGoodOffline( *(*tau), selection, requireNtracks, EtCutOffline );
 
    //   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-- ; )  {
 
        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());
    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 198 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 227 of file T_AnalysisConfig.h.

227{ return m_releaseData; }

T_AnalysisConfig< T >::m_releaseData

std::string m_releaseData

Definition T_AnalysisConfig.h:894

◆ requireDecision()

bool T_AnalysisConfig< T >::requireDecision ( ) const

inlineinherited

Definition at line 242 of file T_AnalysisConfig.h.

242{ return m_requireDecision; }

T_AnalysisConfig< T >::m_requireDecision

bool m_requireDecision

Definition T_AnalysisConfig.h:904

◆ 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 524 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 296 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 205 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 395 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 559 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_monTool()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::set_monTool ( ToolHandle< GenericMonitoringTool > * m )

inline

Definition at line 216 of file T_AnalysisConfigR3_Tier0.h.

216{ m_monTool=m; }

◆ setBeamX()

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

inlineinherited

Definition at line 217 of file T_AnalysisConfig.h.

217{ m_beamX=d; }

◆ setBeamY()

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

inlineinherited

Definition at line 218 of file T_AnalysisConfig.h.

218{ m_beamY=d; }

◆ setBeamZ()

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

inlineinherited

Definition at line 219 of file T_AnalysisConfig.h.

219{ m_beamZ=d; }

◆ setFilterOnRoi()

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

inlineinherited

Definition at line 239 of file T_AnalysisConfig.h.

239{ return m_filterOnRoi=b; }

◆ setGenericFlag()

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

inlineinherited

Definition at line 225 of file T_AnalysisConfig.h.

225{ m_genericFlag=b; }

◆ setMCTruth()

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

inlineinherited

Definition at line 214 of file T_AnalysisConfig.h.

214{ m_mcTruth=b; }

◆ setMCTruthRef()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::setMCTruthRef ( bool b )

inline

Definition at line 210 of file T_AnalysisConfigR3_Tier0.h.

210{ m_mcTruth=b; }

◆ setOfflineRef()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::setOfflineRef ( bool b )

inline

Definition at line 212 of file T_AnalysisConfigR3_Tier0.h.

212{ m_doOffline=b; }

◆ setParentPdgID()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::setParentPdgID ( int i = 0 )

inline

Definition at line 208 of file T_AnalysisConfigR3_Tier0.h.

208{ m_parent_pdgID=i; }

◆ setPdgID()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::setPdgID ( int i = 0 )

inline

Definition at line 206 of file T_AnalysisConfigR3_Tier0.h.

206{ m_pdgID=i; }

◆ setRequireDecision()

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

inlineinherited

Definition at line 241 of file T_AnalysisConfig.h.

241{ m_requireDecision=b; }

◆ setRunPurity()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::setRunPurity ( bool b )

inline

Definition at line 198 of file T_AnalysisConfigR3_Tier0.h.

198{ m_runPurity=b; }

◆ setShifter()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::setShifter ( bool b )

inline

Definition at line 200 of file T_AnalysisConfigR3_Tier0.h.

200{ m_shifter=b; }

◆ setTypes()

template<typename T, typename A = AnalysisR3_Tier0>

void T_AnalysisConfigR3_Tier0< T, A >::setTypes ( const std::vector< std::string > & t )

inline

Definition at line 214 of file T_AnalysisConfigR3_Tier0.h.

214{ m_types=t; }

◆ setUseHighestPT()

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

inlineinherited

Definition at line 232 of file T_AnalysisConfig.h.

232{ m_useHighestPT=b; }

◆ setVtxIndex()

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

inlineinherited

Definition at line 235 of file T_AnalysisConfig.h.

235{ m_vtxIndex=i; }

◆ testChains()

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

inlineinherited

Definition at line 191 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;
  }