#include <TagNProbe.h>

Collaboration diagram for TagNProbe:

Public Member Functions
	TagNProbe (const std::string &refName, double massMin, double massMax, bool unique_flag=true)
	TagNProbe (const std::string &refName0, const std::string &refName1, double massMin, double massMax, bool unique_flag=true)
virtual	~TagNProbe ()
void	construct ()
void	tag (const std::string &chainName)
	getters and setters
void	probe (const std::string &chainName)
const std::string &	tag () const
const std::string &	probe () const
const std::string &	type0 () const
const std::string &	type1 () const
double	mass0 () const
double	mass1 () const
template<typename T>
std::vector< TIDA::Roi * >	GetRois (std::vector< TIDA::Chain > &chains, const TrackSelector selector, TrackFilter filter, T hmass, T hmass_obj, TrigObjectMatcher *tom=0) const
template<typename T>
std::vector< TIDA::Roi * >	GetRois (std::vector< TIDA::Chain > &chains, const TrackSelector selector_tag, TrackFilter filter_tag, const TrackSelector selector_probe, TrackFilter filter_probe, T hmass, T hmass_obj, TrigObjectMatcher tom_tag=0, TrigObjectMatcher tom_probe=0) const

Protected Member Functions
double	pt (const TIDA::Track *t) const
double	pt (const TrackTrigObject *t) const
template<typename T1, typename T2>
double	mass (const T1 t1, const T2 t2) const
template<typename T>
bool	selection (const TIDA::Roi &troi, const TIDA::Roi &proi, const TrackSelector selector, TrackFilter filter, T hmass, T hmass_obj, TrigObjectMatcher *tom=0) const
template<typename T>
bool	selection (const TIDA::Roi &troi, const TIDA::Roi &proi, const TrackSelector selector_tag, TrackFilter filter_tag, const TrackSelector selector_probe, TrackFilter filter_probe, T hmass, T hmass_obj, TrigObjectMatcher tom_tag=0, TrigObjectMatcher tom_probe=0) const
double	mass_obj (const TIDA::Track t1, const TIDA::Track t2, TrigObjectMatcher *tom=0) const
double	mass_obj (const TIDA::Track t1, const TIDA::Track t2, TrigObjectMatcher tom_tag, TrigObjectMatcher tom_probe) const
TIDA::Chain *	findChain (const std::string &chainname, std::vector< TIDA::Chain > &chains) const

Private Attributes
std::string	m_particleType0
std::string	m_particleType1
double	m_mass0
double	m_mass1
double	m_massMin
double	m_massMax
bool	m_unique
std::string	m_probeChainName
std::string	m_tagChainName

Detailed Description

Definition at line 28 of file TagNProbe.h.

Constructor & Destructor Documentation

◆ TagNProbe() [1/2]

TagNProbe::TagNProbe	(	const std::string &	refName,
		double	massMin,
		double	massMax,
		bool	unique_flag = true )

Definition at line 34 of file TagNProbe.cxx.

                                                                 :
  m_particleType0(refName),
  m_particleType1(refName),
  m_mass0(0),
  m_mass1(0),
  m_massMin(massMin),
  m_massMax(massMax),
  m_unique(unique_flag)
{
  construct();
}

◆ TagNProbe() [2/2]

TagNProbe::TagNProbe	(	const std::string &	refName0,
		const std::string &	refName1,
		double	massMin,
		double	massMax,
		bool	unique_flag = true )

Definition at line 20 of file TagNProbe.cxx.

                                                                 :
  m_particleType0(refName0),
  m_particleType1(refName1),
  m_mass0(0),
  m_mass1(0),
  m_massMin(massMin),
  m_massMax(massMax),
  m_unique(unique_flag)
{
  construct();
}

◆ ~TagNProbe()

virtual TagNProbe::~TagNProbe ( )

inlinevirtual

Definition at line 36 of file TagNProbe.h.

36{ }

Member Function Documentation

◆ construct()

void TagNProbe::construct ( )

