jet Namespace Reference

Namespaces
	CombMassComp
	CompCategory
	CompCorrelation
	CompFlavorLabelVar
	CompMassDef
	CompParametrization
	CompScaleVar
	CompTaggerRegionVar
	ExtendedBool
	FlavourComp
	Interpolate
	JetDistances
	JetIsolation
	JetTopology
	PileupComp
	utils

Classes
struct	AccessorAndHisto
struct	AccessorAndHisto2
struct	AttFiller
struct	AttTypes
struct	AttvsAttFiller
struct	AttvsVecAttIndexFiller
class	BaseIndexedConstituentUserInfo
class	CaloCellFastMap
class	CellPosition
class	ClosebyUncertaintyComponent
class	CombinedMassUncertaintyComponent
class	ComponentHelper
class	ConfigHelper
class	CorrelationMatrix
class	ELogMassEtaUncertaintyComponent
class	ELogMassUncertaintyComponent
class	FlavourUncertaintyComponent
class	GroupHelper
class	HistoFiller
class	IConstituentUserInfo
class	IndexedConstituentUserInfo
class	IndexedTConstituentUserInfo
class	InfoHelper
class	InfoHelpereLOGmOe
class	InfoHelpereLOGmOeAbsEta
class	InfoHelpereLOGmOeEta
class	InfoHelperPt
class	InfoHelperPtAbsEta
class	InfoHelperPtAbsMass
class	InfoHelperPtAbsMassAbsEta
class	InfoHelperPtAbsMassEta
class	InfoHelperPtEta
class	InfoHelperPtMass
class	InfoHelperPtMassAbsEta
class	InfoHelperPtMassEta
class	JetCalcAverageLArQualityF
class	JetCalcBadCellsFrac
	Fraction of Bad energy in jet. From cluster moment ENG_BAD_CELLS. More...
class	JetCalcCentroid
class	JetCalcNegativeEnergy
class	JetCalcnLeadingCells
class	JetCalcOutOfTimeEnergyFraction
class	JetCalcQuality
class	JetCalcQualityHEC
class	JetCalcTimeCells
class	JetCaloCalculations
	Holds a list of JetCalculators. More...
class	JetCaloCalculator
class	JetCaloCellCalculations
	collection of JetCaloCellCalculator More...
class	JetCaloCellCalculator
	Base class (inheriting JetCaloCalculator) for calculations accessing CaloCell directly. More...
class	JetCaloQualityUtils
class	JetCellAccessor
class	JetConstituentFiller
class	JetFourMomAccessor
	JetFourMomAccessor is an extension of JetAttributeAccessor::AccessorWrapper<xAOD::JetFourMom_t> AccessorWrapper<xAOD::JetFourMom_t> purpose is to provide a direct and simple access to JetFourMom_t attributes (which are internally saved as 4 floats inside jets). More...
class	LabelIndex
class	LargeRTopologyUncertaintyComponent
class	OptionHelper
class	ParticlePosition
class	PerJetFlavourUncertaintyComponent
class	PileupUncertaintyComponent
class	PtAbsMassEtaUncertaintyComponent
class	PtAbsMassUncertaintyComponent
class	PtEtaUncertaintyComponent
class	PtLogPtMassForTagSFUncertaintyComponent
class	PtMassEtaUncertaintyComponent
class	PtMassUncertaintyComponent
class	PtUncertaintyComponent
class	PunchthroughUncertaintyComponent
class	ResolutionHelper
class	SimpleConstituentUserInfo
class	TrackVertexAssociation
	Class to hold N-to-one aassociations between tracks and vertices. More...
class	UncertaintyComponent
class	UncertaintyGroup
class	UncertaintyHistogram
class	UncertaintySet
class	ValidityHistogram
struct	VecAttFiller
struct	VecAttIndexFiller
class	VertexIndexedConstituentUserInfo

Typedefs
typedef fastjet::ClusterSequence	ClusterSequence
typedef std::map< const xAOD::Jet *, const fastjet::PseudoJet * >	PseudoJetMap
typedef std::vector< fastjet::PseudoJet >	PseudoJetVector
template<typename T >
using	Accessor = SG::AuxElement::Accessor< T >
typedef std::unordered_set< Identifier >	cellset_t

Functions
void	colonSplit (const string &in, string &s1, string &s2, string &s3)
	helper More...
