Namespaces
namespace	ClusterHelpers
namespace	ContainerId
	a namespace for holding the ids for the different "virtual" containers
namespace	Detail
namespace	detail
namespace	EgammaHelpers
namespace	EventInfoHelpers
namespace	MetDef
namespace	MetHelpers
namespace	TestUtils
namespace	TrackHelpers

Classes
class	AccessorTemplate
	the raw column accessor template class More...
class	AccessorTemplate< CI, CT, ColumnAccessMode::input, CM >
class	AccessorTemplate< CI, CT, ColumnAccessMode::output, CM >
class	AccessorTemplate< CI, ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeArray >, CAM, ColumnarModeArray >
class	AccessorTemplate< CI, std::vector< CT >, ColumnAccessMode::input, CM >
	a std::vector accessor for types that can be implemented via conversions More...
class	AccessorTemplate< CI, std::vector< CT >, ColumnAccessMode::input, ColumnarModeArray >
class	AccessorTemplate< CI, std::vector< ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeArray > >, ColumnAccessMode::input, ColumnarModeArray >
class	AccessorTemplate< CI, std::vector< std::vector< CT > >, ColumnAccessMode::input, ColumnarModeArray >
class	AccessorTemplate< VariantContainerId< CIBase, CIList... >, CT, CAM, ColumnarModeArray >
class	AccessorTemplate< VariantContainerId< CIBase, CIList... >, CT, CAM, ColumnarModeXAOD >
struct	ColumnAccessModeTraits
struct	ColumnAccessModeTraits< ColumnAccessMode::input >
struct	ColumnAccessModeTraits< ColumnAccessMode::output >
struct	ColumnAccessModeTraits< ColumnAccessMode::update >
struct	ColumnAccessorDataArray
	all the data about a column accessor that the ColumnarTool needs to know about More...
struct	ColumnarMemoryTest
struct	ColumnarModeArray
struct	ColumnarModeXAOD
struct	ColumnarPhysLiteTest
class	ColumnarTool
	the base class for all columnar components More...
struct	ColumnarToolDataArray
struct	ColumnDataArray
struct	ColumnInfo
	a struct that contains meta-information about each column that's needed to interface the column with the columnar data store More...
struct	ColumnTypeTraits
	a trait class to provide information about the column type More...
struct	ColumnTypeTraits< CT, CM >
struct	ColumnTypeTraits< LinkCastColumn< LT, ELT >, ColumnarModeArray >
struct	ColumnTypeTraits< LinkCastColumn< LT, ELT >, ColumnarModeXAOD >
struct	ColumnTypeTraits< LinkCastColumn< VariantContainerId< CIBase, CIList... >, ELT >, ColumnarModeArray >
struct	ColumnTypeTraits< NativeColumn< CT >, CM >
struct	ColumnTypeTraits< ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeXAOD >, ColumnarModeXAOD >
struct	ColumnTypeTraits< OptObjectId< LT >, ColumnarModeArray >
struct	ColumnTypeTraits< OptObjectId< LT >, ColumnarModeXAOD >
struct	ColumnTypeTraits< RetypeColumn< UT, CT >, CM >
struct	ColumnTypeTraits< std::string, ColumnarModeArray >
struct	ColumnTypeTraits< std::string, ColumnarModeXAOD >
struct	ColumnTypeTraits< std::vector< CT >, ColumnarModeXAOD >
class	ColumnVectorData
	a class that holds the columnar data for a single call More...
struct	ColumnVectorElementHeader
	the header information for a single element in the columnar data vector More...
class	ColumnVectorHeader
	the header information for the entire columnar data vector More...
class	ConfigurableColumnExampleTool
	example of a columnar tool with optional columns More...
class	FilterRange
	a simple range adaptor that filters the elements of a range More...
class	FilterRangeIterator
class	IColumnarTool
	an interface for tools that operate on columnar data More...
struct	LinkCastColumn
	a special column type that behaves like an OptObjectId, but applies an internal cast in xAOD mode More...
class	LinkColumnExampleTool
	an example of a tool reading an element link More...
class	MetAssocationAccessors
	the accessors MetAssociationHelper needs to implement its operations More...
class	MetAssociationHelper
	a columnar version of xAOD::MissingETAssociationHelper More...
class	ModularExampleTool
	an example of a columnar tool with a modular structure More...
class	MomentumAccessorExampleTool
	an example of a columnar tool that uses momentum accessors More...
class	MomentumAccessors
	a handle to hold a IMomentumAccessors object More...
struct	NativeColumn
	a type wrapper to force AccessorTemplate to treat the type as native More...
struct	ObjectColumn
	a special type to use for columns accessing containers/offset maps More...
class	ObjectId
	a class representing a single object (electron, muons, etc.) More...
class	ObjectId< CI, ColumnarModeArray >
class	ObjectId< CI, ColumnarModeXAOD >
class	ObjectId< VariantContainerId< CIList... >, ColumnarModeArray >
class	ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD >
class	ObjectLink
class	ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeArray >
class	ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeXAOD >
	a "variant" link to a single object
class	ObjectRange
	a class representing a continuous sequence of objects (a.k.a. a container) More...
class	ObjectRange< CI, ColumnarModeArray >
class	ObjectRange< CI, ColumnarModeXAOD >
class	ObjectRangeIteratorArray
	an iterator over objects in an ObjectRange More...
class	ObjectRangeIteratorXAODContainer
class	ObjectRangeIteratorXAODSinglet
class	ObjectTypeAccessor
	a specialized accessor for retrieving the xAOD object type of objects More...
class	OptionalColumnExampleTool
	example of a columnar tool with optional columns More...
class	OptObjectId
	a class representing a single optional object (electron, muons, etc.) More...
class	OptObjectId< CI, ColumnarModeArray >
class	OptObjectId< CI, ColumnarModeXAOD >
class	OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray >
class	OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD >
class	PythonToolHandle
	a handle to a python tool for use via nanobind More...
struct	RetypeColumn
	a type wrapper to make AccessorTemplate convert the underlying column type to a different type More...
class	SimpleSelectorExampleTool
	this is the simplest example of a columnar tool More...
class	StringExampleTool
	an example of a columnar tool that reads a vector column More...
class	ToolColumnVectorMap
	a class that interfaces an IColumnarTool to a ColumnVectorHeader More...
struct	VariantContainerId
	a "variant" ContainerId More...
class	VariantExampleTool
	an example of a columnar tool using "variant" object ids and column accessors More...
class	VectorExampleTool
	an example of a columnar tool that reads a vector column More...

Concepts
concept	ContainerIdConcept
	concept for a container id
concept	RegularContainerIdConcept

