Namespaces
namespace	ClusterHelpers
namespace	detail
	Container id definitions for the columnar infrastructure.
namespace	Detail
namespace	EgammaHelpers
namespace	EventInfoHelpers
namespace	MetHelperDefs
namespace	MetHelpers
namespace	TestUtils
namespace	TrackHelpers

Classes
struct	ClusterDef
struct	ColumnAccessorOptions
struct	ColumnAccessModeTraits
struct	ColumnAccessModeTraits< ColumnAccessMode::input >
struct	ColumnAccessModeTraits< ColumnAccessMode::output >
struct	ColumnAccessModeTraits< ColumnAccessMode::update >
class	AccessorTemplate
	the raw column accessor template class More...
struct	NativeColumn
	a type wrapper to force AccessorTemplate to treat the type as native More...
struct	RetypeColumn
	a type wrapper to make AccessorTemplate convert the underlying column type to a different type More...
class	ColumnarTool
	the base class for all columnar components More...
struct	ColumnAccessorDataArray
	all the data about a column accessor that the ColumnarTool needs to know about More...
struct	ColumnarModeXAOD
struct	ColumnarModeArray
struct	ColumnarModeXAODArray
struct	ColumnDataArray
struct	ColumnarToolDataArray
struct	RegularContainerId
	a template that provides a base definition of container id for a regular container More...
struct	MutableContainerId
	a template to define a mutable version of a given container id More...
struct	EventContextDef
class	ObjectRange
	a class representing a continuous sequence of objects (a.k.a. a container) More...
class	ObjectId
	a class representing a single object (electron, muons, etc.) More...
class	OptObjectId
	a class representing a single optional object (electron, muons, etc.) More...
class	ObjectLink
struct	LinkCastColumn
	a special column type that behaves like an OptObjectId, but applies an internal cast in xAOD mode More...
class	MomentumAccessors
	a handle to hold a IMomentumAccessors object More...
struct	ObjectColumn
	a special type to use for columns accessing containers/offset maps More...
class	ObjectId< CI, ColumnarModeXAOD >
class	ObjectId< CI, CM >
class	ObjectRangeIteratorXAODContainer
class	ObjectRange< CI, ColumnarModeXAOD >
class	ObjectRangeIteratorXAODSinglet
class	ObjectRangeIteratorArray
	an iterator over objects in an ObjectRange More...
class	ObjectRange< CI, CM >
class	ObjectTypeAccessor
	a specialized accessor for retrieving the xAOD object type of objects More...
class	OptObjectId< CI, ColumnarModeXAOD >
class	OptObjectId< CI, CM >
struct	ParticleDef
struct	Particle1Def
struct	Particle2Def
struct	ElectronDef
struct	PhotonDef
struct	EgammaDef
struct	EventInfoDef
class	ConfigurableColumnExampleTool
	example of a columnar tool with optional columns More...
class	LinkColumnExampleTool
	an example of a tool reading an element link 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	OptionalColumnExampleTool
	example of a columnar tool with optional columns 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	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...
class	ColumnarLinkTool
	a columnar tool to merge the two components of an element link into the proper repesentation for columnar More...
struct	ColumnInfo
	a struct that contains meta-information about each column that's needed to interface the column with the columnar data store More...
class	IColumnarTool
	an interface for tools that operate on columnar data More...
struct	JetDef
class	FilterRange
	a simple range adaptor that filters the elements of a range More...
class	FilterRangeIterator
class	MetAssociationHelper
	a columnar version of xAOD::MissingETAssociationHelper More...
class	MetAssocationAccessors
	the accessors MetAssociationHelper needs to implement its operations More...
struct	MetDef
struct	Met1Def
struct	MetAssociationDef
struct	MuonDef
struct	DiTauJetDef
struct	TauJetDef
struct	ColumnarMemoryTest
struct	ColumnarPhysLiteTest
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	ColumnVectorData
	a class that holds the columnar data for a single call More...
class	ToolColumnVectorMap
	a class that interfaces an IColumnarTool to a ColumnVectorHeader More...
class	PythonToolHandle
	a handle to a python tool for use via nanobind More...
struct	TrackDef
struct	Track1Def
struct	Track2Def
struct	Track3Def
struct	VertexDef
struct	TruthParticleDef
class	AccessorTemplate< VariantContainerId< CIBase, CIList... >, CT, CAM, CM >
struct	VariantContainerId
	a "variant" ContainerId More...
class	ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeXAOD >
	a "variant" link to a single object More...
class	ObjectLink< VariantContainerId< CIBase, CIList... >, CM >
class	ObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD >
class	ObjectId< VariantContainerId< CIList... >, CM >
class	OptObjectId< VariantContainerId< CIList... >, ColumnarModeXAOD >
class	OptObjectId< VariantContainerId< CIList... >, CM >

Concepts
concept	ColumnarMode
concept	ColumnarArrayMode
concept	ContainerIdConcept
	concept for a container id
concept	RegularContainerIdConcept

