Namespaces
	ClusterHelpers

	detail

	MetDef

	PhysliteTestHelpers

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

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

class	ColumnarToolWrapper
	a class that wraps an IColumnarTool for use in Python More...

class	ColumnarToolWrapperData
	a class that holds the columnar data for a single call to ColumnarToolWrapper More...

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< OptObjectId< LT >, ColumnarModeArray >

struct	ColumnTypeTraits< OptObjectId< LT >, ColumnarModeXAOD >

struct	ColumnTypeTraits< RetypeColumn< UT, CT >, CM >

class	ConfigurableColumnExampleTool
	example of a columnar tool with optional columns More...

struct	ContainerIdTraits

struct	ContainerIdTraits< ContainerId::cluster >

struct	ContainerIdTraits< ContainerId::egamma >

struct	ContainerIdTraits< ContainerId::electron >

struct	ContainerIdTraits< ContainerId::eventContext >

struct	ContainerIdTraits< ContainerId::eventInfo >

struct	ContainerIdTraits< ContainerId::jet >

struct	ContainerIdTraits< ContainerId::metAssociation >

struct	ContainerIdTraits< ContainerId::muon >

struct	ContainerIdTraits< ContainerId::mutableJet >

struct	ContainerIdTraits< ContainerId::mutableMet >

struct	ContainerIdTraits< ContainerId::photon >

struct	ContainerIdTraits< ContainerId::vertex >

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	ModularExampleTool
	an example of a columnar tool with a modular structure 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< O, ColumnarModeArray >

class	ObjectId< O, ColumnarModeXAOD >

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

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	VectorExampleTool
	an example of a columnar tool that reads a vector column More...

Typedefs
using	ColumnType = typename ColumnTypeTraits< CT, CM >::ColumnType

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

template<ContainerId CI, typename CT , typename CM = ColumnarModeDefault>
using	ColumnAccessor = AccessorTemplate< CI, CT, ColumnAccessMode::input, CM >

template<ContainerId CI, typename CT , typename CM = ColumnarModeDefault>
using	ColumnDecorator = AccessorTemplate< CI, CT, ColumnAccessMode::output, CM >

template<ContainerId CI, typename CT , typename CM = ColumnarModeDefault>
using	ColumnUpdater = AccessorTemplate< CI, CT, ColumnAccessMode::update, CM >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

template<typename CT , typename CM = ColumnarModeDefault>
using	ClusterAccessor = AccessorTemplate< ContainerId::cluster, CT, ColumnAccessMode::input, CM >

template<typename CT , typename CM = ColumnarModeDefault>
using	ClusterDecorator = AccessorTemplate< ContainerId::cluster, CT, ColumnAccessMode::output, CM >

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

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 >

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 >

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 >

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 >

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 >

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 >

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

using	JetId = ObjectId< ContainerId::jet >

using	MutableJetId = ObjectId< ContainerId::mutableJet >

using	MuonId = ObjectId< ContainerId::muon >

using	EventInfoId = ObjectId< ContainerId::eventInfo >

using	EventContextId = ObjectId< ContainerId::eventContext >

using	ElectronId = ObjectId< ContainerId::electron >

using	PhotonId = ObjectId< ContainerId::photon >

using	EgammaId = ObjectId< ContainerId::egamma >

using	ClusterId = ObjectId< ContainerId::cluster >

using	TrackId = ObjectId< ContainerId::track >

using	VertexId = ObjectId< ContainerId::vertex >

using	ParticleId = ObjectId< ContainerId::particle >

using	Particle0Id = ObjectId< ContainerId::particle0 >

using	Particle1Id = ObjectId< ContainerId::particle1 >

using	MetId = ObjectId< ContainerId::met >

using	Met0Id = ObjectId< ContainerId::met0 >

using	Met1Id = ObjectId< ContainerId::met1 >

using	MutableMetId = ObjectId< ContainerId::mutableMet >

using	MetAssociationId = ObjectId< ContainerId::metAssociation >

using	xAODContainer = typename ContainerIdTraits< CI >::xAODObjectRangeType

using	CM = ColumnarModeXAOD

using	EventInfoRange = ObjectRange< ContainerId::eventInfo >

using	EventContextRange = ObjectRange< ContainerId::eventContext >

using	JetRange = ObjectRange< ContainerId::jet >