Typedefs
using	ClusterId = ObjectId<ContainerId::cluster>
using	OptClusterId = OptObjectId<ContainerId::cluster>
template<typename CT, typename CM = ColumnarModeDefault>
using	ClusterAccessor = AccessorTemplate<ContainerId::cluster,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	ClusterDecorator = AccessorTemplate<ContainerId::cluster,CT,ColumnAccessMode::output,CM>
template<ContainerIdConcept CI, typename CT, typename CM = ColumnarModeDefault>
using	ColumnAccessor = AccessorTemplate<CI,CT,ColumnAccessMode::input,CM>
template<ContainerIdConcept CI, typename CT, typename CM = ColumnarModeDefault>
using	ColumnDecorator = AccessorTemplate<CI,CT,ColumnAccessMode::output,CM>
template<ContainerIdConcept CI, typename CT, typename CM = ColumnarModeDefault>
using	ColumnUpdater = AccessorTemplate<CI,CT,ColumnAccessMode::update,CM>
using	ColumnarModeDefault = ColumnarModeXAOD
using	EventContextRange = ObjectRange<ContainerId::eventContext>
using	EventContextId = ObjectId<ContainerId::eventContext>
using	ParticleRange = ObjectRange<ContainerId::particle>
using	ParticleId = ObjectId<ContainerId::particle>
using	OptParticleId = OptObjectId<ContainerId::particle>
template<typename CT, typename CM = ColumnarModeDefault>
using	ParticleAccessor = AccessorTemplate<ContainerId::particle,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	ParticleDecorator = AccessorTemplate<ContainerId::particle,CT,ColumnAccessMode::output,CM>
using	Particle0Range = ObjectRange<ContainerId::particle0>
using	Particle0Id = ObjectId<ContainerId::particle0>
using	OptParticle0Id = OptObjectId<ContainerId::particle0>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle0Accessor = AccessorTemplate<ContainerId::particle0,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle0Decorator = AccessorTemplate<ContainerId::particle0,CT,ColumnAccessMode::output,CM>
using	Particle1Range = ObjectRange<ContainerId::particle1>
using	Particle1Id = ObjectId<ContainerId::particle1>
using	OptParticle1Id = OptObjectId<ContainerId::particle1>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle1Accessor = AccessorTemplate<ContainerId::particle1,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle1Decorator = AccessorTemplate<ContainerId::particle1,CT,ColumnAccessMode::output,CM>
using	Particle2Range = ObjectRange<ContainerId::particle2>
using	Particle2Id = ObjectId<ContainerId::particle2>
using	OptParticle2Id = OptObjectId<ContainerId::particle2>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle2Accessor = AccessorTemplate<ContainerId::particle2,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle2Decorator = AccessorTemplate<ContainerId::particle2,CT,ColumnAccessMode::output,CM>
using	ElectronRange = ObjectRange<ContainerId::electron>
using	ElectronId = ObjectId<ContainerId::electron>
using	OptElectronId = OptObjectId<ContainerId::electron>
template<typename CT, typename CM = ColumnarModeDefault>
using	ElectronAccessor = AccessorTemplate<ContainerId::electron,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	ElectronDecorator = AccessorTemplate<ContainerId::electron,CT,ColumnAccessMode::output,CM>
using	PhotonRange = ObjectRange<ContainerId::photon>
using	PhotonId = ObjectId<ContainerId::photon>
using	OptPhotonId = OptObjectId<ContainerId::photon>
template<typename CT, typename CM = ColumnarModeDefault>
using	PhotonAccessor = AccessorTemplate<ContainerId::photon,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	PhotonDecorator = AccessorTemplate<ContainerId::photon,CT,ColumnAccessMode::output,CM>
using	EgammaRange = ObjectRange<ContainerId::egamma>
using	EgammaId = ObjectId<ContainerId::egamma>
using	OptEgammaId = OptObjectId<ContainerId::egamma>
template<typename CT, typename CM = ColumnarModeDefault>
using	EgammaAccessor = AccessorTemplate<ContainerId::egamma,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	EgammaDecorator = AccessorTemplate<ContainerId::egamma,CT,ColumnAccessMode::output,CM>
using	MutableEgammaRange = ObjectRange<ContainerId::mutableEgamma>
using	MutableEgammaId = ObjectId<ContainerId::mutableEgamma>
using	OptMutableEgammaId = OptObjectId<ContainerId::mutableEgamma>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableEgammaAccessor = AccessorTemplate<ContainerId::mutableEgamma,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableEgammaDecorator = AccessorTemplate<ContainerId::mutableEgamma,CT,ColumnAccessMode::output,CM>
using	EventInfoRange = ObjectRange<ContainerId::eventInfo>
using	EventInfoId = ObjectId<ContainerId::eventInfo>
using	OptEventInfoId = OptObjectId<ContainerId::eventInfo>
template<typename CT, typename CM = ColumnarModeDefault>
using	EventInfoAccessor = AccessorTemplate<ContainerId::eventInfo,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	EventInfoDecorator = AccessorTemplate<ContainerId::eventInfo,CT,ColumnAccessMode::output,CM>
using	ColumnarOffsetType = std::size_t
	the type used for the size and offsets in the columnar data
using	JetRange = ObjectRange<ContainerId::jet>
using	JetId = ObjectId<ContainerId::jet>
using	OptJetId = OptObjectId<ContainerId::jet>
template<typename CT, typename CM = ColumnarModeDefault>
using	JetAccessor = AccessorTemplate<ContainerId::jet,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	JetDecorator = AccessorTemplate<ContainerId::jet,CT,ColumnAccessMode::output,CM>
using	MutableJetRange = ObjectRange<ContainerId::mutableJet>
using	MutableJetId = ObjectId<ContainerId::mutableJet>
using	OptMutableJetId = OptObjectId<ContainerId::mutableJet>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableJetAccessor = AccessorTemplate<ContainerId::mutableJet,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableJetDecorator = AccessorTemplate<ContainerId::mutableJet,CT,ColumnAccessMode::output,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableJetUpdater = AccessorTemplate<ContainerId::mutableJet,CT,ColumnAccessMode::update,CM>
using	MetRange = ObjectRange<ContainerId::met>
using	MetId = ObjectId<ContainerId::met>
using	OptMetId = OptObjectId<ContainerId::met>
template<typename CT, typename CM = ColumnarModeDefault>
using	MetAccessor = AccessorTemplate<ContainerId::met,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MetDecorator = AccessorTemplate<ContainerId::met,CT,ColumnAccessMode::output,CM>
using	Met0Range = ObjectRange<ContainerId::met0>
using	Met0Id = ObjectId<ContainerId::met0>
using	OptMet0Id = OptObjectId<ContainerId::met0>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met0Accessor = AccessorTemplate<ContainerId::met0,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met0Decorator = AccessorTemplate<ContainerId::met0,CT,ColumnAccessMode::output,CM>
using	Met1Range = ObjectRange<ContainerId::met1>
using	Met1Id = ObjectId<ContainerId::met1>
using	OptMet1Id = OptObjectId<ContainerId::met1>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met1Accessor = AccessorTemplate<ContainerId::met1,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met1Decorator = AccessorTemplate<ContainerId::met1,CT,ColumnAccessMode::output,CM>
using	MutableMetRange = ObjectRange<ContainerId::mutableMet>
using	MutableMetId = ObjectId<ContainerId::mutableMet>
using	OptMutableMetId = OptObjectId<ContainerId::mutableMet>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableMetAccessor = AccessorTemplate<ContainerId::mutableMet,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableMetDecorator = AccessorTemplate<ContainerId::mutableMet,CT,ColumnAccessMode::output,CM>
using	MetAssociationRange = ObjectRange<ContainerId::metAssociation>
using	MetAssociationId = ObjectId<ContainerId::metAssociation>
using	OptMetAssociationId = OptObjectId<ContainerId::metAssociation>
using	MuonRange = ObjectRange<ContainerId::muon>
using	MuonId = ObjectId<ContainerId::muon>
using	OptMuonId = OptObjectId<ContainerId::muon>
template<typename CT, typename CM = ColumnarModeDefault>
using	MuonAccessor = AccessorTemplate<ContainerId::muon,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MuonDecorator = AccessorTemplate<ContainerId::muon,CT,ColumnAccessMode::output,CM>
using	MuonTrackDef = columnar::VariantContainerId<columnar::ContainerId::track0,columnar::ContainerId::track0,columnar::ContainerId::track3,columnar::ContainerId::track1,columnar::ContainerId::track2>
using	TauJetRange = ObjectRange<ContainerId::tauJet>
using	TauJetId = ObjectId<ContainerId::tauJet>
using	OptTauJetId = OptObjectId<ContainerId::tauJet>
template<typename CT, typename CM = ColumnarModeDefault>
using	TauJetAccessor = AccessorTemplate<ContainerId::tauJet,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	TauJetDecorator = AccessorTemplate<ContainerId::tauJet,CT,ColumnAccessMode::output,CM>
using	TrackId = ObjectId<ContainerId::track>
using	OptTrackId = OptObjectId<ContainerId::track>
template<typename CT, typename CM = ColumnarModeDefault>
using	TrackAccessor = AccessorTemplate<ContainerId::track,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	TrackDecorator = AccessorTemplate<ContainerId::track,CT,ColumnAccessMode::output,CM>
using	OptTrack0Id = OptObjectId<ContainerId::track0>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track0Accessor = AccessorTemplate<ContainerId::track0,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track0Decorator = AccessorTemplate<ContainerId::track0,CT,ColumnAccessMode::output,CM>
using	OptTrack1Id = OptObjectId<ContainerId::track1>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track1Accessor = AccessorTemplate<ContainerId::track1,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track1Decorator = AccessorTemplate<ContainerId::track1,CT,ColumnAccessMode::output,CM>
using	OptTrack2Id = OptObjectId<ContainerId::track2>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track2Accessor = AccessorTemplate<ContainerId::track2,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track2Decorator = AccessorTemplate<ContainerId::track2,CT,ColumnAccessMode::output,CM>
using	OptTrack3Id = OptObjectId<ContainerId::track3>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track3Accessor = AccessorTemplate<ContainerId::track3,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track3Decorator = AccessorTemplate<ContainerId::track3,CT,ColumnAccessMode::output,CM>
using	VertexId = ObjectId<ContainerId::vertex>
using	OptVertexId = OptObjectId<ContainerId::vertex>
template<typename CT, typename CM = ColumnarModeDefault>
using	VertexAccessor = AccessorTemplate<ContainerId::vertex,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	VertexDecorator = AccessorTemplate<ContainerId::vertex,CT,ColumnAccessMode::output,CM>