Definition at line 48 of file TagNProbe.cxx.

                          {
 
 
#ifdef TRUTHUTILS_PARTICLECONSTANTS_H  
  const double muonMass     = ParticleConstants::muonMassInMeV/1000.; // Convert MeV to GeV
  const double electronMass = ParticleConstants::electronMassInMeV/1000.; // Convert MeV to GeV
  const double tauMass      = ParticleConstants::tauMassInMeV/1000.; // Convert MeV to GeV  NB: mass in ParticleConstants is wrong
#else
  const double muonMass     = 0.10565;  // GeV
  const double electronMass = 0.000511; // GeV
  const double tauMass      = 1.77686;  // GeV
#endif
  
  if      ( m_particleType0.find("Muon")!=std::string::npos )      m_mass0 = muonMass;
  else if ( m_particleType0.find("Electron")!=std::string::npos )  m_mass0 = electronMass;
  else if ( m_particleType0.find("Tau")!=std::string::npos )       m_mass0 = tauMass;
 
  if      ( m_particleType1.find("Muon")!=std::string::npos )      m_mass1 = muonMass;
  else if ( m_particleType1.find("Electron")!=std::string::npos )  m_mass1 = electronMass;
  else if ( m_particleType1.find("Tau")!=std::string::npos )       m_mass1 = tauMass;
}

◆ findChain()

TIDA::Chain * TagNProbe::findChain	(	const std::string &	chainname,
		std::vector< TIDA::Chain > &	chains ) const

protected

Definition at line 106 of file TagNProbe.cxx.

                                                                                                {
  for ( size_t i=chains.size() ; i-- ; ) {
    if ( chains[i].name() == chainname ) return &chains[i];
  }
  return 0;
}

◆ GetRois() [1/2]

template<typename T>

std::vector< TIDA::Roi * > TagNProbe::GetRois	(	std::vector< TIDA::Chain > &	chains,
		const TrackSelector *	selector,
		TrackFilter *	filter,
		T *	hmass,
		T *	hmass_obj,
		TrigObjectMatcher *	tom = 0 ) const

inline

Definition at line 60 of file TagNProbe.h.

                                                    {  
    return GetRois( chains, selector, filter, selector, filter, hmass, hmass_obj, tom, tom );
  }

◆ GetRois() [2/2]

template<typename T>

std::vector< TIDA::Roi * > TagNProbe::GetRois	(	std::vector< TIDA::Chain > &	chains,
		const TrackSelector *	selector_tag,
		TrackFilter *	filter_tag,
		const TrackSelector *	selector_probe,
		TrackFilter *	filter_probe,
		T *	hmass,
		T *	hmass_obj,
		TrigObjectMatcher *	tom_tag = 0,
		TrigObjectMatcher *	tom_probe = 0 ) const

inline

tag and probe are the same: skip this tag

Definition at line 70 of file TagNProbe.h.

                                                          {  
 
    std::vector<TIDA::Roi*> probes;
 
    TIDA::Chain* chain_tag   = findChain( tag(), chains ); 
    TIDA::Chain* chain_probe = findChain( probe(), chains ); 
 
    if ( chain_tag==0 || chain_probe==0 ) return probes;
 
    // loop for possible probes
    for ( size_t ip=0 ; ip<chain_probe->size() ; ip++ ) {
      
      TIDA::Roi& proi = chain_probe->rois()[ip];
    
      TIDARoiDescriptor roi_probe( proi.roi() );
 
      bool found_tnp = false;
 
      // loop for possible tags
      for ( size_t it=0 ; it<chain_tag->size() ; it++ ) {  
    
    TIDA::Roi& troi = chain_tag->rois()[it];
    TIDARoiDescriptor roi_tag( troi.roi() );
    if ( roi_probe == roi_tag ) continue;
    
    if ( selection( troi, proi, selector_tag, filter_tag, selector_probe, filter_probe, 
            hmass, hmass_obj, tom_tag, tom_probe ) ) { 
 
      found_tnp = true;
      if ( m_unique ) break;
    }
    
      } // end loop on tags
      
      if ( found_tnp ) probes.push_back( &proi );
 
    } // end loop on probes
    
    return probes;
    
  }

◆ mass()

template<typename T1, typename T2>

double TagNProbe::mass	(	const T1 *	t1,
		const T2 *	t2 ) const

inlineprotected