bool	isConstituent (const xAOD::IParticle *p, const xAOD::Jet *j)
bool	operator< (const UncertaintyComponent &componentA, const UncertaintyComponent &componentB)
bool	operator== (const UncertaintyComponent &componentA, const UncertaintyComponent &componentB)
bool	operator< (const UncertaintyGroup &groupA, const UncertaintyGroup &groupB)
bool	operator== (const UncertaintyGroup &groupA, const UncertaintyGroup &groupB)
	DECLARECELLCALC (JetCalcnLeadingCells, JetCalcnLeadingCells_fromCells, m_id=JetAttribute::N90Cells;)
	DECLARECELLCALC (JetCalcOutOfTimeEnergyFraction, JetCalcOutOfTimeEnergyFraction_fromCells,)
	DECLARECELLCALC (JetCalcTimeCells, JetCalcTimeCells_fromCells,)
	DECLARECELLCALC (JetCalcAverageLArQualityF, JetCalcAverageLArQualityF_fromCells,)
	DECLARECELLCALC (JetCalcQualityHEC, JetCalcQualityHEC_fromCells,)
	DECLARECELLCALC (JetCalcQuality, JetCalcQuality_fromCells,)
	DECLARECELLCALC (JetCalcNegativeEnergy, JetCalcNegativeEnergy_fromCells,)
	DECLARECELLCALC (JetCalcCentroid, JetCalcCentroid_fromCells,)
xAOD::JetFourMom_t	clusterOriginCorrection (const xAOD::Jet &jet, const xAOD::Vertex &vx)
	returns 4-vector of the jet relative to the vertex More...
xAOD::JetFourMom_t	clusterOriginCorrection (const xAOD::Jet &jet, const xAOD::Vertex &vx, const xAOD::CaloCluster::State state=xAOD::CaloCluster::UNKNOWN)
bool	timeAndQualityDefined (const CaloCell *theCell)

Typedef Documentation

Accessor

template<typename T >

using jet::Accessor = typedef SG::AuxElement::Accessor< T >

Definition at line 10 of file JetAttributeHisto.cxx.

cellset_t

typedef std::unordered_set<Identifier> jet::cellset_t

Definition at line 86 of file MissingCellListTool.h.

ClusterSequence

typedef fastjet::ClusterSequence jet::ClusterSequence

Definition at line 21 of file ClusterSequence.h.

PseudoJetMap

typedef std::map<const xAOD::Jet*, const fastjet::PseudoJet*> jet::PseudoJetMap

Definition at line 22 of file PseudoJetMap.h.

PseudoJetVector

typedef std::vector<fastjet::PseudoJet> jet::PseudoJetVector

Definition at line 21 of file PseudoJetVector.h.

Function Documentation

clusterOriginCorrection() [1/2]

xAOD::JetFourMom_t jet::clusterOriginCorrection	(	const xAOD::Jet &	jet,
		const xAOD::Vertex &	vx
	)

returns 4-vector of the jet relative to the vertex

Parameters

jet	the Jet
vx	the Vertex relative to which to compute the returned 4-vector

Returns

4-vector corrected w.r.t vx

The cluster constituents of jet are retrieved, set at the scale they were used to find jet, corrected according to vx. The 4-vector sum of this corrected cluster is returned

clusterOriginCorrection() [2/2]

xAOD::JetFourMom_t jet::clusterOriginCorrection	(	const xAOD::Jet &	jet,
		const xAOD::Vertex &	vx,
		const xAOD::CaloCluster::State	state = xAOD::CaloCluster::UNKNOWN
	)

Definition at line 12 of file JetOriginHelpers.cxx.

                                                                                                                       {
    
 
    xAOD::CaloCluster::State constitScale = state;
    if(constitScale==xAOD::CaloCluster::UNKNOWN) constitScale = (xAOD::CaloCluster::State) jet.getConstituentsSignalState();
 
    int numC = jet.numConstituents();
    const Amg::Vector3D& vxpos= vx.position();
 
    xAOD::IParticle::FourMom_t corrP4(0,0,0,0);
 
    for(int i=0; i<numC;i++){
      const xAOD::CaloCluster* cl = dynamic_cast<const xAOD::CaloCluster*>(jet.rawConstituent(i) );
      if( ! cl ) continue;
 
      xAOD::CaloVertexedTopoCluster corrCl(*cl, constitScale, vxpos );
      xAOD::IParticle::FourMom_t p4CorrCl=corrCl.p4();
      if(cl->e(constitScale) < 0.) p4CorrCl*=-1.;
      corrP4 += p4CorrCl;   
    }
    
    xAOD::JetFourMom_t corrJet;
    corrJet.SetPxPyPzE(corrP4.Px(), corrP4.Py(), corrP4.Pz(), corrP4.E() );
    return corrJet;
    
  }