Enumerations
enum class	ColumnAccessMode { input , output , update }
	an enum for the different access modes for a column More...

Functions
template<ContainerIdConcept CI, typename CT, ColumnAccessMode CAM, typename CM>
void	resetAccessor (AccessorTemplate< CI, CT, CAM, CM > &accessor, ColumnarTool< CM > &columnBase, const std::string &name, ColumnInfo &&info={})
	reset a column accessor to point to a new column
void	moveAccessor (unsigned &dataIndex, std::unique_ptr< ColumnAccessorDataArray > &accessorData, unsigned &sourceIndex, std::unique_ptr< ColumnAccessorDataArray > &sourceData)
void	addColumnAccessMode (ColumnInfo &info, ColumnAccessMode accessMode)
void	mergeColumnInfo (ColumnInfo &target, const ColumnInfo &source)
template<ContainerIdConcept CI, typename CM>
void	resetIParticle (MomentumAccessors< CI, CM > &accessors)
	reset the dynamic momentum accessors to various default implementations
template<ContainerIdConcept CI, typename CM>
void	resetPtEtaPhiReadM (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)
template<ContainerIdConcept CI, typename CM>
void	resetPtEtaPhiFixedM (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool, double mValue)
template<ContainerIdConcept CI, typename CM>
void	resetJet (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)
template<ContainerIdConcept CI, typename CM>
void	resetJetConstituentScale (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool, const std::string &prefix="JetConstitScaleMomentum_")
template<ContainerIdConcept CI, typename CM>
void	resetElectron (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)
template<ContainerIdConcept CI, typename CM>
void	resetPhoton (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)
template<ContainerIdConcept CI, typename CM>
void	resetEgamma (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)
template<ContainerIdConcept CI, typename CM>
void	resetMuon (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)
template<ContainerIdConcept CI, typename CM>
void	resetTau (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)
template<ContainerIdConcept CI, typename CM>
void	resetObjectType (MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool, xAODType::ObjectType type)
double	deltaPhi (double phiA, double phiB)
	delta Phi in range [-pi,pi[
template<ContainerIdConcept CI1, ContainerIdConcept CI2, typename CM>
double	deltaRapidity (const MomentumAccessors< CI1, CM > &momAcc1, ObjectId< CI1, CM > p1, const MomentumAccessors< CI2, CM > &momAcc2, ObjectId< CI2, CM > p2, bool useRapidity=true)
	Computes efficiently \( \Delta{y} \).
template<ContainerIdConcept CI1, ContainerIdConcept CI2, typename CM>
bool	isInDeltaR (const MomentumAccessors< CI1, CM > &momAcc1, ObjectId< CI1, CM > p1, const MomentumAccessors< CI2, CM > &momAcc2, ObjectId< CI2, CM > p2, double dR, bool useRapidity=true)
	Check if 2 particles are in a \( \Delta{R} \) cone.
template<ContainerIdConcept CI>
std::ostream &	operator<< (std::ostream &str, const ObjectId< CI, ColumnarModeXAOD > &obj)
template<ContainerIdConcept CI>
bool	operator== (const ObjectId< CI, ColumnarModeXAOD > &lhs, const ObjectId< CI, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept CI>
bool	operator!= (const ObjectId< CI, ColumnarModeXAOD > &lhs, const ObjectId< CI, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept CI>
std::ostream &	operator<< (std::ostream &str, const ObjectId< CI, ColumnarModeArray > &obj)
template<ContainerIdConcept CI>
bool	operator== (const ObjectId< CI, ColumnarModeArray > &lhs, const ObjectId< CI, ColumnarModeArray > &rhs)
template<ContainerIdConcept CI>
bool	operator!= (const ObjectId< CI, ColumnarModeArray > &lhs, const ObjectId< CI, ColumnarModeArray > &rhs)
template<ContainerIdConcept CI>
bool	operator== (const OptObjectId< CI, ColumnarModeXAOD > &lhs, const OptObjectId< CI, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept CI>
bool	operator!= (const OptObjectId< CI, ColumnarModeXAOD > &lhs, const OptObjectId< CI, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept CI>
bool	operator== (const OptObjectId< CI, ColumnarModeArray > &lhs, const OptObjectId< CI, ColumnarModeArray > &rhs)
template<ContainerIdConcept CI>
bool	operator!= (const OptObjectId< CI, ColumnarModeArray > &lhs, const OptObjectId< CI, ColumnarModeArray > &rhs)
void	renameContainers (IColumnarTool &tool, const std::vector< std::pair< std::string, std::string > > &renames)
	rename containers in the columnar tool
template<typename... CIList>
std::ostream &	operator<< (std::ostream &str, const ObjectLink< VariantContainerId< CIList... >, ColumnarModeXAOD > &obj)
template<typename... CIList>
std::ostream &	operator<< (std::ostream &str, const ObjectLink< VariantContainerId< CIList... >, ColumnarModeArray > &obj)
template<ContainerIdConcept... CIList>
std::ostream &	operator<< (std::ostream &str, const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &obj)
template<ContainerIdConcept... CIList>
bool	operator== (const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &lhs, const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept... CIList>
bool	operator!= (const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &lhs, const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept... CIList>
std::ostream &	operator<< (std::ostream &str, const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &obj)
template<ContainerIdConcept... CIList>
bool	operator== (const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &lhs, const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &rhs)
template<ContainerIdConcept... CIList>
bool	operator!= (const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &lhs, const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &rhs)
template<ContainerIdConcept... CIList>
std::ostream &	operator<< (std::ostream &str, const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &obj)
template<ContainerIdConcept... CIList>
bool	operator== (const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &lhs, const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept... CIList>
bool	operator!= (const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &lhs, const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &rhs)
template<ContainerIdConcept... CIList>
std::ostream &	operator<< (std::ostream &str, const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &obj)
template<ContainerIdConcept... CIList>
bool	operator== (const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &lhs, const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &rhs)
template<ContainerIdConcept... CIList>
bool	operator!= (const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &lhs, const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &rhs)

Variables
constexpr unsigned	columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE
constexpr ColumnarOffsetType	invalidObjectIndex = static_cast<ColumnarOffsetType>(-1)
	the value for an invalid element index
const std::string	numberOfEventsName = "EventInfo"
	the name used for the column containing the number of events

Detailed Description

Author: Nils Krumnack; Nils Krumnack

Includes

Author: Nils Krumnack; Matthew Feickert; Matthias Vigl; Giordon Stark

Typedef Documentation

◆ ClusterAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::ClusterAccessor = AccessorTemplate<ContainerId::cluster,CT,ColumnAccessMode::input,CM>

Definition at line 28 of file ClusterDef.h.

◆ ClusterDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::ClusterDecorator = AccessorTemplate<ContainerId::cluster,CT,ColumnAccessMode::output,CM>

Definition at line 29 of file ClusterDef.h.

◆ ClusterId

using columnar::ClusterId = ObjectId<ContainerId::cluster>

Definition at line 26 of file ClusterDef.h.

◆ ColumnAccessor

template<ContainerIdConcept CI, typename CT, typename CM = ColumnarModeDefault>

using columnar::ColumnAccessor = AccessorTemplate<CI,CT,ColumnAccessMode::input,CM>

Definition at line 261 of file ColumnAccessor.h.

◆ ColumnarModeDefault

using columnar::ColumnarModeDefault = ColumnarModeXAOD

Definition at line 108 of file ColumnarDef.h.

◆ ColumnarOffsetType

using columnar::ColumnarOffsetType = std::size_t

the type used for the size and offsets in the columnar data

Todo: This type still needs to be adjusted to match whatever uproot uses for its offset maps.

Definition at line 20 of file IColumnarTool.h.

◆ ColumnDecorator

template<ContainerIdConcept CI, typename CT, typename CM = ColumnarModeDefault>

using columnar::ColumnDecorator = AccessorTemplate<CI,CT,ColumnAccessMode::output,CM>

Definition at line 262 of file ColumnAccessor.h.

◆ ColumnUpdater

template<ContainerIdConcept CI, typename CT, typename CM = ColumnarModeDefault>

using columnar::ColumnUpdater = AccessorTemplate<CI,CT,ColumnAccessMode::update,CM>

Definition at line 263 of file ColumnAccessor.h.

◆ EgammaAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::EgammaAccessor = AccessorTemplate<ContainerId::egamma,CT,ColumnAccessMode::input,CM>

Definition at line 52 of file EgammaDef.h.

◆ EgammaDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::EgammaDecorator = AccessorTemplate<ContainerId::egamma,CT,ColumnAccessMode::output,CM>

Definition at line 53 of file EgammaDef.h.

◆ EgammaId

using columnar::EgammaId = ObjectId<ContainerId::egamma>

Definition at line 50 of file EgammaDef.h.

◆ EgammaRange

using columnar::EgammaRange = ObjectRange<ContainerId::egamma>

Definition at line 49 of file EgammaDef.h.

◆ ElectronAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::ElectronAccessor = AccessorTemplate<ContainerId::electron,CT,ColumnAccessMode::input,CM>

Definition at line 40 of file EgammaDef.h.

◆ ElectronDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::ElectronDecorator = AccessorTemplate<ContainerId::electron,CT,ColumnAccessMode::output,CM>

Definition at line 41 of file EgammaDef.h.

◆ ElectronId

using columnar::ElectronId = ObjectId<ContainerId::electron>

Definition at line 38 of file EgammaDef.h.

◆ ElectronRange

using columnar::ElectronRange = ObjectRange<ContainerId::electron>

Definition at line 37 of file EgammaDef.h.

◆ EventContextId

using columnar::EventContextId = ObjectId<ContainerId::eventContext>

Definition at line 185 of file ContainerId.h.

◆ EventContextRange

using columnar::EventContextRange = ObjectRange<ContainerId::eventContext>

Definition at line 184 of file ContainerId.h.

◆ EventInfoAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::EventInfoAccessor = AccessorTemplate<ContainerId::eventInfo,CT,ColumnAccessMode::input,CM>

Definition at line 34 of file EventInfoDef.h.

◆ EventInfoDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::EventInfoDecorator = AccessorTemplate<ContainerId::eventInfo,CT,ColumnAccessMode::output,CM>

Definition at line 35 of file EventInfoDef.h.

◆ EventInfoId

using columnar::EventInfoId = ObjectId<ContainerId::eventInfo>

Definition at line 32 of file EventInfoDef.h.

◆ EventInfoRange

using columnar::EventInfoRange = ObjectRange<ContainerId::eventInfo>

Definition at line 31 of file EventInfoDef.h.

◆ JetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::JetAccessor = AccessorTemplate<ContainerId::jet,CT,ColumnAccessMode::input,CM>

Definition at line 28 of file JetDef.h.

◆ JetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::JetDecorator = AccessorTemplate<ContainerId::jet,CT,ColumnAccessMode::output,CM>

Definition at line 29 of file JetDef.h.

◆ JetId

using columnar::JetId = ObjectId<ContainerId::jet>

Definition at line 26 of file JetDef.h.

◆ JetRange

using columnar::JetRange = ObjectRange<ContainerId::jet>

Definition at line 25 of file JetDef.h.

◆ Met0Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Met0Accessor = AccessorTemplate<ContainerId::met0,CT,ColumnAccessMode::input,CM>

Definition at line 58 of file MetDef.h.

◆ Met0Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Met0Decorator = AccessorTemplate<ContainerId::met0,CT,ColumnAccessMode::output,CM>

Definition at line 59 of file MetDef.h.

◆ Met0Id

using columnar::Met0Id = ObjectId<ContainerId::met0>

Definition at line 56 of file MetDef.h.

◆ Met0Range

using columnar::Met0Range = ObjectRange<ContainerId::met0>

Definition at line 55 of file MetDef.h.

◆ Met1Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Met1Accessor = AccessorTemplate<ContainerId::met1,CT,ColumnAccessMode::input,CM>

Definition at line 64 of file MetDef.h.

◆ Met1Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Met1Decorator = AccessorTemplate<ContainerId::met1,CT,ColumnAccessMode::output,CM>

Definition at line 65 of file MetDef.h.

◆ Met1Id

using columnar::Met1Id = ObjectId<ContainerId::met1>

Definition at line 62 of file MetDef.h.

◆ Met1Range

using columnar::Met1Range = ObjectRange<ContainerId::met1>

Definition at line 61 of file MetDef.h.

◆ MetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MetAccessor = AccessorTemplate<ContainerId::met,CT,ColumnAccessMode::input,CM>

Definition at line 52 of file MetDef.h.

◆ MetAssociationId

using columnar::MetAssociationId = ObjectId<ContainerId::metAssociation>

Definition at line 74 of file MetDef.h.

◆ MetAssociationRange

using columnar::MetAssociationRange = ObjectRange<ContainerId::metAssociation>

Definition at line 73 of file MetDef.h.

◆ MetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MetDecorator = AccessorTemplate<ContainerId::met,CT,ColumnAccessMode::output,CM>

Definition at line 53 of file MetDef.h.

◆ MetId

using columnar::MetId = ObjectId<ContainerId::met>

Definition at line 50 of file MetDef.h.

◆ MetRange

using columnar::MetRange = ObjectRange<ContainerId::met>

Definition at line 49 of file MetDef.h.

◆ MuonAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MuonAccessor = AccessorTemplate<ContainerId::muon,CT,ColumnAccessMode::input,CM>

Definition at line 27 of file MuonDef.h.

◆ MuonDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MuonDecorator = AccessorTemplate<ContainerId::muon,CT,ColumnAccessMode::output,CM>

Definition at line 28 of file MuonDef.h.

◆ MuonId

using columnar::MuonId = ObjectId<ContainerId::muon>

Definition at line 25 of file MuonDef.h.

◆ MuonRange

using columnar::MuonRange = ObjectRange<ContainerId::muon>

Definition at line 24 of file MuonDef.h.

◆ MuonTrackDef

using columnar::MuonTrackDef = columnar::VariantContainerId<columnar::ContainerId::track0,columnar::ContainerId::track0,columnar::ContainerId::track3,columnar::ContainerId::track1,columnar::ContainerId::track2>

Definition at line 18 of file MuonTrackHelpers.h.

◆ MutableEgammaAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MutableEgammaAccessor = AccessorTemplate<ContainerId::mutableEgamma,CT,ColumnAccessMode::input,CM>

Definition at line 58 of file EgammaDef.h.

◆ MutableEgammaDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MutableEgammaDecorator = AccessorTemplate<ContainerId::mutableEgamma,CT,ColumnAccessMode::output,CM>

Definition at line 59 of file EgammaDef.h.

◆ MutableEgammaId

using columnar::MutableEgammaId = ObjectId<ContainerId::mutableEgamma>

Definition at line 56 of file EgammaDef.h.

◆ MutableEgammaRange

using columnar::MutableEgammaRange = ObjectRange<ContainerId::mutableEgamma>

Definition at line 55 of file EgammaDef.h.

◆ MutableJetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MutableJetAccessor = AccessorTemplate<ContainerId::mutableJet,CT,ColumnAccessMode::input,CM>

Definition at line 34 of file JetDef.h.

◆ MutableJetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MutableJetDecorator = AccessorTemplate<ContainerId::mutableJet,CT,ColumnAccessMode::output,CM>

Definition at line 35 of file JetDef.h.

◆ MutableJetId

using columnar::MutableJetId = ObjectId<ContainerId::mutableJet>

Definition at line 32 of file JetDef.h.

◆ MutableJetRange

using columnar::MutableJetRange = ObjectRange<ContainerId::mutableJet>

Definition at line 31 of file JetDef.h.

◆ MutableJetUpdater

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MutableJetUpdater = AccessorTemplate<ContainerId::mutableJet,CT,ColumnAccessMode::update,CM>

Definition at line 36 of file JetDef.h.

◆ MutableMetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MutableMetAccessor = AccessorTemplate<ContainerId::mutableMet,CT,ColumnAccessMode::input,CM>

Definition at line 70 of file MetDef.h.

◆ MutableMetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::MutableMetDecorator = AccessorTemplate<ContainerId::mutableMet,CT,ColumnAccessMode::output,CM>

Definition at line 71 of file MetDef.h.

◆ MutableMetId

using columnar::MutableMetId = ObjectId<ContainerId::mutableMet>

Definition at line 68 of file MetDef.h.

◆ MutableMetRange

using columnar::MutableMetRange = ObjectRange<ContainerId::mutableMet>

Definition at line 67 of file MetDef.h.

◆ OptClusterId

using columnar::OptClusterId = OptObjectId<ContainerId::cluster>

Definition at line 27 of file ClusterDef.h.

◆ OptEgammaId

using columnar::OptEgammaId = OptObjectId<ContainerId::egamma>

Definition at line 51 of file EgammaDef.h.

◆ OptElectronId

using columnar::OptElectronId = OptObjectId<ContainerId::electron>

Definition at line 39 of file EgammaDef.h.

◆ OptEventInfoId

using columnar::OptEventInfoId = OptObjectId<ContainerId::eventInfo>

Definition at line 33 of file EventInfoDef.h.

◆ OptJetId

using columnar::OptJetId = OptObjectId<ContainerId::jet>

Definition at line 27 of file JetDef.h.

◆ OptMet0Id

using columnar::OptMet0Id = OptObjectId<ContainerId::met0>

Definition at line 57 of file MetDef.h.

◆ OptMet1Id

using columnar::OptMet1Id = OptObjectId<ContainerId::met1>

Definition at line 63 of file MetDef.h.

◆ OptMetAssociationId

using columnar::OptMetAssociationId = OptObjectId<ContainerId::metAssociation>

Definition at line 75 of file MetDef.h.

◆ OptMetId

using columnar::OptMetId = OptObjectId<ContainerId::met>

Definition at line 51 of file MetDef.h.

◆ OptMuonId

using columnar::OptMuonId = OptObjectId<ContainerId::muon>

Definition at line 26 of file MuonDef.h.

◆ OptMutableEgammaId

using columnar::OptMutableEgammaId = OptObjectId<ContainerId::mutableEgamma>

Definition at line 57 of file EgammaDef.h.

◆ OptMutableJetId

using columnar::OptMutableJetId = OptObjectId<ContainerId::mutableJet>

Definition at line 33 of file JetDef.h.

◆ OptMutableMetId

using columnar::OptMutableMetId = OptObjectId<ContainerId::mutableMet>

Definition at line 69 of file MetDef.h.

◆ OptParticle0Id

using columnar::OptParticle0Id = OptObjectId<ContainerId::particle0>

Definition at line 43 of file ParticleDef.h.

◆ OptParticle1Id

using columnar::OptParticle1Id = OptObjectId<ContainerId::particle1>

Definition at line 49 of file ParticleDef.h.

◆ OptParticle2Id

using columnar::OptParticle2Id = OptObjectId<ContainerId::particle2>

Definition at line 55 of file ParticleDef.h.

◆ OptParticleId

using columnar::OptParticleId = OptObjectId<ContainerId::particle>

Definition at line 37 of file ParticleDef.h.

◆ OptPhotonId

using columnar::OptPhotonId = OptObjectId<ContainerId::photon>

Definition at line 45 of file EgammaDef.h.

◆ OptTauJetId

using columnar::OptTauJetId = OptObjectId<ContainerId::tauJet>

Definition at line 26 of file TauJetDef.h.

◆ OptTrack0Id

using columnar::OptTrack0Id = OptObjectId<ContainerId::track0>

Definition at line 51 of file TrackDef.h.

◆ OptTrack1Id

using columnar::OptTrack1Id = OptObjectId<ContainerId::track1>

Definition at line 55 of file TrackDef.h.

◆ OptTrack2Id

using columnar::OptTrack2Id = OptObjectId<ContainerId::track2>

Definition at line 59 of file TrackDef.h.

◆ OptTrack3Id

using columnar::OptTrack3Id = OptObjectId<ContainerId::track3>

Definition at line 63 of file TrackDef.h.

◆ OptTrackId

using columnar::OptTrackId = OptObjectId<ContainerId::track>

Definition at line 47 of file TrackDef.h.

◆ OptVertexId

using columnar::OptVertexId = OptObjectId<ContainerId::vertex>

Definition at line 68 of file TrackDef.h.

◆ Particle0Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Particle0Accessor = AccessorTemplate<ContainerId::particle0,CT,ColumnAccessMode::input,CM>

Definition at line 44 of file ParticleDef.h.

◆ Particle0Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Particle0Decorator = AccessorTemplate<ContainerId::particle0,CT,ColumnAccessMode::output,CM>

Definition at line 45 of file ParticleDef.h.

◆ Particle0Id

using columnar::Particle0Id = ObjectId<ContainerId::particle0>

Definition at line 42 of file ParticleDef.h.

◆ Particle0Range

using columnar::Particle0Range = ObjectRange<ContainerId::particle0>

Definition at line 41 of file ParticleDef.h.

◆ Particle1Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Particle1Accessor = AccessorTemplate<ContainerId::particle1,CT,ColumnAccessMode::input,CM>

Definition at line 50 of file ParticleDef.h.

◆ Particle1Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Particle1Decorator = AccessorTemplate<ContainerId::particle1,CT,ColumnAccessMode::output,CM>

Definition at line 51 of file ParticleDef.h.

◆ Particle1Id

using columnar::Particle1Id = ObjectId<ContainerId::particle1>

Definition at line 48 of file ParticleDef.h.

◆ Particle1Range

using columnar::Particle1Range = ObjectRange<ContainerId::particle1>

Definition at line 47 of file ParticleDef.h.

◆ Particle2Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Particle2Accessor = AccessorTemplate<ContainerId::particle2,CT,ColumnAccessMode::input,CM>

Definition at line 56 of file ParticleDef.h.

◆ Particle2Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Particle2Decorator = AccessorTemplate<ContainerId::particle2,CT,ColumnAccessMode::output,CM>

Definition at line 57 of file ParticleDef.h.

◆ Particle2Id

using columnar::Particle2Id = ObjectId<ContainerId::particle2>

Definition at line 54 of file ParticleDef.h.

◆ Particle2Range

using columnar::Particle2Range = ObjectRange<ContainerId::particle2>

Definition at line 53 of file ParticleDef.h.

◆ ParticleAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::ParticleAccessor = AccessorTemplate<ContainerId::particle,CT,ColumnAccessMode::input,CM>

Definition at line 38 of file ParticleDef.h.

◆ ParticleDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::ParticleDecorator = AccessorTemplate<ContainerId::particle,CT,ColumnAccessMode::output,CM>

Definition at line 39 of file ParticleDef.h.

◆ ParticleId

using columnar::ParticleId = ObjectId<ContainerId::particle>

Definition at line 36 of file ParticleDef.h.

◆ ParticleRange

using columnar::ParticleRange = ObjectRange<ContainerId::particle>

Definition at line 35 of file ParticleDef.h.

◆ PhotonAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::PhotonAccessor = AccessorTemplate<ContainerId::photon,CT,ColumnAccessMode::input,CM>

Definition at line 46 of file EgammaDef.h.

◆ PhotonDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::PhotonDecorator = AccessorTemplate<ContainerId::photon,CT,ColumnAccessMode::output,CM>

Definition at line 47 of file EgammaDef.h.

◆ PhotonId

using columnar::PhotonId = ObjectId<ContainerId::photon>

Definition at line 44 of file EgammaDef.h.

◆ PhotonRange

using columnar::PhotonRange = ObjectRange<ContainerId::photon>

Definition at line 43 of file EgammaDef.h.

◆ TauJetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::TauJetAccessor = AccessorTemplate<ContainerId::tauJet,CT,ColumnAccessMode::input,CM>

Definition at line 27 of file TauJetDef.h.

◆ TauJetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::TauJetDecorator = AccessorTemplate<ContainerId::tauJet,CT,ColumnAccessMode::output,CM>

Definition at line 28 of file TauJetDef.h.

◆ TauJetId

using columnar::TauJetId = ObjectId<ContainerId::tauJet>

Definition at line 25 of file TauJetDef.h.

◆ TauJetRange

using columnar::TauJetRange = ObjectRange<ContainerId::tauJet>

Definition at line 24 of file TauJetDef.h.

◆ Track0Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track0Accessor = AccessorTemplate<ContainerId::track0,CT,ColumnAccessMode::input,CM>

Definition at line 52 of file TrackDef.h.

◆ Track0Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track0Decorator = AccessorTemplate<ContainerId::track0,CT,ColumnAccessMode::output,CM>

Definition at line 53 of file TrackDef.h.

◆ Track1Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track1Accessor = AccessorTemplate<ContainerId::track1,CT,ColumnAccessMode::input,CM>

Definition at line 56 of file TrackDef.h.

◆ Track1Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track1Decorator = AccessorTemplate<ContainerId::track1,CT,ColumnAccessMode::output,CM>

Definition at line 57 of file TrackDef.h.

◆ Track2Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track2Accessor = AccessorTemplate<ContainerId::track2,CT,ColumnAccessMode::input,CM>

Definition at line 60 of file TrackDef.h.

◆ Track2Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track2Decorator = AccessorTemplate<ContainerId::track2,CT,ColumnAccessMode::output,CM>

Definition at line 61 of file TrackDef.h.

◆ Track3Accessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track3Accessor = AccessorTemplate<ContainerId::track3,CT,ColumnAccessMode::input,CM>

Definition at line 64 of file TrackDef.h.

◆ Track3Decorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::Track3Decorator = AccessorTemplate<ContainerId::track3,CT,ColumnAccessMode::output,CM>

Definition at line 65 of file TrackDef.h.

◆ TrackAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::TrackAccessor = AccessorTemplate<ContainerId::track,CT,ColumnAccessMode::input,CM>

Definition at line 48 of file TrackDef.h.

◆ TrackDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::TrackDecorator = AccessorTemplate<ContainerId::track,CT,ColumnAccessMode::output,CM>

Definition at line 49 of file TrackDef.h.

◆ TrackId

using columnar::TrackId = ObjectId<ContainerId::track>

Definition at line 46 of file TrackDef.h.

◆ VertexAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::VertexAccessor = AccessorTemplate<ContainerId::vertex,CT,ColumnAccessMode::input,CM>

Definition at line 69 of file TrackDef.h.

◆ VertexDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::VertexDecorator = AccessorTemplate<ContainerId::vertex,CT,ColumnAccessMode::output,CM>

Definition at line 70 of file TrackDef.h.

◆ VertexId

using columnar::VertexId = ObjectId<ContainerId::vertex>

Definition at line 67 of file TrackDef.h.

Enumeration Type Documentation

◆ ColumnAccessMode

enum class columnar::ColumnAccessMode

strong

an enum for the different access modes for a column

Enumerator
input	an input column
output	an output column
update	an updateable column

Definition at line 18 of file ColumnInfo.h.

  {
    input,
    output,
    update
  };

Function Documentation

◆ addColumnAccessMode()

void columnar::addColumnAccessMode	(	ColumnInfo &	info,
		ColumnAccessMode	accessMode )

Definition at line 24 of file ColumnInfoHelpers.cxx.

  {
    if (info.accessMode == ColumnAccessMode::input)
      info.accessMode = accessMode;
    else if (info.accessMode != accessMode)
      throw std::runtime_error ("conflicting access modes for column " + info.name);
  }

◆ deltaPhi()

double columnar::deltaPhi	(	double	phiA,
		double	phiB )

inline

delta Phi in range [-pi,pi[

Definition at line 23 of file MomentumHelpers.h.

  {
    return  -remainder( -phiA + phiB, 2*M_PI );
  }

◆ deltaRapidity()

template<ContainerIdConcept CI1, ContainerIdConcept CI2, typename CM>

double columnar::deltaRapidity	(	const MomentumAccessors< CI1, CM > &	momAcc1,
		ObjectId< CI1, CM >	p1,
		const MomentumAccessors< CI2, CM > &	momAcc2,
		ObjectId< CI2, CM >	p2,
		bool	useRapidity = true )

Computes efficiently \( \Delta{y} \).

Definition at line 32 of file MomentumHelpers.h.

  {
    if (useRapidity)
      return momAcc1.rapidity(p1) - momAcc2.rapidity(p2);
    else
      return momAcc1.eta(p1) - momAcc2.eta(p2);
  }

◆ isInDeltaR()

template<ContainerIdConcept CI1, ContainerIdConcept CI2, typename CM>

bool columnar::isInDeltaR	(	const MomentumAccessors< CI1, CM > &	momAcc1,
		ObjectId< CI1, CM >	p1,
		const MomentumAccessors< CI2, CM > &	momAcc2,
		ObjectId< CI2, CM >	p2,
		double	dR,
		bool	useRapidity = true )

Check if 2 particles are in a \( \Delta{R} \) cone.

Parameters

dR	[in] \( \Delta{R} \)

Returns: true if they are

Definition at line 46 of file MomentumHelpers.h.

  {
    const double dPhi = std::abs( xAOD::P4Helpers::deltaPhi(momAcc1.phi(p1),momAcc2.phi(p2)) ); // in [-pi,pi)
    if ( CxxUtils::fpcompare::greater(dPhi,dR) ) return false;        // <==
    const double dRapidity = std::abs( deltaRapidity(momAcc1,p1,momAcc2,p2,useRapidity) );
    if ( CxxUtils::fpcompare::greater(dRapidity,dR) ) return false;        // <==
    const double deltaR2 = dRapidity*dRapidity + dPhi*dPhi;
    if ( CxxUtils::fpcompare::greater(deltaR2,dR*dR) ) return false;  // <==
    return true;
  }

◆ mergeColumnInfo()

void columnar::mergeColumnInfo	(	ColumnInfo &	target,
		const ColumnInfo &	source )

Definition at line 34 of file ColumnInfoHelpers.cxx.

  {
    if (target.name != source.name)
      throw std::runtime_error ("mismatched column names in mergeColumnInfo: " + target.name + " and " + source.name);
 
    if (target.type == nullptr || source.type == nullptr)
      throw std::runtime_error ("missing type information in mergeColumnInfo for column: " + target.name);
    if (*target.type != *source.type)
      throw std::runtime_error ("mismatched column types in mergeColumnInfo for column: " + target.name + ": " + boost::core::demangle(target.type->name()) + " and " + boost::core::demangle(source.type->name()));
    
    addColumnAccessMode (target, source.accessMode);
 
    if (target.offsetName != source.offsetName)
      throw std::runtime_error ("mismatched offset names in mergeColumnInfo for column: " + target.name + ": " + target.offsetName + " and " + source.offsetName);
 
    if (target.fixedDimensions != source.fixedDimensions)
      throw std::runtime_error ("mismatched fixed dimensions in mergeColumnInfo for column: " + target.name);
    
    if (target.isOffset != source.isOffset)
      throw std::runtime_error ("mismatched isOffset in mergeColumnInfo for column: " + target.name);
    
    if (target.replacesColumn.empty())
      target.replacesColumn = source.replacesColumn;
    else if (!source.replacesColumn.empty() && target.replacesColumn != source.replacesColumn)
      throw std::runtime_error ("mismatched replacesColumn in mergeColumnInfo for column: " + target.name + ": " + target.replacesColumn + " and " + source.replacesColumn);
 
    if (!source.isOptional)
      target.isOptional = false;
 
    if (target.linkTargetNames != source.linkTargetNames)
      throw std::runtime_error ("mismatched linkTargetNames in mergeColumnInfo for column: " + target.name);
 
    if (target.variantLinkKeyColumn != source.variantLinkKeyColumn)
      throw std::runtime_error ("mismatched variantLinkKeyColumn in mergeColumnInfo for column: " + target.name + ": " + target.variantLinkKeyColumn + " and " + source.variantLinkKeyColumn);
  }

◆ moveAccessor()

void columnar::moveAccessor	(	unsigned &	dataIndex,
		std::unique_ptr< ColumnAccessorDataArray > &	accessorData,
		unsigned &	sourceIndex,
		std::unique_ptr< ColumnAccessorDataArray > &	sourceData )

Definition at line 30 of file ColumnAccessorDataArray.cxx.

  {
    if (accessorData != nullptr)
      throw std::runtime_error ("trying to set a columnar accessor that has already been set, overwriting not yet supported");
 
    dataIndex = sourceIndex;
    sourceIndex = 0;
 
    if (sourceData)
    {
      if (sourceData->selfPtr != &sourceData)
        throw std::logic_error ("selfPtr not set correctly");
 
      accessorData = std::move (sourceData);
      accessorData->selfPtr = &accessorData;
      accessorData->dataIndexPtr = &dataIndex;
    }
  }

◆ operator!=() [1/8]

template<ContainerIdConcept CI>

bool columnar::operator!=	(	const ObjectId< CI, ColumnarModeArray > &	lhs,
		const ObjectId< CI, ColumnarModeArray > &	rhs )

Definition at line 174 of file ObjectId.h.

  {
    return lhs.getIndex() != rhs.getIndex();
  }

◆ operator!=() [2/8]

template<ContainerIdConcept CI>

bool columnar::operator!=	(	const ObjectId< CI, ColumnarModeXAOD > &	lhs,
		const ObjectId< CI, ColumnarModeXAOD > &	rhs )

Definition at line 88 of file ObjectId.h.

  {
    return &lhs.getXAODObjectNoexcept() != &rhs.getXAODObjectNoexcept();
  }

◆ operator!=() [3/8]

template<ContainerIdConcept... CIList>

bool columnar::operator!=	(	const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	lhs,
		const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	rhs )

Definition at line 202 of file VariantObjectId.h.

  {
    return lhs.getVariantIndex() != rhs.getVariantIndex() || lhs.getObjectIndex() != rhs.getObjectIndex();
  }

◆ operator!=() [4/8]

template<ContainerIdConcept... CIList>

bool columnar::operator!=	(	const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	lhs,
		const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	rhs )

Definition at line 99 of file VariantObjectId.h.

  {
    return &lhs.getXAODObjectNoexcept() != &rhs.getXAODObjectNoexcept();
  }

◆ operator!=() [5/8]

template<ContainerIdConcept CI>

bool columnar::operator!=	(	const OptObjectId< CI, ColumnarModeArray > &	lhs,
		const OptObjectId< CI, ColumnarModeArray > &	rhs )

Definition at line 204 of file OptObjectId.h.

  {
    return lhs.getIndex() != rhs.getIndex();
  }

◆ operator!=() [6/8]

template<ContainerIdConcept CI>

bool columnar::operator!=	(	const OptObjectId< CI, ColumnarModeXAOD > &	lhs,
		const OptObjectId< CI, ColumnarModeXAOD > &	rhs )

Definition at line 100 of file OptObjectId.h.

  {
    return lhs.getXAODObjectNoexcept() != rhs.getXAODObjectNoexcept();
  }

◆ operator!=() [7/8]

template<ContainerIdConcept... CIList>

bool columnar::operator!=	(	const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	lhs,
		const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	rhs )

Definition at line 242 of file VariantOptObjectId.h.

  {
    return lhs.getVariantIndex() != rhs.getVariantIndex() || lhs.getObjectIndex() != rhs.getObjectIndex();
  }

◆ operator!=() [8/8]

template<ContainerIdConcept... CIList>

bool columnar::operator!=	(	const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	lhs,
		const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	rhs )

Definition at line 108 of file VariantOptObjectId.h.

  {
    return &lhs.getXAODObjectNoexcept() != &rhs.getXAODObjectNoexcept();
  }

◆ operator<<() [1/8]

template<ContainerIdConcept CI>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const ObjectId< CI, ColumnarModeArray > &	obj )

Definition at line 162 of file ObjectId.h.

  {
    return str << CI::idName << "/" << obj.getIndex();
  }

◆ operator<<() [2/8]

template<ContainerIdConcept CI>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const ObjectId< CI, ColumnarModeXAOD > &	obj )

Definition at line 76 of file ObjectId.h.

  {
    return str << &obj.getXAODObjectNoexcept() << "/" << obj.getXAODObjectNoexcept().index();
  }

◆ operator<<() [3/8]

template<ContainerIdConcept... CIList>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	obj )

Definition at line 189 of file VariantObjectId.h.

  {
    using CI = VariantContainerId<CIList...>;
    return str << CI::idNameArray.at(obj.getVariantIndex()) << "/" << obj.getObjectIndex();
  }

◆ operator<<() [4/8]

template<ContainerIdConcept... CIList>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	obj )

Definition at line 87 of file VariantObjectId.h.

  {
    return str << &obj.getXAODObjectNoexcept() << "/" << obj.getXAODObjectNoexcept().index();
  }

◆ operator<<() [5/8]

template<typename... CIList>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const ObjectLink< VariantContainerId< CIList... >, ColumnarModeArray > &	obj )

Definition at line 297 of file VariantLinkColumn.h.

  {
    return str << obj.getLinkKey() << "/" << obj.getLinkIndex();
  }

◆ operator<<() [6/8]

template<typename... CIList>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const ObjectLink< VariantContainerId< CIList... >, ColumnarModeXAOD > &	obj )

Definition at line 135 of file VariantLinkColumn.h.

  {
    return str << obj.getXAODObject() << "/" << obj.getXAODObject()->type();
  }

◆ operator<<() [7/8]

template<ContainerIdConcept... CIList>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	obj )

Definition at line 229 of file VariantOptObjectId.h.

  {
    using CI = VariantContainerId<CIList...>;
    return str << CI::idNameArray.at(obj.getVariantIndex()) << "/" << obj.getObjectIndex();
  }

◆ operator<<() [8/8]

template<ContainerIdConcept... CIList>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	obj )

Definition at line 96 of file VariantOptObjectId.h.

  {
    return str << &obj.getXAODObjectNoexcept() << "/" << obj.getXAODObjectNoexcept().index();
  }

◆ operator==() [1/8]

template<ContainerIdConcept CI>

bool columnar::operator==	(	const ObjectId< CI, ColumnarModeArray > &	lhs,
		const ObjectId< CI, ColumnarModeArray > &	rhs )

Definition at line 168 of file ObjectId.h.

  {
    return lhs.getIndex() == rhs.getIndex();
  }

◆ operator==() [2/8]

template<ContainerIdConcept CI>

bool columnar::operator==	(	const ObjectId< CI, ColumnarModeXAOD > &	lhs,
		const ObjectId< CI, ColumnarModeXAOD > &	rhs )

Definition at line 82 of file ObjectId.h.

  {
    return &lhs.getXAODObjectNoexcept() == &rhs.getXAODObjectNoexcept();
  }

◆ operator==() [3/8]

template<ContainerIdConcept... CIList>

bool columnar::operator==	(	const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	lhs,
		const ObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	rhs )

Definition at line 196 of file VariantObjectId.h.

  {
    return lhs.getVariantIndex() == rhs.getVariantIndex() && lhs.getObjectIndex() == rhs.getObjectIndex();
  }

◆ operator==() [4/8]

template<ContainerIdConcept... CIList>

bool columnar::operator==	(	const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	lhs,
		const ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	rhs )

Definition at line 93 of file VariantObjectId.h.

  {
    return &lhs.getXAODObjectNoexcept() == &rhs.getXAODObjectNoexcept();
  }

◆ operator==() [5/8]

template<ContainerIdConcept CI>

bool columnar::operator==	(	const OptObjectId< CI, ColumnarModeArray > &	lhs,
		const OptObjectId< CI, ColumnarModeArray > &	rhs )

Definition at line 198 of file OptObjectId.h.

  {
    return lhs.getIndex() == rhs.getIndex();
  }

◆ operator==() [6/8]

template<ContainerIdConcept CI>

bool columnar::operator==	(	const OptObjectId< CI, ColumnarModeXAOD > &	lhs,
		const OptObjectId< CI, ColumnarModeXAOD > &	rhs )

Definition at line 94 of file OptObjectId.h.

  {
    return lhs.getXAODObjectNoexcept() == rhs.getXAODObjectNoexcept();
  }

◆ operator==() [7/8]

template<ContainerIdConcept... CIList>

bool columnar::operator==	(	const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	lhs,
		const OptObjectId< VariantContainerId< CIList... >, ColumnarModeArray > &	rhs )

Definition at line 236 of file VariantOptObjectId.h.

  {
    return lhs.getVariantIndex() == rhs.getVariantIndex() && lhs.getObjectIndex() == rhs.getObjectIndex();
  }

◆ operator==() [8/8]

template<ContainerIdConcept... CIList>

bool columnar::operator==	(	const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	lhs,
		const OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD > &	rhs )

Definition at line 102 of file VariantOptObjectId.h.

  {
    return &lhs.getXAODObjectNoexcept() == &rhs.getXAODObjectNoexcept();
  }

◆ renameContainers()

void columnar::renameContainers	(	IColumnarTool &	tool,
		const std::vector< std::pair< std::string, std::string > > &	renames )

rename containers in the columnar tool

The interface itself only allows renaming individual columns, but sometimes it is nice to rename a whole container. This happens strictly on the basis of the name, i.e. it being prefixed with "Container.".

Definition at line 23 of file ColumnarToolHelpers.cxx.

  {
    if (!renames.empty())
    {
      auto columnInfo = tool.getColumnInfo ();
      for (auto& [from, to] : renames)
      {
        for (auto& column : columnInfo)
        {
          if (column.name.starts_with (from) && (column.name.size() == from.size() || column.name[from.size()] == '.'))
          {
            std::string newName = to + column.name.substr (from.size());
            tool.renameColumn (column.name, newName);
          }
        }
      }
    }
  }

◆ resetAccessor()

template<ContainerIdConcept CI, typename CT, ColumnAccessMode CAM, typename CM>

void columnar::resetAccessor	(	AccessorTemplate< CI, CT, CAM, CM > &	accessor,
		ColumnarTool< CM > &	columnBase,
		const std::string &	name,
		ColumnInfo &&	info = {} )

reset a column accessor to point to a new column

This allows users to have blank column accessors that only get initialized if they are actually used. This avoids the need to have accessors wrapped inside std::optional or similar constructs. Besides making accessor use slightly more consistent it should also make the code a little more efficient.

Definition at line 252 of file ColumnAccessor.h.

                                                                                                                                         {})
  {
    accessor = AccessorTemplate<CI,CT,CAM,CM> (columnBase, name, std::move (info));
  }

◆ resetEgamma()

template<ContainerIdConcept CI, typename CM>

void columnar::resetEgamma	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool )

Definition at line 361 of file MomentumAccessors.h.

361 {

362 resetPtEtaPhiReadM (accessors, columnarTool); }

columnar::resetPtEtaPhiReadM

void resetPtEtaPhiReadM(MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool)

Definition MomentumAccessors.h:343

◆ resetElectron()

template<ContainerIdConcept CI, typename CM>

void columnar::resetElectron	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool )

