Namespaces
	ClusterHelpers

	ContainerId
	a namespace for holding the ids for the different "virtual" containers

	detail

	Detail

	EgammaHelpers

	EventInfoHelpers

	MetDef

	MetHelpers

	TestUtils

Classes
class	AccessorTemplate
	the raw column accessor template class More...

class	AccessorTemplate< CI, ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeArray >, ColumnAccessMode::input, ColumnarModeArray >

class	AccessorTemplate< CI, std::vector< ObjectLink< VariantContainerId< CIBase, CIList... >, ColumnarModeArray > >, 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< LinkCastColumn< LT, ELT >, ColumnarModeArray >

struct	ColumnTypeTraits< LinkCastColumn< LT, ELT >, ColumnarModeXAOD >

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 >

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 More...

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...

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 >

using	UserType = typename ColumnTypeTraits< CT, CM >::UserType

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	CM = ColumnarModeXAOD

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	ElementType = typename ColumnTypeTraits< CT, CM >::ColumnType

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 More...

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	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	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	ColumnAccessMode { ColumnAccessMode::input, ColumnAccessMode::output, ColumnAccessMode::update }
	an enum for the different access modes for a column More...

Functions
template<typename CT , typename CM >
	requires ((std::is_integral_v< CT >\|\|std::is_floating_point_v< CT >) &&!std::is_same_v< CT, bool >) struct ColumnTypeTraits< CT

template<ContainerIdConcept CI, typename CT , typename CM >
	requires (CI::regularObjectId &&(ColumnTypeTraits< CT, CM >::useConvertInput\|\|ColumnTypeTraits< CT, CM >::useConvertWithDataInput)) class AccessorTemplate< CI

	AccessorTemplate ()=default

	AccessorTemplate (ColumnarTool< CM > &columnBase, const std::string &name, ColumnInfo &&info={})

decltype(auto)	operator() (ObjectId< CI, CM > id) const noexcept

bool	isAvailable (ObjectId< CI, CM > id) const noexcept

std::optional< UserType >	getOptional (ObjectId< CI, CM > id) const

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 More...

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 More...

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)

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>
	requires (std::is_same_v< typename CI::xAODObjectRangeType, typename CI::xAODObjectIdType >) class ObjectRange< CI

	ObjectRange (xAODContainer &val_singlet) noexcept

xAODContainer &	getXAODObject () const noexcept

xAODContainer &	getXAODObjectNoexcept () const noexcept

auto	begin () const noexcept

auto	end () const noexcept

auto	rbegin () const noexcept

auto	rend () const noexcept

bool	empty () const noexcept

std::size_t	size () const noexcept

ObjectId< CI, CM >	operator[] (std::size_t) const noexcept

template<typename Acc , typename... Args>
requiresdecltype(auto) std::invocable< Acc, ObjectRange< CI, ColumnarModeXAOD >, Args... >	operator() (Acc &acc, Args &&... args) const

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)

template<RegularContainerIdConcept CI, typename CT >
requires(ColumnTypeTraits< CT, ColumnarModeXAOD >::isNativeType) struct ColumnTypeTraits< std	requires (ColumnTypeTraits< CT, ColumnarModeArray >::isNativeType) class AccessorTemplate< CI

	AccessorTemplate (AccessorTemplate &&that)

AccessorTemplate &	operator= (AccessorTemplate &&that)

template<ContainerIdConcept CI, typename CT , typename CM >
	requires (ColumnTypeTraits< CT, CM >::useConvertInput\|\|ColumnTypeTraits< CT, CM >::useConvertWithDataInput) class AccessorTemplate< CI
	a std::vector accessor for types that can be implemented via conversions More...

template<ContainerIdConcept CI, typename CT >
	requires (ColumnTypeTraits< CT, ColumnarModeArray >::isNativeType) class AccessorTemplate< CI

void	renameContainers (IColumnarTool &tool, const std::vector< std::pair< std::string, std::string >> &renames)
	rename containers in the columnar tool More...

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
CM	final

	CT

AccessorTemplate< CI, ColumnType, ColumnAccessMode::input, CM >	m_base

constexpr unsigned	columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE

template<typename CI >
concept	ContainerIdConcept = CI::isContainerId
	concept for a container id More...

template<typename CI >
concept	RegularContainerIdConcept = CI::isContainerId && CI::regularObjectId

xAODContainer *	m_singlet = nullptr

unsigned	m_offsetIndex = 0u

std::unique_ptr< ColumnAccessorDataArray >	m_offsetData

unsigned	m_dataIndex = 0u

std::unique_ptr< ColumnAccessorDataArray >	m_dataData

ColumnAccessor< CI, std::vector< typename ColumnTypeTraits< CT, CM >::ColumnType >, CM >	m_accessor

unsigned	m_outerOffsetIndex = 0u

std::unique_ptr< ColumnAccessorDataArray >	m_outerOffsetData

unsigned	m_innerOffsetIndex = 0u

std::unique_ptr< ColumnAccessorDataArray >	m_innerOffsetData

constexpr ColumnarOffsetType	invalidObjectIndex = static_cast<ColumnarOffsetType>(-1)
	the value for an invalid element index More...

const std::string	numberOfEventsName = "EventInfo"
	the name used for the column containing the number of events More...

template<ContainerIdConcept CIBase, ContainerIdConcept... CIList, typename CT , ColumnAccessMode CAM>
requires	requires { AccessorTemplate<CIBase,CT,CAM,ColumnarModeXAOD>{}

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 = typedef 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 = typedef AccessorTemplate<ContainerId::cluster,CT,ColumnAccessMode::output,CM>

Definition at line 29 of file ClusterDef.h.

◆ ClusterId

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

Definition at line 26 of file ClusterDef.h.

◆ CM

typedef ColumnarModeArray columnar::CM

Definition at line 141 of file ObjectRange.h.

◆ ColumnAccessor

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

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

private

Definition at line 219 of file ColumnAccessor.h.

◆ ColumnarModeDefault

using columnar::ColumnarModeDefault = typedef ColumnarModeXAOD

Definition at line 108 of file ColumnarDef.h.

◆ ColumnarOffsetType

using columnar::ColumnarOffsetType = typedef 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 = typedef AccessorTemplate<CI,CT,ColumnAccessMode::output,CM>

private

Definition at line 220 of file ColumnAccessor.h.

◆ ColumnUpdater

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

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

private

Definition at line 221 of file ColumnAccessor.h.

◆ EgammaAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::EgammaAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::egamma,CT,ColumnAccessMode::output,CM>

Definition at line 53 of file EgammaDef.h.

◆ EgammaId

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

Definition at line 50 of file EgammaDef.h.

◆ EgammaRange

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

Definition at line 49 of file EgammaDef.h.

◆ ElectronAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::ElectronAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::electron,CT,ColumnAccessMode::output,CM>

Definition at line 41 of file EgammaDef.h.

◆ ElectronId

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

Definition at line 38 of file EgammaDef.h.

◆ ElectronRange

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

Definition at line 37 of file EgammaDef.h.

◆ ElementType

typedef typename ColumnTypeTraits< CT, ColumnarModeArray >::ColumnType columnar::ElementType

Definition at line 66 of file VectorColumn.h.

◆ EventContextId

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

Definition at line 185 of file ContainerId.h.

◆ EventContextRange

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

Definition at line 184 of file ContainerId.h.

◆ EventInfoAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::EventInfoAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::eventInfo,CT,ColumnAccessMode::output,CM>

Definition at line 35 of file EventInfoDef.h.

◆ EventInfoId

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

Definition at line 32 of file EventInfoDef.h.

◆ EventInfoRange

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

Definition at line 31 of file EventInfoDef.h.

◆ JetAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::JetAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::jet,CT,ColumnAccessMode::output,CM>

Definition at line 29 of file JetDef.h.

◆ JetId

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

Definition at line 26 of file JetDef.h.

◆ JetRange

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

Definition at line 25 of file JetDef.h.

◆ Met0Accessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::Met0Accessor = typedef 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 = typedef AccessorTemplate<ContainerId::met0,CT,ColumnAccessMode::output,CM>

Definition at line 59 of file MetDef.h.

◆ Met0Id

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

Definition at line 56 of file MetDef.h.

◆ Met0Range

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

Definition at line 55 of file MetDef.h.

◆ Met1Accessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::Met1Accessor = typedef 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 = typedef AccessorTemplate<ContainerId::met1,CT,ColumnAccessMode::output,CM>

Definition at line 65 of file MetDef.h.

◆ Met1Id

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

Definition at line 62 of file MetDef.h.

◆ Met1Range

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

Definition at line 61 of file MetDef.h.

◆ MetAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 52 of file MetDef.h.

◆ MetAssociationId

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

Definition at line 74 of file MetDef.h.

◆ MetAssociationRange

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

Definition at line 73 of file MetDef.h.

◆ MetDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 53 of file MetDef.h.

◆ MetId

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

Definition at line 50 of file MetDef.h.

◆ MetRange

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

Definition at line 49 of file MetDef.h.

◆ MuonAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::MuonAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::muon,CT,ColumnAccessMode::output,CM>

Definition at line 28 of file MuonDef.h.

◆ MuonId

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

Definition at line 25 of file MuonDef.h.

◆ MuonRange

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

Definition at line 24 of file MuonDef.h.

◆ MutableEgammaAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::MutableEgammaAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::mutableEgamma,CT,ColumnAccessMode::output,CM>

Definition at line 59 of file EgammaDef.h.

◆ MutableEgammaId

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

Definition at line 56 of file EgammaDef.h.

◆ MutableEgammaRange

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

Definition at line 55 of file EgammaDef.h.

◆ MutableJetAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::MutableJetAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::mutableJet,CT,ColumnAccessMode::output,CM>

Definition at line 35 of file JetDef.h.

◆ MutableJetId

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

Definition at line 32 of file JetDef.h.

◆ MutableJetRange

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

Definition at line 31 of file JetDef.h.

◆ MutableJetUpdater

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::MutableJetUpdater = typedef 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 = typedef 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 = typedef AccessorTemplate<ContainerId::mutableMet,CT,ColumnAccessMode::output,CM>

Definition at line 71 of file MetDef.h.

◆ MutableMetId

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

Definition at line 68 of file MetDef.h.

◆ MutableMetRange

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

Definition at line 67 of file MetDef.h.

◆ OptClusterId

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

Definition at line 27 of file ClusterDef.h.

◆ OptEgammaId

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

Definition at line 51 of file EgammaDef.h.

◆ OptElectronId

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

Definition at line 39 of file EgammaDef.h.

◆ OptEventInfoId

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

Definition at line 33 of file EventInfoDef.h.

◆ OptJetId

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

Definition at line 27 of file JetDef.h.

◆ OptMet0Id

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

Definition at line 57 of file MetDef.h.

◆ OptMet1Id

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

Definition at line 63 of file MetDef.h.

◆ OptMetAssociationId

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

Definition at line 75 of file MetDef.h.

◆ OptMetId

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

Definition at line 51 of file MetDef.h.

◆ OptMuonId

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

Definition at line 26 of file MuonDef.h.

◆ OptMutableEgammaId

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

Definition at line 57 of file EgammaDef.h.

◆ OptMutableJetId

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

Definition at line 33 of file JetDef.h.

◆ OptMutableMetId

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

Definition at line 69 of file MetDef.h.

◆ OptParticle0Id

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

Definition at line 38 of file ParticleDef.h.

◆ OptParticle1Id

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

Definition at line 44 of file ParticleDef.h.

◆ OptParticleId

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

Definition at line 32 of file ParticleDef.h.

◆ OptPhotonId

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

Definition at line 45 of file EgammaDef.h.

◆ OptTrack0Id

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

Definition at line 46 of file TrackDef.h.

◆ OptTrack1Id

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

Definition at line 50 of file TrackDef.h.

◆ OptTrack2Id

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

Definition at line 54 of file TrackDef.h.

◆ OptTrackId

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

Definition at line 42 of file TrackDef.h.

◆ OptVertexId

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

Definition at line 59 of file TrackDef.h.

◆ Particle0Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 39 of file ParticleDef.h.

◆ Particle0Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 40 of file ParticleDef.h.

◆ Particle0Id

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

Definition at line 37 of file ParticleDef.h.

◆ Particle0Range

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

Definition at line 36 of file ParticleDef.h.

◆ Particle1Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 45 of file ParticleDef.h.

◆ Particle1Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 46 of file ParticleDef.h.

◆ Particle1Id

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

Definition at line 43 of file ParticleDef.h.

◆ Particle1Range

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

Definition at line 42 of file ParticleDef.h.

◆ ParticleAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 33 of file ParticleDef.h.

◆ ParticleDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 34 of file ParticleDef.h.

◆ ParticleId

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

Definition at line 31 of file ParticleDef.h.

◆ ParticleRange

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

Definition at line 30 of file ParticleDef.h.

◆ PhotonAccessor

template<typename CT , typename CM = ColumnarModeDefault>

using columnar::PhotonAccessor = typedef 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 = typedef AccessorTemplate<ContainerId::photon,CT,ColumnAccessMode::output,CM>

Definition at line 47 of file EgammaDef.h.

◆ PhotonId

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

Definition at line 44 of file EgammaDef.h.

◆ PhotonRange

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

Definition at line 43 of file EgammaDef.h.

◆ Track0Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 47 of file TrackDef.h.

◆ Track0Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 48 of file TrackDef.h.

◆ Track1Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 51 of file TrackDef.h.

◆ Track1Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 52 of file TrackDef.h.

◆ Track2Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 55 of file TrackDef.h.

◆ Track2Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 56 of file TrackDef.h.

◆ TrackAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 43 of file TrackDef.h.

◆ TrackDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 44 of file TrackDef.h.

◆ TrackId

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

Definition at line 41 of file TrackDef.h.

◆ UserType

using columnar::UserType = typedef typename ColumnTypeTraits<CT,CM>::UserType

Definition at line 165 of file ColumnAccessor.h.

◆ VertexAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 60 of file TrackDef.h.

◆ VertexDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

Definition at line 61 of file TrackDef.h.

◆ VertexId

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

Definition at line 58 of file TrackDef.h.

Enumeration Type Documentation

◆ ColumnAccessMode

enum 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

◆ AccessorTemplate() [1/3]

columnar::AccessorTemplate ( )

default

◆ AccessorTemplate() [2/3]

columnar::AccessorTemplate ( AccessorTemplate && that )

Definition at line 82 of file VectorColumn.h.

     {
       moveAccessor (m_offsetIndex, m_offsetData, that.m_offsetIndex, that.m_offsetData);
       moveAccessor (m_dataIndex, m_dataData, that.m_dataIndex, that.m_dataData);
     }

◆ AccessorTemplate() [3/3]

columnar::AccessorTemplate	(	ColumnarTool< CM > &	columnBase,
		const std::string &	name,
		ColumnInfo &&	info = `{}`
	)

Definition at line 169 of file ColumnAccessor.h.

                                                                                                {})
       : m_base (columnBase, name, std::move (ColumnTypeTraits<CT,CM>::updateColumnInfo(columnBase, info)))
     {}