Typedefs
using	ClusterId = ObjectId<ClusterDef>
using	OptClusterId = OptObjectId<ClusterDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	ClusterAccessor = AccessorTemplate<ClusterDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	ClusterDecorator = AccessorTemplate<ClusterDef,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<EventContextDef>
using	EventContextId = ObjectId<EventContextDef>
using	Particle0Def = ParticleDef
using	ParticleRange = ObjectRange<ParticleDef>
using	ParticleId = ObjectId<ParticleDef>
using	OptParticleId = OptObjectId<ParticleDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	ParticleAccessor = AccessorTemplate<ParticleDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	ParticleDecorator = AccessorTemplate<ParticleDef,CT,ColumnAccessMode::output,CM>
using	Particle0Range = ObjectRange<Particle0Def>
using	Particle0Id = ObjectId<Particle0Def>
using	OptParticle0Id = OptObjectId<Particle0Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle0Accessor = AccessorTemplate<Particle0Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle0Decorator = AccessorTemplate<Particle0Def,CT,ColumnAccessMode::output,CM>
using	Particle1Range = ObjectRange<Particle1Def>
using	Particle1Id = ObjectId<Particle1Def>
using	OptParticle1Id = OptObjectId<Particle1Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle1Accessor = AccessorTemplate<Particle1Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle1Decorator = AccessorTemplate<Particle1Def,CT,ColumnAccessMode::output,CM>
using	Particle2Range = ObjectRange<Particle2Def>
using	Particle2Id = ObjectId<Particle2Def>
using	OptParticle2Id = OptObjectId<Particle2Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle2Accessor = AccessorTemplate<Particle2Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Particle2Decorator = AccessorTemplate<Particle2Def,CT,ColumnAccessMode::output,CM>
using	MutableEgammaDef = MutableContainerId<EgammaDef>
using	ElectronRange = ObjectRange<ElectronDef>
using	ElectronId = ObjectId<ElectronDef>
using	OptElectronId = OptObjectId<ElectronDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	ElectronAccessor = AccessorTemplate<ElectronDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	ElectronDecorator = AccessorTemplate<ElectronDef,CT,ColumnAccessMode::output,CM>
using	PhotonRange = ObjectRange<PhotonDef>
using	PhotonId = ObjectId<PhotonDef>
using	OptPhotonId = OptObjectId<PhotonDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	PhotonAccessor = AccessorTemplate<PhotonDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	PhotonDecorator = AccessorTemplate<PhotonDef,CT,ColumnAccessMode::output,CM>
using	EgammaRange = ObjectRange<EgammaDef>
using	EgammaId = ObjectId<EgammaDef>
using	OptEgammaId = OptObjectId<EgammaDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	EgammaAccessor = AccessorTemplate<EgammaDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	EgammaDecorator = AccessorTemplate<EgammaDef,CT,ColumnAccessMode::output,CM>
using	MutableEgammaRange = ObjectRange<MutableEgammaDef>
using	MutableEgammaId = ObjectId<MutableEgammaDef>
using	OptMutableEgammaId = OptObjectId<MutableEgammaDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableEgammaAccessor = AccessorTemplate<MutableEgammaDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableEgammaDecorator = AccessorTemplate<MutableEgammaDef,CT,ColumnAccessMode::output,CM>
using	EventInfoRange = ObjectRange<EventInfoDef>
using	EventInfoId = ObjectId<EventInfoDef>
using	OptEventInfoId = OptObjectId<EventInfoDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	EventInfoAccessor = AccessorTemplate<EventInfoDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	EventInfoDecorator = AccessorTemplate<EventInfoDef,CT,ColumnAccessMode::output,CM>
using	ColumnarOffsetType = std::size_t
	the type used for the size and offsets in the columnar data