Definition at line 355 of file MomentumAccessors.h.

355 {

356 resetPtEtaPhiFixedM (accessors, columnarTool, ParticleConstants::electronMassInMeV); }

ParticleConstants::PDG2011::electronMassInMeV

constexpr double electronMassInMeV

the mass of the electron (in MeV)

Definition ParticleConstants.h:26

columnar::resetPtEtaPhiFixedM

void resetPtEtaPhiFixedM(MomentumAccessors< CI, CM > &accessors, ColumnarTool< CM > &columnarTool, double mValue)

Definition MomentumAccessors.h:346

◆ resetIParticle()

template<ContainerIdConcept CI, typename CM>

void columnar::resetIParticle ( MomentumAccessors< CI, CM > & accessors )

reset the dynamic momentum accessors to various default implementations

These are convenience functions to avoid the user having to know how a specific particle type is implemented. I decided to make them standalone functions, as that makes it seamless to define further specializations if needed in other packages. In particular tracking momentum accessors need some enums from xAODTracking for the xAOD hypothesis, which I don't want to include here.

Definition at line 340 of file MomentumAccessors.h.

340 {

341 accessors.reset (std::in_place_type<Detail::MomentumAccessorsIParticle<CI,CM>>); }

columnar::Detail::MomentumAccessorsIParticle