◆ 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);
   }

◆ begin()

auto columnar::begin ( ) const

noexcept

Definition at line 154 of file ObjectRange.h.

154 {

155 return ObjectRangeIteratorXAODSinglet<CI> (m_singlet);}

◆ empty()

bool columnar::empty ( ) const

noexcept

Definition at line 163 of file ObjectRange.h.

163 {

164 return false;}

◆ end()

auto columnar::end ( ) const

noexcept

Definition at line 156 of file ObjectRange.h.

156 {

157 return ObjectRangeIteratorXAODSinglet<CI> (nullptr);}

◆ getOptional()

std::optional<UserType> columnar::getOptional ( ObjectId< CI, CM > id ) const

Definition at line 186 of file ColumnAccessor.h.

     {
       if (m_base.isAvailable (id))
         return operator()(id);
       else
         return std::nullopt;
     }

◆ getXAODObject()

xAODContainer& columnar::getXAODObject ( ) const

noexcept

Definition at line 147 of file ObjectRange.h.

147 {

148 return *m_singlet;}

◆ getXAODObjectNoexcept()

xAODContainer& columnar::getXAODObjectNoexcept ( ) const

noexcept

Definition at line 151 of file ObjectRange.h.

151 {

152 return *m_singlet;}

◆ isAvailable()