Definition at line 128 of file TagNProbe.h.

                                                  {
    TLorentzVector v1;
    v1.SetPtEtaPhiM( pt(t1)*0.001, t1->eta(), t1->phi(), m_mass0 );
    TLorentzVector v2;
    v2.SetPtEtaPhiM( pt(t2)*0.001, t2->eta(), t2->phi(), m_mass1 );
    return (v1+v2).M();
  }

◆ mass0()

double TagNProbe::mass0 ( ) const

inline

Definition at line 54 of file TagNProbe.h.

54{ return m_mass0; };

◆ mass1()

double TagNProbe::mass1 ( ) const

inline

Definition at line 55 of file TagNProbe.h.

55{ return m_mass1; };

◆ mass_obj() [1/2]

double TagNProbe::mass_obj	(	const TIDA::Track *	t1,
		const TIDA::Track *	t2,
		TrigObjectMatcher *	tom = 0 ) const

protected

Definition at line 72 of file TagNProbe.cxx.

                                                                                                   {
 
  if ( tom!=0 && tom->status() ) { 
    return mass( tom->object(t1->id()), tom->object(t2->id()) );
  }
  else {
    return mass( t1, t2 );
  }
  
}

◆ mass_obj() [2/2]

double TagNProbe::mass_obj	(	const TIDA::Track *	t1,
		const TIDA::Track *	t2,
		TrigObjectMatcher *	tom_tag,
		TrigObjectMatcher *	tom_probe ) const

protected

different toms for each leg - eg if we wanted electron + tau

only tag tom ...

only probe tom ...

just tracks ...

Definition at line 84 of file TagNProbe.cxx.

                                                                                                                                     {
 
  if ( tom_tag!=0 && tom_tag->status() && tom_probe!=0 && tom_probe->status() ) {
    return mass( tom_tag->object(t1->id()), tom_probe->object(t2->id()) );
  }
  else if ( tom_tag!=0 && tom_tag->status() ) { 
    return mass( tom_tag->object(t1->id()), t2 );
  }
  else if ( tom_probe!=0 && tom_probe->status() ) {
    return mass( t1, tom_probe->object(t2->id()) );
  }
  else {
    return mass( t1, t2 );
  }
  
}

◆ probe() [1/2]

const std::string & TagNProbe::probe ( ) const

inline

Definition at line 49 of file TagNProbe.h.

49{ return m_probeChainName; }

TagNProbe::m_probeChainName

std::string m_probeChainName

Definition TagNProbe.h:218

◆ probe() [2/2]

void TagNProbe::probe ( const std::string & chainName )

inline

Definition at line 46 of file TagNProbe.h.

46{ m_probeChainName = chainName; }

◆ pt() [1/2]

double TagNProbe::pt ( const TIDA::Track * t ) const

inlineprotected

Definition at line 124 of file TagNProbe.h.

124{ return t->pT(); }

read_hist_ntuple.t

t

Definition read_hist_ntuple.py:5

◆ pt() [2/2]

double TagNProbe::pt ( const TrackTrigObject * t ) const

inlineprotected

Definition at line 125 of file TagNProbe.h.

125{ return t->pt(); }

◆ selection() [1/2]

template<typename T>

bool TagNProbe::selection	(	const TIDA::Roi &	troi,
		const TIDA::Roi &	proi,
		const TrackSelector *	selector,
		TrackFilter *	filter,
		T *	hmass,
		T *	hmass_obj,
		TrigObjectMatcher *	tom = 0 ) const

inlineprotected

Definition at line 138 of file TagNProbe.h.

                                           {
    return selection( troi, proi, selector, filter, selector, filter, hmass, hmass_obj, tom, tom ); 
  }

◆ selection() [2/2]

template<typename T>

bool TagNProbe::selection	(	const TIDA::Roi &	troi,
		const TIDA::Roi &	proi,
		const TrackSelector *	selector_tag,
		TrackFilter *	filter_tag,
		const TrackSelector *	selector_probe,
		TrackFilter *	filter_probe,
		T *	hmass,
		T *	hmass_obj,
		TrigObjectMatcher *	tom_tag = 0,
		TrigObjectMatcher *	tom_probe = 0 ) const

inlineprotected

get reference tracks from the tag roi

get reference tracks from the probe roi

loop over tag ref tracks

loop over probe ref tracks