using	MutableJetDef = MutableContainerId<JetDef>
using	JetRange = ObjectRange<JetDef>
using	JetId = ObjectId<JetDef>
using	OptJetId = OptObjectId<JetDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	JetAccessor = AccessorTemplate<JetDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	JetDecorator = AccessorTemplate<JetDef,CT,ColumnAccessMode::output,CM>
using	MutableJetRange = ObjectRange<MutableJetDef>
using	MutableJetId = ObjectId<MutableJetDef>
using	OptMutableJetId = OptObjectId<MutableJetDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableJetAccessor = AccessorTemplate<MutableJetDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableJetDecorator = AccessorTemplate<MutableJetDef,CT,ColumnAccessMode::output,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableJetUpdater = AccessorTemplate<MutableJetDef,CT,ColumnAccessMode::update,CM>
using	Met0Def = MetDef
using	MutableMetDef = MutableContainerId<MetDef>
using	MetRange = ObjectRange<MetDef>
using	MetId = ObjectId<MetDef>
using	OptMetId = OptObjectId<MetDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	MetAccessor = AccessorTemplate<MetDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MetDecorator = AccessorTemplate<MetDef,CT,ColumnAccessMode::output,CM>
using	Met0Range = ObjectRange<Met0Def>
using	Met0Id = ObjectId<Met0Def>
using	OptMet0Id = OptObjectId<Met0Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met0Accessor = AccessorTemplate<Met0Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met0Decorator = AccessorTemplate<Met0Def,CT,ColumnAccessMode::output,CM>
using	Met1Range = ObjectRange<Met1Def>
using	Met1Id = ObjectId<Met1Def>
using	OptMet1Id = OptObjectId<Met1Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met1Accessor = AccessorTemplate<Met1Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Met1Decorator = AccessorTemplate<Met1Def,CT,ColumnAccessMode::output,CM>
using	MutableMetRange = ObjectRange<MutableMetDef>
using	MutableMetId = ObjectId<MutableMetDef>
using	OptMutableMetId = OptObjectId<MutableMetDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableMetAccessor = AccessorTemplate<MutableMetDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MutableMetDecorator = AccessorTemplate<MutableMetDef,CT,ColumnAccessMode::output,CM>
using	MetAssociationRange = ObjectRange<MetAssociationDef>
using	MetAssociationId = ObjectId<MetAssociationDef>
using	OptMetAssociationId = OptObjectId<MetAssociationDef>
using	MuonRange = ObjectRange<MuonDef>
using	MuonId = ObjectId<MuonDef>
using	OptMuonId = OptObjectId<MuonDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	MuonAccessor = AccessorTemplate<MuonDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	MuonDecorator = AccessorTemplate<MuonDef,CT,ColumnAccessMode::output,CM>
using	MuonTrackDef = columnar::VariantContainerId<columnar::Track0Def,columnar::Track0Def,columnar::Track3Def,columnar::Track1Def,columnar::Track2Def>
using	DiTauJetRange = ObjectRange<DiTauJetDef>
using	DiTauJetId = ObjectId<DiTauJetDef>
using	OptDiTauJetId = OptObjectId<DiTauJetDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	DiTauJetAccessor = AccessorTemplate<DiTauJetDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	DiTauJetDecorator = AccessorTemplate<DiTauJetDef,CT,ColumnAccessMode::output,CM>
using	TauJetRange = ObjectRange<TauJetDef>
using	TauJetId = ObjectId<TauJetDef>
using	OptTauJetId = OptObjectId<TauJetDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	TauJetAccessor = AccessorTemplate<TauJetDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	TauJetDecorator = AccessorTemplate<TauJetDef,CT,ColumnAccessMode::output,CM>
using	Track0Def = TrackDef
using	TrackId = ObjectId<TrackDef>
using	OptTrackId = OptObjectId<TrackDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	TrackAccessor = AccessorTemplate<TrackDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	TrackDecorator = AccessorTemplate<TrackDef,CT,ColumnAccessMode::output,CM>
using	OptTrack0Id = OptObjectId<Track0Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track0Accessor = AccessorTemplate<Track0Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track0Decorator = AccessorTemplate<Track0Def,CT,ColumnAccessMode::output,CM>
using	OptTrack1Id = OptObjectId<Track1Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track1Accessor = AccessorTemplate<Track1Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track1Decorator = AccessorTemplate<Track1Def,CT,ColumnAccessMode::output,CM>
using	OptTrack2Id = OptObjectId<Track2Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track2Accessor = AccessorTemplate<Track2Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track2Decorator = AccessorTemplate<Track2Def,CT,ColumnAccessMode::output,CM>
using	OptTrack3Id = OptObjectId<Track3Def>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track3Accessor = AccessorTemplate<Track3Def,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	Track3Decorator = AccessorTemplate<Track3Def,CT,ColumnAccessMode::output,CM>
using	VertexId = ObjectId<VertexDef>
using	OptVertexId = OptObjectId<VertexDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	VertexAccessor = AccessorTemplate<VertexDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	VertexDecorator = AccessorTemplate<VertexDef,CT,ColumnAccessMode::output,CM>
using	TruthParticleRange = ObjectRange<TruthParticleDef>
using	TruthParticleId = ObjectId<TruthParticleDef>
using	OptTruthParticleId = OptObjectId<TruthParticleDef>
template<typename CT, typename CM = ColumnarModeDefault>
using	TruthParticleAccessor = AccessorTemplate<TruthParticleDef,CT,ColumnAccessMode::input,CM>
template<typename CT, typename CM = ColumnarModeDefault>
using	TruthParticleDecorator = AccessorTemplate<TruthParticleDef,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, ColumnAccessorOptions &&options={})
	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)