columnar momentum accessors that redirect to the xAOD::IParticle interface internally

Definition MomentumAccessors.h:93

◆ resetJet()

template<ContainerIdConcept CI, typename CM>

void columnar::resetJet	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool )

Definition at line 349 of file MomentumAccessors.h.

349 {

350 resetPtEtaPhiReadM (accessors, columnarTool); }

◆ resetJetConstituentScale()

template<ContainerIdConcept CI, typename CM>

void columnar::resetJetConstituentScale	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool,
		const std::string &	prefix = "JetConstitScaleMomentum_" )

Definition at line 352 of file MomentumAccessors.h.

352 {

353 accessors.reset (std::in_place_type<Detail::FullMomentumAccessorsPtEtaPhiM<Detail::CoreMomentumAccessorsPtEtaPhiReadM<CI,CM>>>, columnarTool, prefix); }

columnar::Detail::FullMomentumAccessorsPtEtaPhiM

generic columnar momentum accessors that use a pt, eta, phi, m representation underneath

Definition MomentumAccessors.h:125

columnar::Detail::CoreMomentumAccessorsPtEtaPhiReadM

a core momentum accessor that reads pt, eta, phi, and m from the file

Definition MomentumAccessors.h:183

◆ resetMuon()

template<ContainerIdConcept CI, typename CM>