bool columnar::isAvailable ( ObjectId< CI, CM > id ) const

noexcept

Definition at line 181 of file ColumnAccessor.h.

     {
       return m_base.isAvailable (id);
     }

◆ 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 ("data already 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;
     }
   }

◆ ObjectRange()

columnar::ObjectRange ( xAODContainer & val_singlet )

noexcept

Definition at line 143 of file ObjectRange.h.

144 : m_singlet (&val_singlet)

145 {}

◆ 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/2]

template<typename Acc , typename... Args>

requiresdecltype(auto) std::invocable<Acc,ObjectRange<CI,ColumnarModeXAOD>,Args...> columnar::operator()	(	Acc &	acc,
		Args &&...	args
	)		const

Definition at line 175 of file ObjectRange.h.

175 {

176 return acc (*this, std::forward<Args> (args)...);}

◆ operator()() [2/2]

auto columnar::operator() ( ObjectId< CI, CM > id ) const

noexcept

Definition at line 173 of file ColumnAccessor.h.

     {
       if constexpr (ColumnTypeTraits<CT,CM>::useConvertWithDataInput)
         return ColumnTypeTraits<CT,CM>::convertInput (id.getData(), m_base(id));
       else
         return ColumnTypeTraits<CT,CM>::convertInput (m_base(id));
     }