using	MutableJetRange = ObjectRange< ContainerId::mutableJet >

using	EgammaRange = ObjectRange< ContainerId::egamma >

using	ElectronRange = ObjectRange< ContainerId::electron >

using	PhotonRange = ObjectRange< ContainerId::photon >

using	MuonRange = ObjectRange< ContainerId::muon >

using	ParticleRange = ObjectRange< ContainerId::particle >

using	Particle0Range = ObjectRange< ContainerId::particle0 >

using	Particle1Range = ObjectRange< ContainerId::particle1 >

using	MetRange = ObjectRange< ContainerId::met >

using	Met0Range = ObjectRange< ContainerId::met0 >

using	Met1Range = ObjectRange< ContainerId::met1 >

using	MutableMetRange = ObjectRange< ContainerId::mutableMet >

using	MetAssociationRange = ObjectRange< ContainerId::metAssociation >

using	OptJetId = OptObjectId< ContainerId::jet >

using	OptMutableJetId = OptObjectId< ContainerId::mutableJet >

using	OptMuonId = OptObjectId< ContainerId::muon >

using	OptElectronId = OptObjectId< ContainerId::electron >

using	OptPhotonId = OptObjectId< ContainerId::photon >

using	OptEgammaId = OptObjectId< ContainerId::egamma >

using	OptClusterId = OptObjectId< ContainerId::cluster >

using	OptTrackId = OptObjectId< ContainerId::track >

using	OptTrack0Id = OptObjectId< ContainerId::track0 >

using	OptTrack1Id = OptObjectId< ContainerId::track1 >

using	OptTrack2Id = OptObjectId< ContainerId::track2 >

using	OptVertexId = OptObjectId< ContainerId::vertex >

using	OptParticleId = OptObjectId< ContainerId::particle >

using	OptParticle0Id = OptObjectId< ContainerId::particle0 >

using	OptParticle1Id = OptObjectId< ContainerId::particle1 >

using	OptMetId = OptObjectId< ContainerId::met >

using	OptMet0Id = OptObjectId< ContainerId::met0 >

using	OptMet1Id = OptObjectId< ContainerId::met1 >

using	OptMutableMetId = OptObjectId< ContainerId::mutableMet >

using	OptMetAssociationId = OptObjectId< ContainerId::metAssociation >

using	OptEventInfoId = OptObjectId< ContainerId::eventInfo >

using	ElementType = typename ColumnTypeTraits< CT, CM >::ColumnType

using	ColumnarOffsetType = std::size_t
	the type used for the size and offsets in the columnar data More...

Enumerations
enum	ContainerId { ContainerId::jet, ContainerId::mutableJet, ContainerId::muon, ContainerId::electron, ContainerId::photon, ContainerId::egamma, ContainerId::cluster, ContainerId::track, ContainerId::track0 = track, ContainerId::track1, ContainerId::track2, ContainerId::vertex, ContainerId::particle, ContainerId::particle0 = particle, ContainerId::particle1, ContainerId::met, ContainerId::met0 = met, ContainerId::met1, ContainerId::mutableMet, ContainerId::metAssociation, ContainerId::eventInfo, ContainerId::eventContext }
	the id for the different "virtual" containers More...

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<ContainerId OT, 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...

	AccessorTemplate ()=default

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

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

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

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

template<ContainerId 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)

template<ContainerId CI>
bool	operator== (const ObjectId< CI, ColumnarModeXAOD > &lhs, const ObjectId< CI, ColumnarModeXAOD > &rhs)

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

template<ContainerId CI>
bool	operator== (const ObjectId< CI, ColumnarModeArray > &lhs, const ObjectId< CI, ColumnarModeArray > &rhs)

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

template<ContainerId CI>
	requires (std::is_same_v< typename ContainerIdTraits< CI >::xAODObjectRangeType, typename ContainerIdTraits< CI >::xAODObjectIdType >) class ObjectRange< CI

	ObjectRange (xAODContainer &val_singlet) noexcept

xAODContainer &	getXAODObject () const noexcept

auto	begin () const noexcept

auto	end () 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<ContainerId CI>
bool	operator== (const OptObjectId< CI, ColumnarModeXAOD > &lhs, const OptObjectId< CI, ColumnarModeXAOD > &rhs)

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

template<ContainerId CI>
bool	operator== (const OptObjectId< CI, ColumnarModeArray > &lhs, const OptObjectId< CI, ColumnarModeArray > &rhs)

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