void columnar::resetMuon	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool )

Definition at line 364 of file MomentumAccessors.h.

364 {

365 resetPtEtaPhiFixedM (accessors, columnarTool, ParticleConstants::muonMassInMeV); }

ParticleConstants::PDG2011::muonMassInMeV

constexpr double muonMassInMeV

the mass of the muon (in MeV)

Definition ParticleConstants.h:29

◆ resetObjectType()

template<ContainerIdConcept CI, typename CM>

void columnar::resetObjectType	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool,
		xAODType::ObjectType	type )

Definition at line 371 of file MomentumAccessors.h.

  {
    switch (type)
    {
      case xAODType::ObjectType::Electron:
        resetElectron (accessors, columnarTool);
        break;
      case xAODType::ObjectType::Photon:
        resetPhoton (accessors, columnarTool);
        break;
      case xAODType::ObjectType::Muon:
        resetMuon (accessors, columnarTool);
        break;
      case xAODType::ObjectType::Tau:
        resetTau (accessors, columnarTool);
        break;
      case xAODType::ObjectType::Jet:
        resetJet (accessors, columnarTool);
        break;
      default:
        throw std::runtime_error ("Unknown object type for momentum accessors: " + std::to_string(static_cast<unsigned>(type)));
    }
  }

◆ resetPhoton()