◆ 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 289 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=()

AccessorTemplate & columnar::operator= ( AccessorTemplate && that )

Definition at line 88 of file VectorColumn.h.

     {
       if (this != &that)
       {
         moveAccessor (m_offsetIndex, m_offsetData, that.m_offsetIndex, that.m_offsetData);
         moveAccessor (m_dataIndex, m_dataData, that.m_dataIndex, that.m_dataData);
       }
       return *this;
     }

◆ 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();
   }

◆ operator[]()

ObjectId<CI,CM> columnar::operator[] ( std::size_t ) const

noexcept

Definition at line 169 of file ObjectRange.h.

                                                                            {
       return ObjectId<CI,CM> (*m_singlet);
     }

◆ rbegin()

auto columnar::rbegin ( ) const

noexcept

Definition at line 158 of file ObjectRange.h.

158 {

159 return ObjectRangeIteratorXAODSinglet<CI> (m_singlet);}

◆ 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);
           }
         }
       }
     }
   }

◆ rend()

auto columnar::rend ( ) const

noexcept

Definition at line 160 of file ObjectRange.h.

160 {

161 return ObjectRangeIteratorXAODSinglet<CI> (nullptr);}

◆ requires() [1/6]

template<typename CT , typename CM >

columnar::requires ( (std::is_integral_v< CT >||std::is_floating_point_v< CT >) &&!std::is_same_v< CT, bool > )

◆ requires() [2/6]

template<ContainerIdConcept CI, typename CT , typename CM >

columnar::requires ( CI::regularObjectId && ColumnTypeTraits< CT, CM >::useConvertInput||ColumnTypeTraits< CT, CM >::useConvertWithDataInput )

◆ requires() [3/6]

template<ContainerIdConcept CI, typename CT , typename CM >

columnar::requires ( ColumnTypeTraits< CT, CM >::useConvertInput||ColumnTypeTraits< CT, CM >::useConvertWithDataInput )

private

a std::vector accessor for types that can be implemented via conversions

This is a bit more involved in that it needs to wrap the underlying view, and apply the conversion on access. That means I need to have a custom view and iterator object to handle it. Furthermore, since some conversions need a data pointer and others don't, I need to have two different implementations of the view and iterator.

◆ requires() [4/6]

template<ContainerIdConcept CI, typename CT >

columnar::requires ( ColumnTypeTraits< CT, ColumnarModeArray >::isNativeType )

◆ requires() [5/6]

template<RegularContainerIdConcept CI, typename CT >

requires (ColumnTypeTraits<CT,ColumnarModeXAOD>::isNativeType) struct ColumnTypeTraits<std columnar::requires ( ColumnTypeTraits< CT, ColumnarModeArray >::isNativeType )