template<ContainerId CI>
	requires (CI==ContainerId::particle0\|\|CI==ContainerId::particle1) struct ContainerIdTraits< CI > final

template<ContainerId 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)

std::span< const ElementType >	operator() (ObjectId< CI, CM > id) const noexcept

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

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

Variables
CM	final

	CT

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

constexpr unsigned	columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE

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

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

Detailed Description

Author: Nils Krumnack; Nils Krumnack

Includes

Typedef Documentation

◆ ClusterAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 245 of file ColumnAccessor.h.

◆ ClusterDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 246 of file ColumnAccessor.h.

◆ ClusterId

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

Definition at line 161 of file ObjectId.h.

◆ CM

typedef ColumnarModeArray columnar::CM

Definition at line 115 of file ObjectRange.h.

◆ ColumnAccessor

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

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

private

Definition at line 221 of file ColumnAccessor.h.

◆ ColumnarModeDefault

using columnar::ColumnarModeDefault = typedef ColumnarModeXAOD

Definition at line 45 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<ContainerId CI, typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 222 of file ColumnAccessor.h.

◆ ColumnType

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

Definition at line 166 of file ColumnAccessor.h.

◆ ColumnUpdater

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

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

private

Definition at line 223 of file ColumnAccessor.h.

◆ EgammaAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 243 of file ColumnAccessor.h.

◆ EgammaDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 244 of file ColumnAccessor.h.

◆ EgammaId

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

Definition at line 160 of file ObjectId.h.

◆ EgammaRange

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

private

Definition at line 288 of file ObjectRange.h.

◆ ElectronAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 239 of file ColumnAccessor.h.

◆ ElectronDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 240 of file ColumnAccessor.h.

◆ ElectronId

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

Definition at line 158 of file ObjectId.h.

◆ ElectronRange

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

private

Definition at line 289 of file ObjectRange.h.

◆ ElementType

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

Definition at line 66 of file VectorColumn.h.

◆ EventContextId

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

Definition at line 157 of file ObjectId.h.

◆ EventContextRange

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

private

Definition at line 285 of file ObjectRange.h.

◆ EventInfoAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 247 of file ColumnAccessor.h.

◆ EventInfoDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 248 of file ColumnAccessor.h.

◆ EventInfoId

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

Definition at line 156 of file ObjectId.h.

◆ EventInfoRange

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

private

Definition at line 284 of file ObjectRange.h.

◆ JetAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 224 of file ColumnAccessor.h.

◆ JetDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 225 of file ColumnAccessor.h.

◆ JetId

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

Definition at line 153 of file ObjectId.h.

◆ JetRange

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

private

Definition at line 286 of file ObjectRange.h.

◆ Met0Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 257 of file ColumnAccessor.h.

◆ Met0Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 258 of file ColumnAccessor.h.

◆ Met0Id

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

Definition at line 168 of file ObjectId.h.

◆ Met0Range

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

private

Definition at line 296 of file ObjectRange.h.

◆ Met1Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 259 of file ColumnAccessor.h.

◆ Met1Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 260 of file ColumnAccessor.h.

◆ Met1Id

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

Definition at line 169 of file ObjectId.h.

◆ Met1Range

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

private

Definition at line 297 of file ObjectRange.h.

◆ MetAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 255 of file ColumnAccessor.h.

◆ MetAssociationId

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

Definition at line 171 of file ObjectId.h.

◆ MetAssociationRange

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

private

Definition at line 299 of file ObjectRange.h.

◆ MetDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 256 of file ColumnAccessor.h.

◆ MetId

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

Definition at line 167 of file ObjectId.h.

◆ MetRange

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

private

Definition at line 295 of file ObjectRange.h.

◆ MuonAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 229 of file ColumnAccessor.h.

◆ MuonDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 230 of file ColumnAccessor.h.

◆ MuonId

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

Definition at line 155 of file ObjectId.h.

◆ MuonRange

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

private

Definition at line 291 of file ObjectRange.h.

◆ MutableJetAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 226 of file ColumnAccessor.h.

◆ MutableJetDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 227 of file ColumnAccessor.h.

◆ MutableJetId

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

Definition at line 154 of file ObjectId.h.

◆ MutableJetRange

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

private

Definition at line 287 of file ObjectRange.h.