template<ContainerIdConcept CI, typename CM>

void columnar::resetPhoton	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool )

Definition at line 358 of file MomentumAccessors.h.

358 {

359 resetPtEtaPhiFixedM (accessors, columnarTool, ParticleConstants::photonMassInMeV); }

ParticleConstants::photonMassInMeV

constexpr double photonMassInMeV

various mass-less particles

Definition ParticleConstants.h:136

◆ resetPtEtaPhiFixedM()

template<ContainerIdConcept CI, typename CM>

void columnar::resetPtEtaPhiFixedM	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool,
		double	mValue )

Definition at line 346 of file MomentumAccessors.h.

346 {

347 accessors.reset (std::in_place_type<Detail::FullMomentumAccessorsPtEtaPhiM<Detail::CoreMomentumAccessorsPtEtaPhiFixedM<CI,CM>>>, columnarTool, mValue); }

columnar::Detail::CoreMomentumAccessorsPtEtaPhiFixedM

a core momentum accessor that reads pt, eta, phi from the file, but uses a fixed value for m

Definition MomentumAccessors.h:199

◆ resetPtEtaPhiReadM()

template<ContainerIdConcept CI, typename CM>

void columnar::resetPtEtaPhiReadM	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool )

Definition at line 343 of file MomentumAccessors.h.