check compatibility of the track z and invariant mass ...

Definition at line 148 of file TagNProbe.h.

                                                 {
  
    TIDARoiDescriptor roi_tag( troi.roi() );
  
    dynamic_cast<Filter_Combined*>(filter_tag)->setRoi( &roi_tag );
 
    std::vector<TIDA::Track*> refp_tag = selector_tag->tracks( filter_tag );
                                                                                                                                                                     
    TIDARoiDescriptor roi_probe( proi.roi() );
 
    dynamic_cast<Filter_Combined* >( filter_probe )->setRoi( &roi_probe );
 
    std::vector<TIDA::Track*> refp_probe = selector_probe->tracks( filter_probe );
    bool found = false;
 
    for ( size_t it=0; it<refp_tag.size() ; it++ ) {
      for ( size_t ip=0; ip<refp_probe.size() ; ip++ ) {
    double invmass     = mass( refp_tag[it], refp_probe[ip] );
    double invmass_obj = mass_obj( refp_tag[it], refp_probe[ip], tom_tag, tom_probe  );
    double deltaz0     = std::fabs(refp_tag[it]->z0() - refp_probe[ip]->z0() );
    
    if ( invmass_obj>m_massMin && invmass_obj<m_massMax && deltaz0<5 ) {
      hmass->Fill( invmass );
      hmass_obj->Fill( invmass_obj );
      found = true;
    }
      }
    }
    
    return found;
 
  }

◆ tag() [1/2]

const std::string & TagNProbe::tag ( ) const

inline

Definition at line 48 of file TagNProbe.h.

48{ return m_tagChainName; }

TagNProbe::m_tagChainName

std::string m_tagChainName

Definition TagNProbe.h:219

◆ tag() [2/2]

void TagNProbe::tag ( const std::string & chainName )

inline

getters and setters

could be moved to the constructor now ...

Definition at line 45 of file TagNProbe.h.

45{ m_tagChainName = chainName; }

◆ type0()

const std::string & TagNProbe::type0 ( ) const

inline

Definition at line 51 of file TagNProbe.h.

51{ return m_particleType0; };

◆ type1()

const std::string & TagNProbe::type1 ( ) const

inline

Definition at line 52 of file TagNProbe.h.

52{ return m_particleType1; };

Member Data Documentation

◆ m_mass0

double TagNProbe::m_mass0

private

Definition at line 210 of file TagNProbe.h.

◆ m_mass1

double TagNProbe::m_mass1

private

Definition at line 211 of file TagNProbe.h.

◆ m_massMax

double TagNProbe::m_massMax

private

Definition at line 214 of file TagNProbe.h.

◆ m_massMin

double TagNProbe::m_massMin

private

Definition at line 213 of file TagNProbe.h.

◆ m_particleType0

std::string TagNProbe::m_particleType0

private

Definition at line 207 of file TagNProbe.h.

◆ m_particleType1

std::string TagNProbe::m_particleType1

private

Definition at line 208 of file TagNProbe.h.

◆ m_probeChainName

std::string TagNProbe::m_probeChainName

private

Definition at line 218 of file TagNProbe.h.

◆ m_tagChainName

std::string TagNProbe::m_tagChainName

private

Definition at line 219 of file TagNProbe.h.

◆ m_unique

bool TagNProbe::m_unique

private

Definition at line 216 of file TagNProbe.h.

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

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TagNProbe() [1/2]

◆ TagNProbe() [2/2]

◆ ~TagNProbe()

Member Function Documentation

◆ construct()

◆ findChain()

◆ GetRois() [1/2]

◆ GetRois() [2/2]

◆ mass()

◆ mass0()

◆ mass1()

◆ mass_obj() [1/2]

◆ mass_obj() [2/2]

◆ probe() [1/2]

◆ probe() [2/2]

◆ pt() [1/2]

◆ pt() [2/2]

◆ selection() [1/2]

◆ selection() [2/2]

◆ tag() [1/2]

◆ tag() [2/2]

◆ type0()

◆ type1()

Member Data Documentation

◆ m_mass0

◆ m_mass1

◆ m_massMax

◆ m_massMin

◆ m_particleType0

◆ m_particleType1

◆ m_probeChainName

◆ m_tagChainName

◆ m_unique