◆ MutableJetUpdater

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 228 of file ColumnAccessor.h.

◆ MutableMetAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 261 of file ColumnAccessor.h.

◆ MutableMetDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 262 of file ColumnAccessor.h.

◆ MutableMetId

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

Definition at line 170 of file ObjectId.h.

◆ MutableMetRange

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

private

Definition at line 298 of file ObjectRange.h.

◆ OptClusterId

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

Definition at line 196 of file OptObjectId.h.

◆ OptEgammaId

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

Definition at line 195 of file OptObjectId.h.

◆ OptElectronId

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

Definition at line 193 of file OptObjectId.h.

◆ OptEventInfoId

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

Definition at line 210 of file OptObjectId.h.

◆ OptJetId

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

Definition at line 190 of file OptObjectId.h.

◆ OptMet0Id

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

Definition at line 206 of file OptObjectId.h.

◆ OptMet1Id

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

Definition at line 207 of file OptObjectId.h.

◆ OptMetAssociationId

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

Definition at line 209 of file OptObjectId.h.

◆ OptMetId

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

Definition at line 205 of file OptObjectId.h.

◆ OptMuonId

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

Definition at line 192 of file OptObjectId.h.

◆ OptMutableJetId

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

Definition at line 191 of file OptObjectId.h.

◆ OptMutableMetId

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

Definition at line 208 of file OptObjectId.h.

◆ OptParticle0Id

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

Definition at line 203 of file OptObjectId.h.

◆ OptParticle1Id

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

Definition at line 204 of file OptObjectId.h.

◆ OptParticleId

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

Definition at line 202 of file OptObjectId.h.

◆ OptPhotonId

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

Definition at line 194 of file OptObjectId.h.

◆ OptTrack0Id

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

Definition at line 198 of file OptObjectId.h.

◆ OptTrack1Id

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

Definition at line 199 of file OptObjectId.h.

◆ OptTrack2Id

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

Definition at line 200 of file OptObjectId.h.

◆ OptTrackId

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

Definition at line 197 of file OptObjectId.h.

◆ OptVertexId

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

Definition at line 201 of file OptObjectId.h.

◆ Particle0Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 251 of file ColumnAccessor.h.

◆ Particle0Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 252 of file ColumnAccessor.h.

◆ Particle0Id

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

Definition at line 165 of file ObjectId.h.

◆ Particle0Range

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

private

Definition at line 293 of file ObjectRange.h.

◆ Particle1Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 253 of file ColumnAccessor.h.

◆ Particle1Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 254 of file ColumnAccessor.h.

◆ Particle1Id

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

Definition at line 166 of file ObjectId.h.

◆ Particle1Range

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

private

Definition at line 294 of file ObjectRange.h.

◆ ParticleAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 249 of file ColumnAccessor.h.

◆ ParticleDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 250 of file ColumnAccessor.h.

◆ ParticleId

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

Definition at line 164 of file ObjectId.h.

◆ ParticleRange

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

private

Definition at line 292 of file ObjectRange.h.

◆ PhotonAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 241 of file ColumnAccessor.h.

◆ PhotonDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 242 of file ColumnAccessor.h.

◆ PhotonId

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

Definition at line 159 of file ObjectId.h.

◆ PhotonRange

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

private

Definition at line 290 of file ObjectRange.h.

◆ Track0Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 233 of file ColumnAccessor.h.

◆ Track0Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 234 of file ColumnAccessor.h.

◆ Track1Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 235 of file ColumnAccessor.h.

◆ Track1Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 236 of file ColumnAccessor.h.

◆ Track2Accessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 237 of file ColumnAccessor.h.

◆ Track2Decorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 238 of file ColumnAccessor.h.

◆ TrackAccessor

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 231 of file ColumnAccessor.h.

◆ TrackDecorator

template<typename CT , typename CM = ColumnarModeDefault>

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

private

Definition at line 232 of file ColumnAccessor.h.

◆ TrackId

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

Definition at line 162 of file ObjectId.h.

◆ UserType

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

Definition at line 167 of file ColumnAccessor.h.

◆ VertexId

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

Definition at line 163 of file ObjectId.h.

◆ xAODContainer

using columnar::xAODContainer = typedef typename ContainerIdTraits<CI>::xAODObjectRangeType

Definition at line 114 of file ObjectRange.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
   };

◆ ContainerId

enum columnar::ContainerId

strong