SG::sgkey_t	computeSgKey (const std::string &name, std::uint32_t clid)
	compute the StoreGate hashed key for a container
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, ColumnarArrayMode CM>
std::ostream &	operator<< (std::ostream &str, const ObjectId< CI, CM > &obj)
template<ContainerIdConcept CI, ColumnarArrayMode CM>
bool	operator== (const ObjectId< CI, CM > &lhs, const ObjectId< CI, CM > &rhs)
template<ContainerIdConcept CI, ColumnarArrayMode CM>
bool	operator!= (const ObjectId< CI, CM > &lhs, const ObjectId< CI, CM > &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, ColumnarArrayMode CM>
bool	operator== (const OptObjectId< CI, CM > &lhs, const OptObjectId< CI, CM > &rhs)
template<ContainerIdConcept CI, ColumnarArrayMode CM>
bool	operator!= (const OptObjectId< CI, CM > &lhs, const OptObjectId< CI, CM > &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, ColumnarArrayMode CM>
std::ostream &	operator<< (std::ostream &str, const ObjectLink< VariantContainerId< CIList... >, CM > &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, ColumnarArrayMode CM>
std::ostream &	operator<< (std::ostream &str, const ObjectId< VariantContainerId< CIList... >, CM > &obj)
template<ContainerIdConcept... CIList, ColumnarArrayMode CM>
bool	operator== (const ObjectId< VariantContainerId< CIList... >, CM > &lhs, const ObjectId< VariantContainerId< CIList... >, CM > &rhs)
template<ContainerIdConcept... CIList, ColumnarArrayMode CM>
bool	operator!= (const ObjectId< VariantContainerId< CIList... >, CM > &lhs, const ObjectId< VariantContainerId< CIList... >, CM > &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, ColumnarArrayMode CM>
std::ostream &	operator<< (std::ostream &str, const OptObjectId< VariantContainerId< CIList... >, CM > &obj)
template<ContainerIdConcept... CIList, ColumnarArrayMode CM>
bool	operator== (const OptObjectId< VariantContainerId< CIList... >, CM > &lhs, const OptObjectId< VariantContainerId< CIList... >, CM > &rhs)
template<ContainerIdConcept... CIList, ColumnarArrayMode CM>
bool	operator!= (const OptObjectId< VariantContainerId< CIList... >, CM > &lhs, const OptObjectId< VariantContainerId< CIList... >, CM > &rhs)

Variables
constexpr unsigned	columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE
constexpr ColumnarOffsetType	invalidObjectIndex = static_cast<ColumnarOffsetType>(-1)
	the value for an invalid element index
constexpr std::string_view	eventContextCIName = "eventContext"
	the name for the event context container id
const std::string	eventRangeColumnName = "EventInfo"
	the default name for the column containing the event range
const std::unordered_map< std::string, SG::sgkey_t >	knownSgKeys
	lookup table from container name to its sgkey hash

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<ClusterDef,CT,ColumnAccessMode::input,CM>

Definition at line 25 of file ClusterDef.h.

◆ ClusterDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 26 of file ClusterDef.h.

◆ ClusterId

using columnar::ClusterId = ObjectId<ClusterDef>

Definition at line 23 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 274 of file ColumnAccessor.h.

◆ ColumnarModeDefault

using columnar::ColumnarModeDefault = ColumnarModeXAOD

Definition at line 224 of file ColumnarCore/ColumnarCore/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 19 of file ColumnarInterfaces/ColumnarInterfaces/ColumnarDef.h.

◆ ColumnDecorator

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

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

Definition at line 275 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 276 of file ColumnAccessor.h.

◆ DiTauJetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::DiTauJetAccessor = AccessorTemplate<DiTauJetDef,CT,ColumnAccessMode::input,CM>

Definition at line 24 of file DiTauJetDef.h.

◆ DiTauJetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::DiTauJetDecorator = AccessorTemplate<DiTauJetDef,CT,ColumnAccessMode::output,CM>

Definition at line 25 of file DiTauJetDef.h.

◆ DiTauJetId

using columnar::DiTauJetId = ObjectId<DiTauJetDef>

Definition at line 22 of file DiTauJetDef.h.

◆ DiTauJetRange

using columnar::DiTauJetRange = ObjectRange<DiTauJetDef>

Definition at line 21 of file DiTauJetDef.h.

◆ EgammaAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 49 of file EgammaDef.h.

◆ EgammaDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 50 of file EgammaDef.h.

◆ EgammaId

using columnar::EgammaId = ObjectId<EgammaDef>

Definition at line 47 of file EgammaDef.h.

◆ EgammaRange

using columnar::EgammaRange = ObjectRange<EgammaDef>

Definition at line 46 of file EgammaDef.h.

◆ ElectronAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 37 of file EgammaDef.h.

◆ ElectronDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 38 of file EgammaDef.h.

◆ ElectronId

using columnar::ElectronId = ObjectId<ElectronDef>

Definition at line 35 of file EgammaDef.h.

◆ ElectronRange

using columnar::ElectronRange = ObjectRange<ElectronDef>

Definition at line 34 of file EgammaDef.h.

◆ EventContextId

using columnar::EventContextId = ObjectId<EventContextDef>

Definition at line 212 of file ContainerId.h.

◆ EventContextRange

using columnar::EventContextRange = ObjectRange<EventContextDef>

Definition at line 211 of file ContainerId.h.

◆ EventInfoAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 34 of file EventInfoDef.h.

◆ EventInfoDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 35 of file EventInfoDef.h.

◆ EventInfoId

using columnar::EventInfoId = ObjectId<EventInfoDef>

Definition at line 32 of file EventInfoDef.h.

◆ EventInfoRange

using columnar::EventInfoRange = ObjectRange<EventInfoDef>

Definition at line 31 of file EventInfoDef.h.

◆ JetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 25 of file JetDef.h.

◆ JetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 26 of file JetDef.h.

◆ JetId

using columnar::JetId = ObjectId<JetDef>

Definition at line 23 of file JetDef.h.

◆ JetRange

using columnar::JetRange = ObjectRange<JetDef>

Definition at line 22 of file JetDef.h.

◆ Met0Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 55 of file MetDef.h.

◆ Met0Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 56 of file MetDef.h.

◆ Met0Def

using columnar::Met0Def = MetDef

Definition at line 33 of file MetDef.h.

◆ Met0Id

using columnar::Met0Id = ObjectId<Met0Def>

Definition at line 53 of file MetDef.h.

◆ Met0Range

using columnar::Met0Range = ObjectRange<Met0Def>

Definition at line 52 of file MetDef.h.

◆ Met1Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 61 of file MetDef.h.

◆ Met1Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 62 of file MetDef.h.

◆ Met1Id

using columnar::Met1Id = ObjectId<Met1Def>

Definition at line 59 of file MetDef.h.

◆ Met1Range

using columnar::Met1Range = ObjectRange<Met1Def>

Definition at line 58 of file MetDef.h.

◆ MetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 49 of file MetDef.h.

◆ MetAssociationId

using columnar::MetAssociationId = ObjectId<MetAssociationDef>

Definition at line 71 of file MetDef.h.

◆ MetAssociationRange

using columnar::MetAssociationRange = ObjectRange<MetAssociationDef>

Definition at line 70 of file MetDef.h.

◆ MetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 50 of file MetDef.h.

◆ MetId

using columnar::MetId = ObjectId<MetDef>

Definition at line 47 of file MetDef.h.

◆ MetRange

using columnar::MetRange = ObjectRange<MetDef>

Definition at line 46 of file MetDef.h.

◆ MuonAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 24 of file MuonDef.h.

◆ MuonDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 25 of file MuonDef.h.

◆ MuonId

using columnar::MuonId = ObjectId<MuonDef>

Definition at line 22 of file MuonDef.h.

◆ MuonRange

using columnar::MuonRange = ObjectRange<MuonDef>

Definition at line 21 of file MuonDef.h.

◆ MuonTrackDef

using columnar::MuonTrackDef = columnar::VariantContainerId<columnar::Track0Def,columnar::Track0Def,columnar::Track3Def,columnar::Track1Def,columnar::Track2Def>

Definition at line 18 of file MuonTrackHelpers.h.

◆ MutableEgammaAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 55 of file EgammaDef.h.

◆ MutableEgammaDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 56 of file EgammaDef.h.

◆ MutableEgammaDef

using columnar::MutableEgammaDef = MutableContainerId<EgammaDef>

Definition at line 32 of file EgammaDef.h.

◆ MutableEgammaId

using columnar::MutableEgammaId = ObjectId<MutableEgammaDef>

Definition at line 53 of file EgammaDef.h.

◆ MutableEgammaRange

using columnar::MutableEgammaRange = ObjectRange<MutableEgammaDef>

Definition at line 52 of file EgammaDef.h.

◆ MutableJetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 31 of file JetDef.h.

◆ MutableJetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 32 of file JetDef.h.

◆ MutableJetDef

using columnar::MutableJetDef = MutableContainerId<JetDef>

Definition at line 20 of file JetDef.h.

◆ MutableJetId

using columnar::MutableJetId = ObjectId<MutableJetDef>

Definition at line 29 of file JetDef.h.

◆ MutableJetRange

using columnar::MutableJetRange = ObjectRange<MutableJetDef>

Definition at line 28 of file JetDef.h.

◆ MutableJetUpdater

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 33 of file JetDef.h.

◆ MutableMetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 67 of file MetDef.h.

◆ MutableMetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 68 of file MetDef.h.

◆ MutableMetDef

using columnar::MutableMetDef = MutableContainerId<MetDef>

Definition at line 34 of file MetDef.h.

◆ MutableMetId

using columnar::MutableMetId = ObjectId<MutableMetDef>

Definition at line 65 of file MetDef.h.

◆ MutableMetRange

using columnar::MutableMetRange = ObjectRange<MutableMetDef>

Definition at line 64 of file MetDef.h.

◆ OptClusterId

using columnar::OptClusterId = OptObjectId<ClusterDef>

Definition at line 24 of file ClusterDef.h.

◆ OptDiTauJetId

using columnar::OptDiTauJetId = OptObjectId<DiTauJetDef>

Definition at line 23 of file DiTauJetDef.h.

◆ OptEgammaId

using columnar::OptEgammaId = OptObjectId<EgammaDef>

Definition at line 48 of file EgammaDef.h.

◆ OptElectronId

using columnar::OptElectronId = OptObjectId<ElectronDef>

Definition at line 36 of file EgammaDef.h.

◆ OptEventInfoId

using columnar::OptEventInfoId = OptObjectId<EventInfoDef>

Definition at line 33 of file EventInfoDef.h.

◆ OptJetId

using columnar::OptJetId = OptObjectId<JetDef>

Definition at line 24 of file JetDef.h.

◆ OptMet0Id

using columnar::OptMet0Id = OptObjectId<Met0Def>

Definition at line 54 of file MetDef.h.

◆ OptMet1Id

using columnar::OptMet1Id = OptObjectId<Met1Def>

Definition at line 60 of file MetDef.h.

◆ OptMetAssociationId

using columnar::OptMetAssociationId = OptObjectId<MetAssociationDef>

Definition at line 72 of file MetDef.h.

◆ OptMetId

using columnar::OptMetId = OptObjectId<MetDef>

Definition at line 48 of file MetDef.h.

◆ OptMuonId

using columnar::OptMuonId = OptObjectId<MuonDef>

Definition at line 23 of file MuonDef.h.

◆ OptMutableEgammaId

using columnar::OptMutableEgammaId = OptObjectId<MutableEgammaDef>

Definition at line 54 of file EgammaDef.h.

◆ OptMutableJetId

using columnar::OptMutableJetId = OptObjectId<MutableJetDef>

Definition at line 30 of file JetDef.h.

◆ OptMutableMetId

using columnar::OptMutableMetId = OptObjectId<MutableMetDef>

Definition at line 66 of file MetDef.h.

◆ OptParticle0Id

using columnar::OptParticle0Id = OptObjectId<Particle0Def>

Definition at line 40 of file ParticleDef.h.

◆ OptParticle1Id

using columnar::OptParticle1Id = OptObjectId<Particle1Def>

Definition at line 46 of file ParticleDef.h.

◆ OptParticle2Id

using columnar::OptParticle2Id = OptObjectId<Particle2Def>

Definition at line 52 of file ParticleDef.h.

◆ OptParticleId

using columnar::OptParticleId = OptObjectId<ParticleDef>

Definition at line 34 of file ParticleDef.h.

◆ OptPhotonId

using columnar::OptPhotonId = OptObjectId<PhotonDef>

Definition at line 42 of file EgammaDef.h.

◆ OptTauJetId

using columnar::OptTauJetId = OptObjectId<TauJetDef>

Definition at line 23 of file TauJetDef.h.

◆ OptTrack0Id

using columnar::OptTrack0Id = OptObjectId<Track0Def>

Definition at line 48 of file TrackDef.h.

◆ OptTrack1Id

using columnar::OptTrack1Id = OptObjectId<Track1Def>

Definition at line 52 of file TrackDef.h.

◆ OptTrack2Id

using columnar::OptTrack2Id = OptObjectId<Track2Def>

Definition at line 56 of file TrackDef.h.

◆ OptTrack3Id

using columnar::OptTrack3Id = OptObjectId<Track3Def>

Definition at line 60 of file TrackDef.h.

◆ OptTrackId

using columnar::OptTrackId = OptObjectId<TrackDef>

Definition at line 44 of file TrackDef.h.

◆ OptTruthParticleId

using columnar::OptTruthParticleId = OptObjectId<TruthParticleDef>

Definition at line 23 of file TruthParticleDef.h.

◆ OptVertexId

using columnar::OptVertexId = OptObjectId<VertexDef>

Definition at line 65 of file TrackDef.h.

◆ Particle0Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 41 of file ParticleDef.h.

◆ Particle0Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 42 of file ParticleDef.h.

◆ Particle0Def

using columnar::Particle0Def = ParticleDef

Definition at line 20 of file ParticleDef.h.

◆ Particle0Id

using columnar::Particle0Id = ObjectId<Particle0Def>

Definition at line 39 of file ParticleDef.h.

◆ Particle0Range

using columnar::Particle0Range = ObjectRange<Particle0Def>

Definition at line 38 of file ParticleDef.h.

◆ Particle1Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 47 of file ParticleDef.h.

◆ Particle1Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 48 of file ParticleDef.h.

◆ Particle1Id

using columnar::Particle1Id = ObjectId<Particle1Def>

Definition at line 45 of file ParticleDef.h.

◆ Particle1Range

using columnar::Particle1Range = ObjectRange<Particle1Def>

Definition at line 44 of file ParticleDef.h.

◆ Particle2Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 53 of file ParticleDef.h.

◆ Particle2Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 54 of file ParticleDef.h.

◆ Particle2Id

using columnar::Particle2Id = ObjectId<Particle2Def>

Definition at line 51 of file ParticleDef.h.

◆ Particle2Range

using columnar::Particle2Range = ObjectRange<Particle2Def>

Definition at line 50 of file ParticleDef.h.

◆ ParticleAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 35 of file ParticleDef.h.

◆ ParticleDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 36 of file ParticleDef.h.

◆ ParticleId

using columnar::ParticleId = ObjectId<ParticleDef>

Definition at line 33 of file ParticleDef.h.

◆ ParticleRange

using columnar::ParticleRange = ObjectRange<ParticleDef>

Definition at line 32 of file ParticleDef.h.

◆ PhotonAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 43 of file EgammaDef.h.

◆ PhotonDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 44 of file EgammaDef.h.

◆ PhotonId

using columnar::PhotonId = ObjectId<PhotonDef>

Definition at line 41 of file EgammaDef.h.

◆ PhotonRange

using columnar::PhotonRange = ObjectRange<PhotonDef>

Definition at line 40 of file EgammaDef.h.

◆ TauJetAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 24 of file TauJetDef.h.

◆ TauJetDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 25 of file TauJetDef.h.

◆ TauJetId

using columnar::TauJetId = ObjectId<TauJetDef>

Definition at line 22 of file TauJetDef.h.

◆ TauJetRange

using columnar::TauJetRange = ObjectRange<TauJetDef>

Definition at line 21 of file TauJetDef.h.

◆ Track0Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 49 of file TrackDef.h.

◆ Track0Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 50 of file TrackDef.h.

◆ Track0Def

using columnar::Track0Def = TrackDef

Definition at line 21 of file TrackDef.h.

◆ Track1Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 53 of file TrackDef.h.

◆ Track1Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 54 of file TrackDef.h.

◆ Track2Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 57 of file TrackDef.h.

◆ Track2Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 58 of file TrackDef.h.

◆ Track3Accessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 61 of file TrackDef.h.

◆ Track3Decorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 62 of file TrackDef.h.

◆ TrackAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 45 of file TrackDef.h.

◆ TrackDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 46 of file TrackDef.h.

◆ TrackId

using columnar::TrackId = ObjectId<TrackDef>

Definition at line 43 of file TrackDef.h.

◆ TruthParticleAccessor

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::TruthParticleAccessor = AccessorTemplate<TruthParticleDef,CT,ColumnAccessMode::input,CM>

Definition at line 24 of file TruthParticleDef.h.

◆ TruthParticleDecorator

template<typename CT, typename CM = ColumnarModeDefault>

using columnar::TruthParticleDecorator = AccessorTemplate<TruthParticleDef,CT,ColumnAccessMode::output,CM>

Definition at line 25 of file TruthParticleDef.h.

◆ TruthParticleId

using columnar::TruthParticleId = ObjectId<TruthParticleDef>

Definition at line 22 of file TruthParticleDef.h.

◆ TruthParticleRange

using columnar::TruthParticleRange = ObjectRange<TruthParticleDef>

Definition at line 21 of file TruthParticleDef.h.

◆ VertexAccessor

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 66 of file TrackDef.h.

◆ VertexDecorator

template<typename CT, typename CM = ColumnarModeDefault>

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

Definition at line 67 of file TrackDef.h.

◆ VertexId

using columnar::VertexId = ObjectId<VertexDef>

Definition at line 64 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 19 of file ColumnInfo.h.

  {
    input,
    output,
    update
  };

Function Documentation

◆ addColumnAccessMode()

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

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

◆ computeSgKey()

SG::sgkey_t columnar::computeSgKey	(	const std::string &	name,
		std::uint32_t	clid )

nodiscard

compute the StoreGate hashed key for a container

This reproduces SG::StringPool::stringToKey (SGTools), which is how Athena computes the keys stored as m_persKey for persistified element links: the crc64 of the container name, extended with the container CLID, masked to 30 bits. SGTools itself is not available in AnalysisBase-style releases, hence this local implementation on top of CxxUtils.

Together with ColumnInfo::soleLinkTargetClid this allows computing the expected m_persKey for a link column's target at runtime instead of hard-coding the values.

Definition at line 85 of file ColumnInfoHelpers.cxx.

  {
    std::uint64_t crc = CxxUtils::crc64 (name);
    if (clid != 0)
      crc = CxxUtils::crc64addint (crc, clid);
    // mask to SG::StringPool::sgkey_t_nbits (30) bits
    return static_cast<SG::sgkey_t> (crc & ((static_cast<std::uint64_t> (1) << 30) - 1));
  }

◆ 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 36 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.index != source.index)
      throw std::runtime_error ("mismatched column index in mergeColumnInfo: " + std::to_string(target.index) + " and " + std::to_string(source.index));
 
    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.soleLinkTargetName != source.soleLinkTargetName)
      throw std::runtime_error ("mismatched soleLinkTargetName in mergeColumnInfo for column: " + target.name);
 
    if (target.soleLinkTargetClid != source.soleLinkTargetClid)
      throw std::runtime_error ("mismatched soleLinkTargetClid in mergeColumnInfo for column: " + target.name);
 
    if (target.isVariantLink != source.isVariantLink)
      throw std::runtime_error ("mismatched isVariantLink in mergeColumnInfo for column: " + target.name);
 
    if (target.variantLinkTargetNames != source.variantLinkTargetNames)
      throw std::runtime_error ("mismatched variantLinkTargetNames in mergeColumnInfo for column: " + target.name);
 
    if (target.keyColumnForVariantLink != source.keyColumnForVariantLink)
      throw std::runtime_error ("mismatched keyColumnForVariantLink in mergeColumnInfo for column: " + target.name + ": " + target.keyColumnForVariantLink + " and " + source.keyColumnForVariantLink);
  }

◆ 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, ColumnarArrayMode CM>

bool columnar::operator!=	(	const ObjectId< CI, CM > &	lhs,
		const ObjectId< CI, CM > &	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, ColumnarArrayMode CM>

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

Definition at line 201 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, ColumnarArrayMode CM>

bool columnar::operator!=	(	const OptObjectId< CI, CM > &	lhs,
		const OptObjectId< CI, CM > &	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, ColumnarArrayMode CM>

bool columnar::operator!=	(	const OptObjectId< VariantContainerId< CIList... >, CM > &	lhs,
		const OptObjectId< VariantContainerId< CIList... >, CM > &	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, ColumnarArrayMode CM>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const ObjectId< CI, CM > &	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, ColumnarArrayMode CM>

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

Definition at line 188 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, ColumnarArrayMode CM>

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

Definition at line 313 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, ColumnarArrayMode CM>

std::ostream & columnar::operator<<	(	std::ostream &	str,
		const OptObjectId< VariantContainerId< CIList... >, CM > &	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, ColumnarArrayMode CM>

bool columnar::operator==	(	const ObjectId< CI, CM > &	lhs,
		const ObjectId< CI, CM > &	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, ColumnarArrayMode CM>

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

Definition at line 195 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, ColumnarArrayMode CM>

bool columnar::operator==	(	const OptObjectId< CI, CM > &	lhs,
		const OptObjectId< CI, CM > &	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, ColumnarArrayMode CM>

bool columnar::operator==	(	const OptObjectId< VariantContainerId< CIList... >, CM > &	lhs,
		const OptObjectId< VariantContainerId< CIList... >, CM > &	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,
		ColumnAccessorOptions &&	options = {} )

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 265 of file ColumnAccessor.h.

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

◆ 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 ColumnarCore/ColumnarCore/ColumnarDef.h.

◆ eventContextCIName

std::string_view columnar::eventContextCIName = "eventContext"

inlineconstexpr

the name for the event context container id

Definition at line 28 of file ColumnarInterfaces/ColumnarInterfaces/ColumnarDef.h.

◆ eventRangeColumnName

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

inline

the default name for the column containing the event range

This is used in quite a few places, so I'm defining it here to make it visible everywhere. 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.

Definition at line 37 of file ColumnarInterfaces/ColumnarInterfaces/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 24 of file ColumnarInterfaces/ColumnarInterfaces/ColumnarDef.h.

◆ knownSgKeys

const std::unordered_map<std::string,SG::sgkey_t> columnar::knownSgKeys

inline

Initial value:

                                            =
{
  {"AnalysisMuons", 0x3a6b126f},
  {"AnalysisElectrons", 0x3902fec0},
  {"AnalysisPhotons", 0x35d1472f},
  {"AnalysisJets", 0x1afd1919},
  {"egammaClusters", 0x15788d1f},
  {"GSFConversionVertices", 0x1f3e85c9},
  {"InDetTrackParticles", 0x1d3890db},
  {"CombinedMuonTrackParticles", 0x340d9196},
  {"ExtrapolatedMuonTrackParticles", 0x14e35e9f},
  {"GSFTrackParticles", 0x2e42db0b},
  {"InDetForwardTrackParticles", 0x143c6846},
  {"MuonSpectrometerTrackParticles", 0x3993c8f3},
}

lookup table from container name to its sgkey hash

This is shared between the columnar test fixtures and the columnar helper tools, so that both use the same source of truth when translating a raw sgkey read from an xAOD file into the compact key used by the columnar variant-link representation.

The keys are calculated as crc64(name) extended with the container CLID and masked to 30 bits (see computeSgKey, which reproduces SG::StringPool::stringToKey). For sole-target link columns python computes the keys from ColumnInfo::soleLinkTargetClid. This table is used in situations in which the container type (and with it the CLID) is not readily available.

Definition at line 32 of file KnownSgKeys.h.

                                                                   {
    {"AnalysisMuons", 0x3a6b126f},
    {"AnalysisElectrons", 0x3902fec0},
    {"AnalysisPhotons", 0x35d1472f},
    {"AnalysisJets", 0x1afd1919},
    {"egammaClusters", 0x15788d1f},
    {"GSFConversionVertices", 0x1f3e85c9},
    {"InDetTrackParticles", 0x1d3890db},
    {"CombinedMuonTrackParticles", 0x340d9196},
    {"ExtrapolatedMuonTrackParticles", 0x14e35e9f},
    {"GSFTrackParticles", 0x2e42db0b},
    {"InDetForwardTrackParticles", 0x143c6846},
    {"MuonSpectrometerTrackParticles", 0x3993c8f3},
  };

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Detailed Description

Includes

Typedef Documentation

◆ ClusterAccessor

◆ ClusterDecorator

◆ ClusterId

◆ ColumnAccessor

◆ ColumnarModeDefault

◆ ColumnarOffsetType

◆ ColumnDecorator

◆ ColumnUpdater

◆ DiTauJetAccessor

◆ DiTauJetDecorator

◆ DiTauJetId

◆ DiTauJetRange

◆ EgammaAccessor

◆ EgammaDecorator

◆ EgammaId

◆ EgammaRange

◆ ElectronAccessor

◆ ElectronDecorator

◆ ElectronId

◆ ElectronRange

◆ EventContextId

◆ EventContextRange

◆ EventInfoAccessor

◆ EventInfoDecorator

◆ EventInfoId

◆ EventInfoRange

◆ JetAccessor

◆ JetDecorator

◆ JetId

◆ JetRange

◆ Met0Accessor

◆ Met0Decorator

◆ Met0Def

◆ Met0Id

◆ Met0Range

◆ Met1Accessor

◆ Met1Decorator

◆ Met1Id

◆ Met1Range

◆ MetAccessor

◆ MetAssociationId

◆ MetAssociationRange

◆ MetDecorator

◆ MetId

◆ MetRange

◆ MuonAccessor

◆ MuonDecorator

◆ MuonId

◆ MuonRange

◆ MuonTrackDef

◆ MutableEgammaAccessor

◆ MutableEgammaDecorator

◆ MutableEgammaDef

◆ MutableEgammaId

◆ MutableEgammaRange

◆ MutableJetAccessor

◆ MutableJetDecorator

◆ MutableJetDef

◆ MutableJetId

◆ MutableJetRange

◆ MutableJetUpdater

◆ MutableMetAccessor

◆ MutableMetDecorator

◆ MutableMetDef

◆ MutableMetId

◆ MutableMetRange

◆ OptClusterId

◆ OptDiTauJetId

◆ OptEgammaId

◆ OptElectronId