◆ requires() [6/6]

template<ContainerIdConcept CI>

columnar::requires ( std::is_same_v< typename CI::xAODObjectRangeType, typename CI::xAODObjectIdType > )

◆ 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 = `{}`
	)

private

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 210 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); }

◆ 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); }

◆ 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>>); }

◆ 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); }

◆ 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); }

◆ 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); }

◆ 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); }

◆ 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); }

◆ size()

std::size_t columnar::size ( ) const

noexcept

Definition at line 166 of file ObjectRange.h.

166 {

167 return 1;}

Variable Documentation

◆ columnarAccessMode

constexpr unsigned columnar::columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE

constexpr

Definition at line 15 of file ColumnarDef.h.

◆ ContainerIdConcept

template<typename CI >

concept columnar::ContainerIdConcept = CI::isContainerId

concept for a container id

Definition at line 171 of file ContainerId.h.

◆ CT

columnar::CT

Definition at line 160 of file ColumnAccessor.h.

◆ final

ColumnarModeArray columnar::final

Initial value:

{

using ColumnType = CT

Definition at line 105 of file ColumnAccessor.h.

◆ invalidObjectIndex

constexpr 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.

◆ m_accessor

ColumnAccessor<CI,std::vector<typename ColumnTypeTraits<CT,CM>::ColumnType>,CM> columnar::m_accessor

private

Private Members

Definition at line 164 of file VectorColumn.h.

◆ m_base

AccessorTemplate<CI,ColumnType,ColumnAccessMode::input,CM> columnar::m_base

private

Definition at line 195 of file ColumnAccessor.h.

◆ m_dataData

std::unique_ptr< ColumnAccessorDataArray > columnar::m_dataData

private

Definition at line 118 of file VectorColumn.h.

◆ m_dataIndex

unsigned columnar::m_dataIndex = 0u

private

Definition at line 117 of file VectorColumn.h.

◆ m_innerOffsetData

std::unique_ptr<ColumnAccessorDataArray> columnar::m_innerOffsetData

private

Definition at line 93 of file VectorVectorColumn.h.

◆ m_innerOffsetIndex

unsigned columnar::m_innerOffsetIndex = 0u

private

Definition at line 92 of file VectorVectorColumn.h.

◆ m_offsetData

std::unique_ptr<ColumnAccessorDataArray> columnar::m_offsetData

private

Definition at line 116 of file VectorColumn.h.

◆ m_offsetIndex

unsigned columnar::m_offsetIndex = 0u

private

Private Members

Definition at line 115 of file VectorColumn.h.

◆ m_outerOffsetData

std::unique_ptr<ColumnAccessorDataArray> columnar::m_outerOffsetData

private

Definition at line 91 of file VectorVectorColumn.h.

◆ m_outerOffsetIndex

unsigned columnar::m_outerOffsetIndex = 0u

private

Private Members

Definition at line 90 of file VectorVectorColumn.h.

◆ m_singlet

xAODContainer* columnar::m_singlet = nullptr

private

Private Members

Definition at line 184 of file ObjectRange.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.

◆ RegularContainerIdConcept

template<typename CI >

concept columnar::RegularContainerIdConcept = CI::isContainerId && CI::regularObjectId

Definition at line 173 of file ContainerId.h.

◆ requires

template<ContainerIdConcept CIBase, ContainerIdConcept... CIList, typename CT , ColumnAccessMode CAM>

requires columnar::requires { AccessorTemplate<CIBase,CT,CAM,ColumnarModeXAOD>{}

Definition at line 22 of file VariantAccessor.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Includes

Typedef Documentation

◆ ClusterAccessor

◆ ClusterDecorator

◆ ClusterId

◆ CM

◆ ColumnAccessor

◆ ColumnarModeDefault

◆ ColumnarOffsetType

◆ ColumnDecorator

◆ ColumnUpdater

◆ EgammaAccessor

◆ EgammaDecorator

◆ EgammaId

◆ EgammaRange

◆ ElectronAccessor

◆ ElectronDecorator

◆ ElectronId

◆ ElectronRange

◆ ElementType

◆ 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

◆ 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