the id for the different "virtual" containers

To first order these are just the different xAOD types, and have a direct mapping to the xAOD types. In the columnar world we don't really have objects like that, but there are still columns that belong together, which (mostly) share an offset map and a common prefix to their names. In effect these are virtual containers.

One big difference to the xAOD world is that the container id is really referring to just a single container. If you have e.g. two JetContainer instances in your tool, you need to use two different container ids for them. That is because in the columnar world the virtual containers come with completely separate columns, have separate offset maps, etc.

A given container id also only has a meaning within the context of one specific tool instance. If you have multiple instances of a tool they may be connected to different containers/columns each. If a tool has subtools they need to coordinate their container ids as well, making subtools a lot more tightly connected than in the xAOD world.

For xAOD code the container id must match the container used, as there is an underlying xAOD object for the code. For columnar code they are essentially arbitrary, but to make it work for xAOD mode. There are some containers that have special meaning (e.g. event), but most of them have the same behavior, just for different containers.

By default all referenced xAOD objects are const-qualified, as most tools will anyways work on const-qualified objects. And since the prototype works mostly with accessors directly, it bypasses most of the situations in which the xAOD objects are required to be mutable. I now (13 Jan 25) started to add a mutable version of some containers, because if you need to interface with preexisting xAOD code it can matter. For now I'd say use it sparingly.

Most classes in the prototype are templates that take the container id as a template parameter. In part this is to support the xAOD mode, but it also serves an important role in columanr mode, as it allows to perform a lot of safety checks at compile time. E.g. it allows to guarantee that an ObjectId always refers to a valid entry in the container and that it can only be used with columns that are associated with that container.

Note: Whenever you add a new container id here, you also need to add an associated ContainerIdTraits specialization for that container id (in the correct header file). You should also add proper type aliases for ObjectId, ObjectRange, OptObjectId, and ColumnAccessor. These type aliases are essential for keeping user code reasonably compact.

Enumerator
jet
mutableJet
muon
electron
photon
egamma
cluster
track
track0
track1
track2
vertex
particle
particle0
particle1
met
met0
met1
mutableMet
metAssociation
eventInfo
eventContext

Definition at line 70 of file ContainerId.h.

   {
     jet,
     mutableJet,
     muon,
     electron,
     photon,
     egamma,
     cluster,
     track,
     track0 = track,
     track1,
     track2,
     vertex,
     particle,
     particle0 = particle,
     particle1,
     met,
     met0 = met,
     met1,
     mutableMet,
     metAssociation,
     eventInfo,
     eventContext
   };

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

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

◆ begin()

auto columnar::begin ( ) const

noexcept

Definition at line 124 of file ObjectRange.h.

124 {

125 return ObjectRangeIteratorXAODSinglet<CI> (m_singlet);}

◆ empty()

bool columnar::empty ( ) const

noexcept

Definition at line 129 of file ObjectRange.h.

129 {

130 return false;}

◆ end()

auto columnar::end ( ) const

noexcept

Definition at line 126 of file ObjectRange.h.

126 {

127 return ObjectRangeIteratorXAODSinglet<CI> (nullptr);}

◆ getOptional()

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

Definition at line 188 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 121 of file ObjectRange.h.

121 {

122 return *m_singlet;}

◆ isAvailable() [1/2]

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

noexcept

Definition at line 105 of file VectorColumn.h.

     {
       auto *data = static_cast<const ElementType*>(id.getData()[m_dataIndex]);
       return data != nullptr;
     }

◆ isAvailable() [2/2]

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

noexcept

Definition at line 183 of file ColumnAccessor.h.

     {
       return m_base.isAvailable (id);
     }

◆ 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 117 of file ObjectRange.h.

118 : m_singlet (&val_singlet)

119 {}

◆ operator!=() [1/4]

template<ContainerId CI>

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

Definition at line 145 of file ObjectId.h.

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

◆ operator!=() [2/4]

template<ContainerId CI>

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

Definition at line 71 of file ObjectId.h.

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

◆ operator!=() [3/4]

template<ContainerId CI>

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

Definition at line 182 of file OptObjectId.h.

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

◆ operator!=() [4/4]

template<ContainerId CI>

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

Definition at line 89 of file OptObjectId.h.

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

◆ operator()() [1/3]

template<typename Acc , typename... Args>

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

Definition at line 141 of file ObjectRange.h.