colonSplit()

void jet::colonSplit	(	const string &	in,
		string &	s1,
		string &	s2,
		string &	s3
	)

helper

Definition at line 221 of file JetIsolationTool.cxx.

                                                                       {
    s2=""; s3="";
    std::stringstream str(in);
    std::getline(str, s1, ':' );
    std::getline(str, s2, ':');
    std::getline(str, s3);
  }

DECLARECELLCALC() [1/8]

jet::DECLARECELLCALC	(	JetCalcAverageLArQualityF	,
		JetCalcAverageLArQualityF_fromCells
	)

DECLARECELLCALC() [2/8]

jet::DECLARECELLCALC	(	JetCalcCentroid	,
		JetCalcCentroid_fromCells
	)

DECLARECELLCALC() [3/8]

jet::DECLARECELLCALC	(	JetCalcNegativeEnergy	,
		JetCalcNegativeEnergy_fromCells
	)

DECLARECELLCALC() [4/8]

jet::DECLARECELLCALC	(	JetCalcnLeadingCells	,
		JetCalcnLeadingCells_fromCells	,
		m_id	= JetAttribute::N90Cells;
	)

DECLARECELLCALC() [5/8]

jet::DECLARECELLCALC	(	JetCalcOutOfTimeEnergyFraction	,
		JetCalcOutOfTimeEnergyFraction_fromCells
	)

DECLARECELLCALC() [6/8]

jet::DECLARECELLCALC	(	JetCalcQuality	,
		JetCalcQuality_fromCells
	)

DECLARECELLCALC() [7/8]

jet::DECLARECELLCALC	(	JetCalcQualityHEC	,
		JetCalcQualityHEC_fromCells
	)

DECLARECELLCALC() [8/8]

jet::DECLARECELLCALC	(	JetCalcTimeCells	,
		JetCalcTimeCells_fromCells
	)

isConstituent()

bool jet::isConstituent	(	const xAOD::IParticle *	p,
		const xAOD::Jet *	j
	)

Definition at line 230 of file JetIsolationTool.cxx.

                                                             {
    // just need raw constituents.
    for(size_t i = 0;i<j->numConstituents();i++){
      if( p == j->rawConstituent(i) ) return true;
    }
    return false;
  }

operator<() [1/2]

bool jet::operator<	(	const UncertaintyComponent &	componentA,
		const UncertaintyComponent &	componentB
	)

Definition at line 13 of file UncertaintyComponent.cxx.

{
    return componentA.getName() < componentB.getName();
}

operator<() [2/2]

bool jet::operator<	(	const UncertaintyGroup &	groupA,
		const UncertaintyGroup &	groupB
	)

Definition at line 13 of file UncertaintyGroup.cxx.

{
    return groupA.getName() < groupB.getName();
}

operator==() [1/2]

bool jet::operator==	(	const UncertaintyComponent &	componentA,
		const UncertaintyComponent &	componentB
	)

Definition at line 18 of file UncertaintyComponent.cxx.

{
    return componentA.getName() == componentB.getName();
}

operator==() [2/2]

bool jet::operator==	(	const UncertaintyGroup &	groupA,
		const UncertaintyGroup &	groupB
	)

Definition at line 18 of file UncertaintyGroup.cxx.

{
    return groupA.getName() == groupB.getName();
}

timeAndQualityDefined()

bool jet::timeAndQualityDefined

(

const CaloCell *

theCell

)

Definition at line 84 of file JetCaloCellQualityUtils.cxx.

                                                     {
    // ensure timing information is defined
    bool timeIsDefined(false);
    if(theCell->caloDDE()->is_tile())     
      {
        if ( (theCell->provenance()) & 0x8080)
          timeIsDefined = true;
      }
    else //is_lar
      {
        if ( (theCell->provenance() & 0x2000) &&
             !(theCell->provenance()  & 0x0800 ) // do not take masked-patched cells int
             )         timeIsDefined = true;
      }
    return timeIsDefined;
  }