343 {

344 accessors.reset (std::in_place_type<Detail::FullMomentumAccessorsPtEtaPhiM<Detail::CoreMomentumAccessorsPtEtaPhiReadM<CI,CM>>>, columnarTool); }

◆ resetTau()

template<ContainerIdConcept CI, typename CM>

void columnar::resetTau	(	MomentumAccessors< CI, CM > &	accessors,
		ColumnarTool< CM > &	columnarTool )

Definition at line 367 of file MomentumAccessors.h.

367 {

368 resetPtEtaPhiReadM (accessors, columnarTool); }

Variable Documentation

◆ columnarAccessMode

unsigned columnar::columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE

constexpr

Definition at line 15 of file ColumnarDef.h.

◆ invalidObjectIndex

ColumnarOffsetType columnar::invalidObjectIndex = static_cast<ColumnarOffsetType>(-1)

inlineconstexpr

the value for an invalid element index

This is mostly used for invalid element links

Definition at line 25 of file IColumnarTool.h.

◆ numberOfEventsName

const std::string columnar::numberOfEventsName = "EventInfo"

inline

the name used for the column containing the number of events

Essentially this shows up in a large number of places, and I'm not sure what the best name for it is. I'm currently using "EventInfo", because technically it is the number of EventInfo objects the data has. I'm pretty sure that this will be confusing to many people.

Todo: Find a better name than "EventInfo".

Definition at line 38 of file IColumnarTool.h.

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Detailed Description

Includes

Typedef Documentation

◆ ClusterAccessor

◆ ClusterDecorator

◆ ClusterId

◆ ColumnAccessor

◆ ColumnarModeDefault

◆ ColumnarOffsetType

◆ ColumnDecorator

◆ ColumnUpdater

◆ EgammaAccessor

◆ EgammaDecorator

◆ EgammaId

◆ EgammaRange

◆ ElectronAccessor

◆ ElectronDecorator

◆ ElectronId

◆ ElectronRange

◆ EventContextId

◆ EventContextRange

◆ EventInfoAccessor

◆ EventInfoDecorator

◆ EventInfoId

◆ EventInfoRange

◆ JetAccessor

◆ JetDecorator

◆ JetId

◆ JetRange

◆ Met0Accessor

◆ Met0Decorator

◆ Met0Id

◆ Met0Range

◆ Met1Accessor

◆ Met1Decorator

◆ Met1Id

◆ Met1Range

◆ MetAccessor

◆ MetAssociationId

◆ MetAssociationRange

◆ MetDecorator

◆ MetId

◆ MetRange

◆ MuonAccessor

◆ MuonDecorator

◆ MuonId

◆ MuonRange

◆ MuonTrackDef

◆ MutableEgammaAccessor

◆ MutableEgammaDecorator

◆ MutableEgammaId

◆ MutableEgammaRange

◆ MutableJetAccessor

◆ MutableJetDecorator

◆ MutableJetId

◆ MutableJetRange

◆ MutableJetUpdater

◆ MutableMetAccessor

◆ MutableMetDecorator

◆ MutableMetId

◆ MutableMetRange

◆ OptClusterId

◆ OptEgammaId

◆ OptElectronId

◆ OptEventInfoId

◆ OptJetId

◆ OptMet0Id

◆ OptMet1Id

◆ OptMetAssociationId

◆ OptMetId

◆ OptMuonId

◆ OptMutableEgammaId

◆ OptMutableJetId