141 {

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

◆ operator()() [2/3]

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

noexcept

Definition at line 98 of file VectorColumn.h.

     {
       auto *offset = static_cast<const ColumnarOffsetType*>(id.getData()[m_offsetIndex]);
       auto *data = static_cast<const ElementType*>(id.getData()[m_dataIndex]);
       return std::span<const ElementType> (&data[offset[id.getIndex()]], offset[id.getIndex()+1]-offset[id.getIndex()]);
     }

◆ operator()() [3/3]

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

noexcept

Definition at line 175 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=()

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/4]

template<ContainerId CI>

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

Definition at line 139 of file ObjectId.h.

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

◆ operator==() [2/4]

template<ContainerId CI>

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

Definition at line 65 of file ObjectId.h.

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

◆ operator==() [3/4]

template<ContainerId CI>

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

Definition at line 176 of file OptObjectId.h.

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

◆ operator==() [4/4]

template<ContainerId CI>

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

Definition at line 83 of file OptObjectId.h.

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

◆ operator[]()

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

noexcept

Definition at line 135 of file ObjectRange.h.

                                                                            {
       return ObjectId<CI,CM> (*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);
           }
         }
       }
     }
   }

◆ requires() [1/5]

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/5]

template<ContainerId CI>

columnar::requires ( CI = = ContainerId::particle0 || CI == ContainerId::particle1 )

final

the xAOD type to use with ObjectId

the xAOD type to use with ObjectRange

the xAOD type to use with ElementLink

the xAOD type to use with ObjectId

the xAOD type to use with ObjectRange

the xAOD type to use with ElementLink

the xAOD type to use with ObjectId

the xAOD type to use with ObjectRange

the xAOD type to use with ElementLink

the xAOD type to use with ObjectId

the xAOD type to use with ObjectRange

the xAOD type to use with ElementLink

the xAOD type to use with ObjectId

the xAOD type to use with ObjectRange

the xAOD type to use with ElementLink

Definition at line 16 of file ParticleDef.h.

   {
     static constexpr bool isDefined = true;
     static constexpr bool isMutable = false;
     static constexpr bool perEventRange = true;
     static constexpr bool perEventId = false;
  
     using xAODObjectIdType = const xAOD::IParticle;
  
     using xAODObjectRangeType = const xAOD::IParticleContainer;
  
     using xAODElementLinkType = xAOD::IParticleContainer;
  };

◆ requires() [3/5]

template<ContainerId OT, typename CT , typename CM >

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

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/5]

template<ContainerId CI, typename CT >

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

◆ requires() [5/5]

template<ContainerId CI>

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

◆ resetAccessor()

template<ContainerId 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 212 of file ColumnAccessor.h.

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

◆ size()

std::size_t columnar::size ( ) const

noexcept

Definition at line 132 of file ObjectRange.h.

132 {

133 return 1;}

Variable Documentation

◆ columnarAccessMode

constexpr unsigned columnar::columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE

constexpr

Definition at line 12 of file ColumnarDef.h.

◆ CT

columnar::CT

Definition at line 160 of file ColumnAccessor.h.

◆ final

CM 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<OT,ColumnType,ColumnAccessMode::input,CM> columnar::m_base

private

Definition at line 197 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_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_singlet

xAODContainer* columnar::m_singlet = nullptr

private

Private Members

Definition at line 150 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.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Includes

Typedef Documentation

◆ ClusterAccessor

◆ ClusterDecorator

◆ ClusterId

◆ CM

◆ ColumnAccessor

◆ ColumnarModeDefault

◆ ColumnarOffsetType

◆ ColumnDecorator

◆ ColumnType

◆ 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

◆ MutableJetAccessor

◆ MutableJetDecorator

◆ MutableJetId

◆ MutableJetRange

◆ MutableJetUpdater

◆ MutableMetAccessor

◆ MutableMetDecorator

◆ MutableMetId

◆ MutableMetRange

◆ OptClusterId

◆ OptEgammaId

◆ OptElectronId

◆ OptEventInfoId

◆ OptJetId

◆ OptMet0Id

◆ OptMet1Id

◆ OptMetAssociationId

◆ OptMetId

◆ OptMuonId

◆ OptMutableJetId

◆ OptMutableMetId

◆ OptParticle0Id

◆ OptParticle1Id

◆ OptParticleId