Implementation of the interface ILArDAC2uA for MC Derives from LArDAC2uAComplete, and implements the phi-z symmetry. More...

#include <LArDAC2uAMC.h>

Inheritance diagram for LArDAC2uAMC:

Collaboration diagram for LArDAC2uAMC:

Public Types
typedef LArConditionsContainer< LArSingleFloatP >	CONTAINER
enum	{ ERRORCODE = LArElecCalib::ERRORCODE }
typedef LArSingleFloatP	LArCondObj
typedef unsigned int	FebId
	Typedefs for subset.
typedef LArConditionsSubset< LArSingleFloatP >	Subset
typedef LArConditionsSubset< LArSingleFloatP >::Traits	Traits
typedef Subset::ChannelVector	ChannelVector
typedef Subset::FebPairReference	FebPairReference
typedef ChannelVector::const_iterator	ChannelVectorIterator
typedef Subset::size_type	size_type
typedef Subset::ConstCorrectionVecIt	ConstCorrectionIt
typedef Subset::Reference	Reference
typedef Subset::ConstReference	ConstReference
typedef Subset::Pointer	Pointer
typedef Subset::ConstPointer	ConstPointer
typedef LArConditionsContainerDB< LArSingleFloatP >	ConditionsMap
	Typedefs for DB.
typedef ConditionsMap::const_iterator	ConstConditionsMapIterator
typedef ConditionsMap::iterator	ConditionsMapIterator
typedef std::map< unsigned int, ConditionsMap >	GainMap
typedef std::pair< unsigned int, ConditionsMap >	GainPair
typedef GainMap::const_iterator	ConstGainMapIterator
typedef GainMap::iterator	GainMapIterator
typedef CondMultChanCollection< Subset >	MultChanCollection
	Typedefs for MultChan access.
typedef MultChanCollection::chan_const_iterator	chan_const_iterator
typedef MultChanCollection::iov_const_iterator	iov_const_iterator
typedef MultChanCollection::chan_size_type	chan_size_type
typedef MultChanCollection::iov_size_type	iov_size_type
enum	GroupingType
	Grouping type. More...
typedef LArCondFEBIdChanMap::FEBIdVector	FEBIdVector
typedef unsigned int	ChanNum
typedef std::vector< ChanNum >	ChanVec
typedef std::vector< IOVRange >	IOVVec
typedef ChanVec::iterator	chan_iterator
typedef IOVVec::iterator	iov_iterator
typedef BASE	DataVector_BASE
typedef BASE	DVL_BASE
typedef BASE::PtrVector	PtrVector
	This is the type of the underlying `std::vector` (what `stdcont` returns).
typedef BASE::PtrVector	BaseContainer
typedef LArSingleFloatP *&	reference
typedef LArSingleFloatP *const &	const_reference
typedef BASE::difference_type	difference_type
typedef LArSingleFloatP *	value_type
typedef BASE::allocator_type	allocator_type
typedef LArSingleFloatP **	pointer
typedef LArSingleFloatP const	const_pointer
typedef const LArSingleFloatP *	const_value_type
typedef LArSingleFloatP	base_value_type
	The `T` value used as the template parameter.
typedef std::unique_ptr< base_value_type >	unique_type
	Type of a unique_ptr that can be used to insert elements into this container.
typedef DataModel_detail::ElementProxy< DataVector >	ElementProxy
	This type is used to proxy lvalue accesses to `DataVector` elements, in order to handle ownership.
typedef std::reverse_iterator< const_iterator >	const_reverse_iterator
	Standard `const_reverse_iterator`.
typedef std::reverse_iterator< iterator >	reverse_iterator
	Standard `reverse_iterator`.
typedef DataVector	base_data_vector
using	Deleter

Public Member Functions
	LArDAC2uAMC ()
virtual	~LArDAC2uAMC ()
virtual StatusCode	initialize ()
	Initialization done after creation or read back - derived classes may augment the functionality.
virtual const float &	DAC2UA (const HWIdentifier &CellID) const
	access to DAC2UA conversion factor index by Identifier, and gain setting
void	set (const HWIdentifier &CellID, const float vDAC2uA)
void	setPdata (const HWIdentifier id, const LArSingleFloatP &payload, unsigned int gain=0)
	put payload in persistent data
ConstReference	get (const HWIdentifier id, unsigned int gain=0) const
	get data with online identifier
Reference	get (const HWIdentifier id, unsigned int gain=0)
	non-const get data with online identifier
unsigned int	coolChannel (const HWIdentifier id, unsigned int gain=0) const
	Return the COOL channel number for a given online id and gain.
unsigned int	groupingType () const
	Type of grouping - defined in LArConditionContainerBase.h.
std::string	groupingTypeToString () const
	Type of grouping - defined in LArConditionContainerBase.h.
unsigned int	groupNumber (unsigned int coolChannel) const
	Return the group number of a COOL channel (0 - correction group, 1-N for FEB ID groups)
unsigned int	nGroups () const
	Number of groups - minimum is 2 (1 correction group, 1 FEB ID group)
unsigned int	minGain () const
	Mininum gain value.
unsigned int	nGains () const
	Number of gain values.
chan_const_iterator	chan_begin () const
	Access to Channel numbers via iterators - from MultChanCollection.
chan_const_iterator	chan_end () const
chan_size_type	chan_size () const
	number of channels - from MultChanCollection
iov_const_iterator	iov_begin () const
	Access to IOVs via iterators - from MultChanCollection.
iov_const_iterator	iov_end () const
iov_size_type	iov_size () const
	number of IOVs - from MultChanCollection
unsigned int	conditionsPerChannel (unsigned int coolChannel) const
	Statistics: number of conditions per COOL channel.
unsigned int	conditionsPerGroup (unsigned int group) const
	Statistics: number of conditions per group.
unsigned int	conditionsPerGain (unsigned int gain) const
	Statistics: number of conditions per gain.
unsigned int	totalNumberOfConditions () const
	Statistics: total number of conditions.
unsigned int	totalNumberOfCorrections () const
	Statistics: total number of corrections.
bool	correctionsApplied () const
	Have corrections been applied?
StatusCode	applyCorrections ()
	apply correction set
StatusCode	undoCorrections ()
	undo corrections that have been already applied
StatusCode	insertCorrection (HWIdentifier id, const LArSingleFloatP &cond, unsigned int gain, bool corrChannel=true)
	access to corrections -
ConstCorrectionIt	undoCorrBegin (unsigned int gain) const
	get iterator over the Undo-Vector for a certain gain
ConstCorrectionIt	undoCorrEnd (unsigned int gain) const
ConstConditionsMapIterator	begin (unsigned int gain) const
	get iterator for all channels for a gain
ConditionsMapIterator	begin (unsigned int gain)
ConstConditionsMapIterator	begin (unsigned int gain, const std::vector< FebId > &febIds) const
	get iterator for all channels for a gain, restricted to a list of FebIds
ConditionsMapIterator	begin (unsigned int gain, const std::vector< FebId > &febIds)
ConstConditionsMapIterator	begin (unsigned int gain, const HWIdentifier &febId) const
	get iterator for all channels for a gain, restricted to one Feb
ConditionsMapIterator	begin (unsigned int gain, const HWIdentifier &febId)
ConstConditionsMapIterator	end (unsigned int gain) const
	end of all channels for this gain
ConditionsMapIterator	end (unsigned int gain)
void	removeConditions ()
	Remove conditions leaving the corrections - may be needed to only write out the corrections when both are present.
void	removeConditionsChannel (unsigned int coolChannel)
	Remove the conditions for a specific cool channel - e.g.
std::vector< unsigned >	completeCorrectionChannels ()
	Fill all non-existing Correction Channels with emtpy subsets This is necessary to terminate the IOV of the previous correction.
bool	merge (const LArConditionsContainer< LArSingleFloatP > &other)
StatusCode	initializeBase ()
	initialize
void	setGroupingType (GroupingType type)
	allow group type to be set externally - need to (re)initialize after setting grouping type
StatusCode	setGroupingType (const std::string &groupingStr, MsgStream &logStr)
	allow group type to be set externally based on a string returns an FAILURE and a message to logStr if unknown string is supplied
const LArOnlineID_Base *	onlineHelper () const
	provide access to online id helper
const CaloCell_Base_ID *	offlineHelper () const
	provide access to offline id helper
const FEBIdVector &	febIdVector (unsigned int gain, unsigned int coolChannel) const
	Access to a FEB ID vector for a given gain and COOL channel.
IOVRange	minRange () const
	Current minimal IOVRange.
bool	hasUniqueIOV () const
	Check whether there is a unique IOV for all channels.
void	add (ChanNum chanNum)
	Adding in channel numbers.
void	add (const IOVRange &range)
	Adding in iov ranges.
void	addNewStop (const IOVTime &stop)
	Add new stop time to minRange - make sure that stop is <= to new stop.
void	resetChannelNumbers ()
	Reset channel numbers - needed to allow sorting.
CondMultChanCollImpl *	implementation ()
	Get implementation.
Element access.
Change the vector capacity to match the current size. Note: this does not affect auxiliary data.
const LArSingleFloatP *	get (size_type n) const
	Access an element, as an rvalue.
const LArSingleFloatP *	operator[] (size_type n) const
	Access an element, as an rvalue.
ElementProxy	operator[] (size_type n)
	Access an element, as an lvalue.
const LArSingleFloatP *	at (size_type n) const
	Access an element, as an rvalue.
ElementProxy	at (size_type n)
	Access an element, as an lvalue.
const LArSingleFloatP *	front () const
	Access the first element in the collection as an rvalue.
ElementProxy	front ()
	Access the first element in the collection as an lvalue.
const LArSingleFloatP *	back () const
	Access the last element in the collection as an rvalue.
ElementProxy	back ()
	Access the last element in the collection as an lvalue.
Iterator creation.
const_iterator	begin () const noexcept
	Return a `const_iterator` pointing at the beginning of the collection.
iterator	begin () noexcept
	Return an `iterator` pointing at the beginning of the collection.
const_iterator	end () const noexcept
	Return a `const_iterator` pointing past the end of the collection.
iterator	end () noexcept
	Return an `iterator` pointing past the end of the collection.
const_reverse_iterator	rbegin () const noexcept
	Return a `const_reverse_iterator` pointing past the end of the collection.
reverse_iterator	rbegin () noexcept
	Return a `reverse_iterator` pointing past the end of the collection.
const_reverse_iterator	rend () const noexcept
	Return a `const_reverse_iterator` pointing at the beginning of the collection.
reverse_iterator	rend () noexcept
	Return a `reverse_iterator` pointing at the beginning of the collection.
const_iterator	cbegin () const noexcept
	Return a `const_iterator` pointing at the beginning of the collection.
const_iterator	cend () const noexcept
	Return a `const_iterator` pointing past the end of the collection.
const_reverse_iterator	crbegin () const noexcept
	Return a `const_reverse_iterator` pointing past the end of the collection.
const_reverse_iterator	crend () const noexcept
	Return a `const_reverse_iterator` pointing at the beginning of the collection.
Constructors, destructors, assignment.
void	assign (InputIterator first, InputIterator last)
	Assign from iterators.
void	assign (std::initializer_list< value_type > l)
Size and capacity.
size_type	size () const noexcept
	Returns the number of elements in the collection.
void	resize (size_type sz)
	Resizes the collection to the specified number of elements.
void	reserve (size_type n)
	Attempt to preallocate enough memory for a specified number of elements.
Insertion operations.
value_type	push_back (value_type pElem)
	Add an element to the end of the collection.
value_type	push_back (std::unique_ptr< base_value_type > pElem)
	Add an element to the end of the collection.
size_type	push_new (size_type n, F alloc)
	Create and add a number of new elements to the end of the container.
value_type	emplace_back (value_type pElem)
	Add an element to the end of the collection.
iterator	insert (iterator position, value_type pElem)
	Add a new element to the collection.
iterator	insert (iterator position, std::unique_ptr< base_value_type > pElem)
	Add a new element to the collection.
void	insert (iterator position, InputIterator first, InputIterator last)
	Add a group of new elements to the collection.
void	insert (iterator position, InputIterator first, InputIterator last)
	Add a group of new elements to the collection.
void	insert (iterator position, std::initializer_list< value_type > l)
	Add a group of new elements to the collection.
iterator	emplace (iterator position, value_type pElem)
	Add a new element to the collection.
void	insertMove (iterator position, DataVector &other)
	Insert the contents of another `DataVector`, with auxiliary data copied via move semantics.
Erasure operations.
iterator	erase (iterator position)
	Remove element at a given position.
iterator	erase (iterator first, iterator last)
	Remove a range of elements.
void	pop_back ()
	Remove the last element from the collection.
void	clear ()
	Erase all the elements in the collection.

Static Public Member Functions
static bool	applyCorrectionsAtInit (bool setFlag=false, bool flag=true)
	provide access to flag which determines corrections are applied at initialize, i.e.

Static Public Attributes
static constexpr float	dummy =LArElecCalib::ERRORCODE
static const bool	has_virtual
	This is true for any `DataVector` class if we need to use virtual derivation to get to the base `DataVector` class.
static constexpr bool	must_own
	If true, then this type must own its contents.

Protected Member Functions
ConstReference	empty () const
	Access to standard empty value.
StatusCode	initGrouping ()
void	correctionIndexAndCoolChannel (HWIdentifier id, unsigned int gain, unsigned int &index, unsigned int &coolChannel)

Protected Attributes
GainMap	m_cached
	Map indexed by gain providing pointers into the data in the CondMultChanCollection.
GroupingType	m_groupType
LArCondFEBIdChanMap	m_febIdChanMap
const LArOnlineID_Base *	m_onlineHelper
const CaloCell_Base_ID *	m_offlineHelper
std::vector< unsigned int >	m_channelToMultChanCollIndex
bool	m_isInitialized

Private Types
typedef std::vector< ConstPointer >	TVector
typedef TVector::const_iterator	TVectorIterator
typedef std::map< unsigned int, TVector >	TVectorMap
typedef TVectorMap::const_iterator	TVectorMapIterator
typedef Subset::CorrectionPair	CorrectionPair
typedef Subset::CorrectionVec	CorrectionVector
typedef Subset::ConstCorrectionVecIt	ConstCorrectionVecIt
typedef std::vector< CorrectionVector >	CorrectionVectors
typedef DataVector< Subset >	SubsetDV
typedef SubsetDV::const_iterator	const_iterator
typedef SubsetDV::iterator	iterator

Private Member Functions
StatusCode	updateConditionsMap (FebId id, unsigned int gain, ConditionsMap &conditionsMap)
	Update the ConditionsMap for a new FEB ID.
void	sortSubsets ()
	Sort subsets by channel number.

Private Attributes
ConstCorrectionIt	m_dummyCorrIt
	Dummy iterator (returned if requested for invalid gain)
CorrectionVectors	m_correctionsUndo
bool	m_correctionsApplied
CorrectionVector	m_emptyCorrectionVec
CondMultChanCollImpl	m_impl

Non-standard operations.
void	resize (size_type sz)
void	pop_back ()
void	clear (SG::OwnershipPolicy ownPolicy)
	Erase all the elements in the collection, and reset the ownership mode.
void	clear (SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy trackIndices)
void	clear (std::unique_ptr< Deleter > deleter)
	Erase all the elements in the collection, and change how elements are to be deleted.
void	clear ()
void	clear (SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)
void	swapElement (size_type index, value_type newElem, reference oldElem)
	Swap one element out of the container.
void	swapElement (iterator pos, value_type newElem, reference oldElem)
	Swap one element out of the container.
void	swapElement (size_type index, std::unique_ptr< base_value_type > newElem, std::unique_ptr< base_value_type > &oldElem)
	Swap one element out of the container.
void	swapElement (iterator pos, std::unique_ptr< base_value_type > newElem, std::unique_ptr< base_value_type > &oldElem)
	Swap one element out of the container.
virtual const DataModel_detail::DVLInfoBase &	dvlinfo_v () const override
	Return the DV/DL info struct for this class.
const SG::AuxVectorBase &	auxbase () const
	Convert to `AuxVectorBase`.
size_type	max_size () const noexcept
	Returns the `size()` of the largest possible collection.
size_type	capacity () const noexcept
	Returns the total number of elements that the collection can hold before needing to allocate more memory.
void	shrink_to_fit ()
const PtrVector &	stdcont () const
	Return the underlying `std::vector` of the container.
SG::OwnershipPolicy	ownPolicy () const
	Return the ownership policy setting for this container.
static const DataModel_detail::DVLInfoBase &	dvlinfo ()
	Return the DV/DL info struct for this class.
static int	baseOffset (const std::type_info &ti)
	Return the offset of a base `DataVector` class.

Swap and sort.
void	swap (DataVector &rhs)
	Swap this collection with another.
void	sort ()
	Sort the container.
void	sort (COMPARE comp)
	Sort the container with a user-specified comparison operator.
static void	iter_swap (iterator a, iterator b)
	Swap the referents of two `DataVector` iterators.

Internal operations.
void	resortAux (iterator beg, iterator end)
	Reset indices / reorder aux data after elements have been permuted.
void	testInsert (const char *op)
	Test if we can insert; raise an exception if not.
void	testInsertOol (const char *op)
	Test if we can insert; raise an exception if not.
SG::IsMostDerivedFlag	m_isMostDerived
	This flag is true if this DV instance is the most-derived one.
void	clearMostDerived ()
	Clear `m_isMostDerived` for this instance and for all bases.
virtual void	setMostDerived () override
	Set `m_isMostDerived` for this instance and clear it for all bases.
void	assignElement (typename BaseContainer::iterator pos, value_type newElem)
	Handle element assignment.
void	assignElement (typename BaseContainer::iterator pos, std::unique_ptr< base_value_type > newElem)
	Handle element assignment.
void	assignBaseElement (typename BaseContainer::iterator pos, typename BaseContainer::value_type newElem)
	Handle element assignment from a base pointer.
void	shift (size_t pos, ptrdiff_t offs)
	Shift the auxiliary elements of the container.
virtual const std::type_info &	dv_typeid () const override
	Find the most-derived `DataVector` class in the hierarchy.
typedef ROOT::Meta::Selection::DataVector< LArSingleFloatP, DataVector_BASE >::self	self
static int	baseOffset1 (const char *p, const DataVector &dv, const std::type_info &ti)
	Helper for `baseOffset`.
static const LArSingleFloatP *	do_cast (const typename PtrVector::value_type p)
	Helper to shorten calls to `DataModel_detail::DVLCast`.
static LArSingleFloatP *	do_cast_nc (typename PtrVector::value_type p)
	Helper to shorten calls to `DataModel_detail::DVLCast`.

Detailed Description

Implementation of the interface ILArDAC2uA for MC Derives from LArDAC2uAComplete, and implements the phi-z symmetry.

Author: S. Laplace

Version: 0-0-1 , 02/02/2004

History:

08/02/2004, S. Laplace: new online ID
29/04/2004, S. Laplace: added ERRORCODE

Definition at line 21 of file LArDAC2uAMC.h.

Member Typedef Documentation

◆ allocator_type

typedef BASE::allocator_type DataVector< LArSingleFloatP, BASE >::allocator_type

inherited

Definition at line 817 of file DataVector.h.

◆ base_data_vector

typedef DataVector DataVector< LArSingleFloatP, BASE >::base_data_vector

inherited

Definition at line 854 of file DataVector.h.

◆ base_value_type

typedef LArSingleFloatP DataVector< LArSingleFloatP, BASE >::base_value_type

inherited

The T value used as the template parameter.

Note that this is different from value_type (that's T*).

Definition at line 825 of file DataVector.h.

◆ BaseContainer

typedef BASE::PtrVector DataVector< LArSingleFloatP, BASE >::BaseContainer

inherited

Definition at line 807 of file DataVector.h.

◆ chan_const_iterator

typedef MultChanCollection::chan_const_iterator LArConditionsContainer< LArSingleFloatP >::chan_const_iterator

inherited

Definition at line 95 of file LArConditionsContainer.h.

◆ chan_iterator

typedef ChanVec::iterator CondMultChanCollection< LArSingleFloatP >::chan_iterator

inherited

Definition at line 59 of file CondMultChanCollection.h.

◆ chan_size_type

typedef MultChanCollection::chan_size_type LArConditionsContainer< LArSingleFloatP >::chan_size_type

inherited

Definition at line 97 of file LArConditionsContainer.h.

◆ ChannelVector

typedef Subset::ChannelVector LArConditionsContainer< LArSingleFloatP >::ChannelVector

inherited

Definition at line 74 of file LArConditionsContainer.h.

◆ ChannelVectorIterator

typedef ChannelVector::const_iterator LArConditionsContainer< LArSingleFloatP >::ChannelVectorIterator

inherited

Definition at line 76 of file LArConditionsContainer.h.

◆ ChanNum

typedef unsigned int CondMultChanCollection< LArSingleFloatP >::ChanNum

inherited

Definition at line 55 of file CondMultChanCollection.h.

◆ ChanVec

typedef std::vector<ChanNum> CondMultChanCollection< LArSingleFloatP >::ChanVec

inherited

Definition at line 56 of file CondMultChanCollection.h.

◆ ConditionsMap

typedef LArConditionsContainerDB<LArSingleFloatP> LArConditionsContainer< LArSingleFloatP >::ConditionsMap

inherited

Typedefs for DB.

Definition at line 85 of file LArConditionsContainer.h.

◆ ConditionsMapIterator

typedef ConditionsMap::iterator LArConditionsContainer< LArSingleFloatP >::ConditionsMapIterator

inherited

Definition at line 87 of file LArConditionsContainer.h.

◆ const_iterator

typedef SubsetDV::const_iterator LArConditionsContainer< LArSingleFloatP >::const_iterator

privateinherited

Definition at line 322 of file LArConditionsContainer.h.

◆ const_pointer

typedef LArSingleFloatP* const* DataVector< LArSingleFloatP, BASE >::const_pointer

inherited

Definition at line 819 of file DataVector.h.

◆ const_reference

typedef LArSingleFloatP* const& DataVector< LArSingleFloatP, BASE >::const_reference

inherited

Definition at line 813 of file DataVector.h.

◆ const_reverse_iterator

typedef std::reverse_iterator<const_iterator> DataVector< LArSingleFloatP, BASE >::const_reverse_iterator

inherited

Standard const_reverse_iterator.

Definition at line 847 of file DataVector.h.

◆ const_value_type

typedef const LArSingleFloatP* DataVector< LArSingleFloatP, BASE >::const_value_type

inherited

Definition at line 821 of file DataVector.h.

◆ ConstConditionsMapIterator

typedef ConditionsMap::const_iterator LArConditionsContainer< LArSingleFloatP >::ConstConditionsMapIterator

inherited

Definition at line 86 of file LArConditionsContainer.h.

◆ ConstCorrectionIt

typedef Subset::ConstCorrectionVecIt LArConditionsContainer< LArSingleFloatP >::ConstCorrectionIt

inherited

Definition at line 78 of file LArConditionsContainer.h.

◆ ConstCorrectionVecIt

typedef Subset::ConstCorrectionVecIt LArConditionsContainer< LArSingleFloatP >::ConstCorrectionVecIt

privateinherited

Definition at line 319 of file LArConditionsContainer.h.

◆ ConstGainMapIterator

typedef GainMap::const_iterator LArConditionsContainer< LArSingleFloatP >::ConstGainMapIterator

inherited

Definition at line 90 of file LArConditionsContainer.h.

◆ ConstPointer

typedef Subset::ConstPointer LArConditionsContainer< LArSingleFloatP >::ConstPointer

inherited

Definition at line 82 of file LArConditionsContainer.h.

◆ ConstReference

typedef Subset::ConstReference LArConditionsContainer< LArSingleFloatP >::ConstReference

inherited

Definition at line 80 of file LArConditionsContainer.h.

◆ CONTAINER

typedef LArConditionsContainer<LArSingleFloatP> LArDAC2uAComplete::CONTAINER

inherited

Definition at line 30 of file LArDAC2uAComplete.h.

◆ CorrectionPair

typedef Subset::CorrectionPair LArConditionsContainer< LArSingleFloatP >::CorrectionPair

privateinherited

Definition at line 317 of file LArConditionsContainer.h.

◆ CorrectionVector

typedef Subset::CorrectionVec LArConditionsContainer< LArSingleFloatP >::CorrectionVector

privateinherited

Definition at line 318 of file LArConditionsContainer.h.

◆ CorrectionVectors

typedef std::vector<CorrectionVector> LArConditionsContainer< LArSingleFloatP >::CorrectionVectors

privateinherited

Definition at line 320 of file LArConditionsContainer.h.

◆ DataVector_BASE

typedef BASE DataVector< LArSingleFloatP, BASE >::DataVector_BASE

inherited

Definition at line 797 of file DataVector.h.

◆ Deleter

using DataVector< LArSingleFloatP, BASE >::Deleter

inherited

Definition at line 857 of file DataVector.h.

◆ difference_type

typedef BASE::difference_type DataVector< LArSingleFloatP, BASE >::difference_type

inherited

Definition at line 815 of file DataVector.h.

◆ DVL_BASE

typedef BASE DataVector< LArSingleFloatP, BASE >::DVL_BASE

inherited

Definition at line 798 of file DataVector.h.

◆ ElementProxy

typedef DataModel_detail::ElementProxy<DataVector> DataVector< LArSingleFloatP, BASE >::ElementProxy

inherited

This type is used to proxy lvalue accesses to DataVector elements, in order to handle ownership.

Definition at line 833 of file DataVector.h.

◆ FebId

typedef unsigned int LArConditionsContainer< LArSingleFloatP >::FebId

inherited

Typedefs for subset.

Definition at line 71 of file LArConditionsContainer.h.

◆ FEBIdVector

typedef LArCondFEBIdChanMap::FEBIdVector LArConditionsContainerBase::FEBIdVector

inherited

Definition at line 54 of file LArConditionsContainerBase.h.

◆ FebPairReference

typedef Subset::FebPairReference LArConditionsContainer< LArSingleFloatP >::FebPairReference

inherited

Definition at line 75 of file LArConditionsContainer.h.

◆ GainMap

typedef std::map<unsigned int, ConditionsMap > LArConditionsContainer< LArSingleFloatP >::GainMap

inherited

Definition at line 88 of file LArConditionsContainer.h.

◆ GainMapIterator

typedef GainMap::iterator LArConditionsContainer< LArSingleFloatP >::GainMapIterator

inherited

Definition at line 91 of file LArConditionsContainer.h.

◆ GainPair

typedef std::pair<unsigned int, ConditionsMap > LArConditionsContainer< LArSingleFloatP >::GainPair

inherited

Definition at line 89 of file LArConditionsContainer.h.

◆ iov_const_iterator

typedef MultChanCollection::iov_const_iterator LArConditionsContainer< LArSingleFloatP >::iov_const_iterator

inherited

Definition at line 96 of file LArConditionsContainer.h.

◆ iov_iterator

typedef IOVVec::iterator CondMultChanCollection< LArSingleFloatP >::iov_iterator

inherited

Definition at line 62 of file CondMultChanCollection.h.

◆ iov_size_type

typedef MultChanCollection::iov_size_type LArConditionsContainer< LArSingleFloatP >::iov_size_type

inherited

Definition at line 98 of file LArConditionsContainer.h.

◆ IOVVec

typedef std::vector<IOVRange> CondMultChanCollection< LArSingleFloatP >::IOVVec

inherited

Definition at line 57 of file CondMultChanCollection.h.

◆ iterator

typedef SubsetDV::iterator LArConditionsContainer< LArSingleFloatP >::iterator

privateinherited

Definition at line 323 of file LArConditionsContainer.h.

◆ LArCondObj

typedef LArSingleFloatP LArConditionsContainer< LArSingleFloatP >::LArCondObj

inherited

Definition at line 69 of file LArConditionsContainer.h.

◆ MultChanCollection

typedef CondMultChanCollection<Subset> LArConditionsContainer< LArSingleFloatP >::MultChanCollection

inherited

Typedefs for MultChan access.

Definition at line 94 of file LArConditionsContainer.h.

◆ Pointer

typedef Subset::Pointer LArConditionsContainer< LArSingleFloatP >::Pointer

inherited

Definition at line 81 of file LArConditionsContainer.h.

◆ pointer

typedef LArSingleFloatP** DataVector< LArSingleFloatP, BASE >::pointer

inherited

Definition at line 818 of file DataVector.h.

◆ PtrVector

typedef BASE::PtrVector DataVector< LArSingleFloatP, BASE >::PtrVector

inherited

This is the type of the underlying std::vector (what stdcont returns).

Definition at line 806 of file DataVector.h.

◆ Reference

typedef Subset::Reference LArConditionsContainer< LArSingleFloatP >::Reference

inherited

Definition at line 79 of file LArConditionsContainer.h.

◆ reference

typedef LArSingleFloatP*& DataVector< LArSingleFloatP, BASE >::reference

inherited

Definition at line 812 of file DataVector.h.

◆ reverse_iterator

typedef std::reverse_iterator<iterator> DataVector< LArSingleFloatP, BASE >::reverse_iterator

inherited

Standard reverse_iterator.

Note that lvalue references here will yield an ElementProxy, not a reference.

Definition at line 852 of file DataVector.h.

◆ self

typedef ROOT::Meta::Selection::DataVector<LArSingleFloatP,DataVector_BASE>::self DataVector< LArSingleFloatP, BASE >::self

privateinherited

Definition at line 2063 of file DataVector.h.

◆ size_type

typedef Subset::size_type LArConditionsContainer< LArSingleFloatP >::size_type

inherited

Definition at line 77 of file LArConditionsContainer.h.

◆ Subset

typedef LArConditionsSubset<LArSingleFloatP> LArConditionsContainer< LArSingleFloatP >::Subset

inherited

Definition at line 72 of file LArConditionsContainer.h.

◆ SubsetDV

typedef DataVector<Subset> LArConditionsContainer< LArSingleFloatP >::SubsetDV

privateinherited

Definition at line 321 of file LArConditionsContainer.h.

◆ Traits

typedef LArConditionsSubset<LArSingleFloatP>::Traits LArConditionsContainer< LArSingleFloatP >::Traits

inherited

Definition at line 73 of file LArConditionsContainer.h.

◆ TVector

typedef std::vector<ConstPointer> LArConditionsContainer< LArSingleFloatP >::TVector

privateinherited

Definition at line 313 of file LArConditionsContainer.h.

◆ TVectorIterator

typedef TVector::const_iterator LArConditionsContainer< LArSingleFloatP >::TVectorIterator

privateinherited

Definition at line 314 of file LArConditionsContainer.h.

◆ TVectorMap

typedef std::map<unsigned int, TVector> LArConditionsContainer< LArSingleFloatP >::TVectorMap

privateinherited

Definition at line 315 of file LArConditionsContainer.h.

◆ TVectorMapIterator

typedef TVectorMap::const_iterator LArConditionsContainer< LArSingleFloatP >::TVectorMapIterator

privateinherited

Definition at line 316 of file LArConditionsContainer.h.

◆ unique_type

typedef std::unique_ptr<base_value_type> DataVector< LArSingleFloatP, BASE >::unique_type

inherited

Type of a unique_ptr that can be used to insert elements into this container.

Definition at line 829 of file DataVector.h.

◆ value_type

typedef LArSingleFloatP* DataVector< LArSingleFloatP, BASE >::value_type

inherited

Definition at line 816 of file DataVector.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

inherited

Enumerator
ERRORCODE

Definition at line 37 of file ILArDAC2uA.h.

37{ERRORCODE = LArElecCalib::ERRORCODE};

ILArDAC2uA::ERRORCODE

@ ERRORCODE

Definition ILArDAC2uA.h:37

LArElecCalib::ERRORCODE

@ ERRORCODE

Definition LArCalibErrorCode.h:17

◆ GroupingType

enum LArConditionsContainerBase::GroupingType

inherited

Grouping type.

Definition at line 44 of file LArConditionsContainerBase.h.

                      {
        Unknown      = 0,
    SingleGroup,
    SubDetectorGrouping,
    FeedThroughGrouping,
    ExtendedFTGrouping,
    ExtendedSubDetGrouping,
    SuperCells
    };

Constructor & Destructor Documentation

◆ LArDAC2uAMC()

LArDAC2uAMC::LArDAC2uAMC ( )

Definition at line 7 of file LArDAC2uAMC.cxx.

7 :LArDAC2uAComplete()

8{}

LArDAC2uAComplete::LArDAC2uAComplete

LArDAC2uAComplete()

Definition LArDAC2uAComplete.cxx:8

◆ ~LArDAC2uAMC()

LArDAC2uAMC::~LArDAC2uAMC ( )

virtual

Definition at line 14 of file LArDAC2uAMC.cxx.

14{}

Member Function Documentation

◆ add() [1/2]

template<typename T>

void CondMultChanCollection< T >::add ( const IOVRange & range )

inlineinherited

Adding in iov ranges.

Definition at line 208 of file CondMultChanCollection.h.

{
    m_impl.add(range);
}

◆ add() [2/2]

void CondMultChanCollection< LArSingleFloatP >::add ( ChanNum chanNum )

inlineinherited

Adding in channel numbers.

Definition at line 89 of file CondMultChanCollection.h.

{
    m_impl.add(chanNum);
}

◆ addNewStop()

void CondMultChanCollection< LArSingleFloatP >::addNewStop ( const IOVTime & stop )

inlineinherited

Add new stop time to minRange - make sure that stop is <= to new stop.

Definition at line 96 of file CondMultChanCollection.h.

{
    m_impl.addNewStop(stop);
}

◆ applyCorrections()

StatusCode LArConditionsContainer< LArSingleFloatP >::applyCorrections ( )

inherited

apply correction set

◆ applyCorrectionsAtInit()

bool LArConditionsContainerBase::applyCorrectionsAtInit	(	bool	setFlag = false,
		bool	flag = true )

staticinherited

provide access to flag which determines corrections are applied at initialize, i.e.

when conditions are read in. Default is true. This is a class (static) variable which applied to ALL conditions in a job! If one wants to change the value of the flag, pass in arguments:

Definition at line 92 of file LArConditionsContainerBase.cxx.

{
    // If setFlag is true, change the value of static flag, otherwise
    // return current value
 
    // Default value is true
    static std::atomic<bool> applyCorrs = true;
    
    if (setFlag) applyCorrs = flag;
    
    return (applyCorrs);
}

◆ assign() [1/2]

void DataVector< LArSingleFloatP, BASE >::assign	(	InputIterator	first,
		InputIterator	last )

inherited

Assign from iterators.

Parameters

first	The start of the range to put in the container.
last	The end of the range to put in the container.

Any existing owned elements will be released. The DataVector's ownership policy determines whether it will take ownership of the new elements.

◆ assign() [2/2]

void DataVector< LArSingleFloatP, BASE >::assign ( std::initializer_list< value_type > l )

inherited

Parameters

l	An initializer list.

Any existing owned elements will be released. The DataVector's ownership policy determines whether it will take ownership of the new elements.

◆ assignBaseElement()

void DataVector< LArSingleFloatP, BASE >::assignBaseElement	(	typename BaseContainer::iterator	pos,
		typename BaseContainer::value_type	newElem )

privateinherited

Handle element assignment from a base pointer.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The old element is freed if this container owns elements. Auxiliary data are copied if appropriate.

◆ assignElement() [1/2]

void DataVector< LArSingleFloatP, BASE >::assignElement	(	typename BaseContainer::iterator	pos,
		std::unique_ptr< base_value_type >	newElem )

privateinherited

Handle element assignment.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The container must own its elements. Auxiliary data are copied if appropriate.

◆ assignElement() [2/2]

void DataVector< LArSingleFloatP, BASE >::assignElement	(	typename BaseContainer::iterator	pos,
		value_type	newElem )

privateinherited

Handle element assignment.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The old element is freed if this container owns elements. Auxiliary data are copied if appropriate.

◆ at() [1/2]

ElementProxy DataVector< LArSingleFloatP, BASE >::at ( size_type n )

inherited

Access an element, as an lvalue.

Parameters

n	Array index to access.

Returns: Proxy to the element at n.

Will raise std::out_of_range if the index is out-of-bounds. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ at() [2/2]

const LArSingleFloatP * DataVector< LArSingleFloatP, BASE >::at ( size_type n ) const

inherited

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

Will raise std::out_of_range if the index is out-of-bounds. Note that we return a const T* rather than a reference.

◆ auxbase()

const SG::AuxVectorBase & DataVector< LArSingleFloatP, BASE >::auxbase ( ) const

inherited

Convert to AuxVectorBase.

Needed to get AuxVectorBase from a ConstDataVector. Present in DataVector as well for consistency. We only really need it in the base class; however, root6 fails constructing a TMethodCall for this if there is virtual derivation. A workaround is to redeclare this in the derived classes too.

◆ back() [1/2]

ElementProxy DataVector< LArSingleFloatP, BASE >::back ( )

inherited

Access the last element in the collection as an lvalue.

Returns: Proxy to the last element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ back() [2/2]

const LArSingleFloatP * DataVector< LArSingleFloatP, BASE >::back ( ) const

inherited

Access the last element in the collection as an rvalue.

Returns: The last element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a const T* rather than a reference.

◆ baseOffset()

int DataVector< LArSingleFloatP, BASE >::baseOffset ( const std::type_info & ti )

staticinherited

Return the offset of a base DataVector class.

Parameters

ti	`std::type_info` of the desired class.

If ti represents a DataVector base class of this one, then return the offset of that base class. Otherwise, return -1.

This function is here due to limitations of root 6, which can't calculate these offsets correctly from the dictionary if virtual derivation is used.

◆ baseOffset1()

int DataVector< LArSingleFloatP, BASE >::baseOffset1	(	const char *	p,
		const DataVector &	dv,
		const std::type_info &	ti )

staticinherited

Helper for baseOffset.

Parameters

p	Pointer to the start of the top-level object.
dv	Reference to the DataVector object.
ti	`std::type_info` of the desired class.

If ti represents a DataVector base class of this one, then return the offset of that base class. Otherwise, return -1.

◆ begin() [1/8]

const_iterator DataVector< LArSingleFloatP, BASE >::begin ( ) const

noexceptinherited

Return a const_iterator pointing at the beginning of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ begin() [2/8]

iterator DataVector< LArSingleFloatP, BASE >::begin ( )

noexceptinherited

Return an iterator pointing at the beginning of the collection.

Returns: An iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ begin() [3/8]

ConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::begin ( unsigned int gain )

inherited

◆ begin() [4/8]

ConstConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::begin ( unsigned int gain ) const

inherited

get iterator for all channels for a gain

◆ begin() [5/8]

ConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::begin	(	unsigned int	gain,
		const HWIdentifier &	febId )

inherited

◆ begin() [6/8]

ConstConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::begin	(	unsigned int	gain,
		const HWIdentifier &	febId ) const

inherited

get iterator for all channels for a gain, restricted to one Feb

◆ begin() [7/8]

ConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::begin	(	unsigned int	gain,
		const std::vector< FebId > &	febIds )

inherited

◆ begin() [8/8]

ConstConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::begin	(	unsigned int	gain,
		const std::vector< FebId > &	febIds ) const

inherited

get iterator for all channels for a gain, restricted to a list of FebIds

◆ capacity()

size_type DataVector< LArSingleFloatP, BASE >::capacity ( ) const

noexceptinherited

Returns the total number of elements that the collection can hold before needing to allocate more memory.

◆ cbegin()

const_iterator DataVector< LArSingleFloatP, BASE >::cbegin ( ) const

noexceptinherited

Return a const_iterator pointing at the beginning of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ cend()

const_iterator DataVector< LArSingleFloatP, BASE >::cend ( ) const

noexceptinherited

Return a const_iterator pointing past the end of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ chan_begin()

chan_const_iterator LArConditionsContainer< LArSingleFloatP >::chan_begin ( ) const

inherited

Access to Channel numbers via iterators - from MultChanCollection.

◆ chan_end()

chan_const_iterator LArConditionsContainer< LArSingleFloatP >::chan_end ( ) const

inherited

◆ chan_size()

chan_size_type LArConditionsContainer< LArSingleFloatP >::chan_size ( ) const

inherited

number of channels - from MultChanCollection

◆ clear() [1/6]

void DataVector< LArSingleFloatP, BASE >::clear ( )

inherited

Erase all the elements in the collection.

Erase all the elements in the collection, and reset the ownership mode.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

Parameters

ownPolicy	The new ownership policy of the container.
trackIndices	The index tracking policy.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

◆ clear() [2/6]

void DataVector< LArSingleFloatP, BASE >::clear ( )

inherited

◆ clear() [3/6]

void DataVector< LArSingleFloatP, BASE >::clear ( SG::OwnershipPolicy ownPolicy )

inherited

Erase all the elements in the collection, and reset the ownership mode.

Parameters

ownPolicy The new ownership policy of the container.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

◆ clear() [4/6]

void DataVector< LArSingleFloatP, BASE >::clear	(	SG::OwnershipPolicy	ownPolicy,
		SG::IndexTrackingPolicy	trackIndices )

inherited

◆ clear() [5/6]

void DataVector< LArSingleFloatP, BASE >::clear	(	SG::OwnershipPolicy	ownPolicy,
		SG::IndexTrackingPolicy	trackIndices = SG::DEFAULT_TRACK_INDICES )

inherited

◆ clear() [6/6]

void DataVector< LArSingleFloatP, BASE >::clear ( std::unique_ptr< Deleter > deleter )

inherited

Erase all the elements in the collection, and change how elements are to be deleted.

Parameters

deleter Object to be used to delete object. Passing nullptr will change back to the default.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this. After the current elements are deleted, the Deleter object is changed.

◆ clearMostDerived()

void DataVector< LArSingleFloatP, BASE >::clearMostDerived ( )

protectedinherited

Clear m_isMostDerived for this instance and for all bases.

Called from the constructor after setting m_isMostDerived.

◆ completeCorrectionChannels()

std::vector< unsigned > LArConditionsContainer< LArSingleFloatP >::completeCorrectionChannels ( )

inherited

Fill all non-existing Correction Channels with emtpy subsets This is necessary to terminate the IOV of the previous correction.

◆ conditionsPerChannel()

unsigned int LArConditionsContainer< LArSingleFloatP >::conditionsPerChannel ( unsigned int coolChannel ) const

inherited

Statistics: number of conditions per COOL channel.

◆ conditionsPerGain()

unsigned int LArConditionsContainer< LArSingleFloatP >::conditionsPerGain ( unsigned int gain ) const

inherited

Statistics: number of conditions per gain.

◆ conditionsPerGroup()

unsigned int LArConditionsContainer< LArSingleFloatP >::conditionsPerGroup ( unsigned int group ) const

inherited

Statistics: number of conditions per group.

◆ coolChannel()

unsigned int LArConditionsContainer< LArSingleFloatP >::coolChannel	(	const HWIdentifier	id,
		unsigned int	gain = 0 ) const

inherited

Return the COOL channel number for a given online id and gain.

◆ correctionIndexAndCoolChannel()

void LArConditionsContainerBase::correctionIndexAndCoolChannel	(	HWIdentifier	id,
		unsigned int	gain,
		unsigned int &	index,
		unsigned int &	coolChannel )

protectedinherited

Definition at line 102 of file LArConditionsContainerBase.cxx.

{
    MsgStream log(Athena::getMessageSvc(), "LArConditionsContainerBase");
 
    index       = 9999;
    coolChannel = 0;
    // First get cool channel number
    if (!m_onlineHelper) {
        log << MSG::ERROR << "correctionIndex> Could not get online id helper!" << endmsg;
        return;
    }
 
    int p_n  = m_onlineHelper->pos_neg(id);
    if (m_onlineHelper->isEMBPS(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::PSBA;  // PS Barrel
        else     coolChannel = LArCondFEBIdChanMap::PSBC;  // PS Barrel
    }
    else if (m_onlineHelper->isEMECPS(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::PSECA; // PS Endcap
        else     coolChannel = LArCondFEBIdChanMap::PSECC; // PS Endcap
    }
    else if (m_onlineHelper->isEMBchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::EMBA;  // EM Barrel
        else     coolChannel = LArCondFEBIdChanMap::EMBC;  // EM Barrel
    }
    else if (m_onlineHelper->isEMECchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::EMECA; // EM Endcap
        else     coolChannel = LArCondFEBIdChanMap::EMECC; // EM Endcap
    }
    else if (m_onlineHelper->isHECchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::HECA;  // HEC A
        else     coolChannel = LArCondFEBIdChanMap::HECC;  // HEC C
    }
    else if (m_onlineHelper->isFCALchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::FCALA; // FCAL A
        else     coolChannel = LArCondFEBIdChanMap::FCALC; // FCAL C
    }
 
    if (!coolChannel) {
        log << MSG::ERROR << "correctionIndex> coolChannel not found! Online ids: " 
            << "  " << m_onlineHelper->show_to_string(id)
            << endmsg;
        return;
    }
 
    // add on offset for gain
    unsigned int gainOffset = (gain - m_febIdChanMap.minGain())*LArCondFEBIdChanMap::NCORRTYPE;
    coolChannel += gainOffset;
 
    // look up the index in the table
    if (coolChannel >= m_channelToMultChanCollIndex.size()) {
        log << MSG::ERROR << "correctionIndex> coolChannel larger than lookup table: chan, size " 
            << coolChannel << " " << m_channelToMultChanCollIndex.size()
            << endmsg;
    }
    else {
        index = m_channelToMultChanCollIndex[coolChannel];
    }
}

◆ correctionsApplied()

bool LArConditionsContainer< LArSingleFloatP >::correctionsApplied ( ) const

inherited

Have corrections been applied?

◆ crbegin()

const_reverse_iterator DataVector< LArSingleFloatP, BASE >::crbegin ( ) const

noexceptinherited

Return a const_reverse_iterator pointing past the end of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ crend()

const_reverse_iterator DataVector< LArSingleFloatP, BASE >::crend ( ) const

noexceptinherited

Return a const_reverse_iterator pointing at the beginning of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ DAC2UA()

const float & LArDAC2uAMC::DAC2UA ( const HWIdentifier & id ) const

virtual

access to DAC2UA conversion factor index by Identifier, and gain setting

Reimplemented from LArDAC2uAComplete.

Definition at line 19 of file LArDAC2uAMC.cxx.

{ 
  std::cout << "LArDACuAMC is deprecated. Use LArDACuASym!" << std::endl;
  std::abort();
  return dummy;
}

◆ do_cast()

const LArSingleFloatP * DataVector< LArSingleFloatP, BASE >::do_cast ( const typename PtrVector::value_type p )

staticinherited

Helper to shorten calls to DataModel_detail::DVLCast.

Parameters

p	The value to convert.

Returns: The value as a const T*.

The conversion will be done with static_cast if possible, with dynamic_cast otherwise.

◆ do_cast_nc()

LArSingleFloatP * DataVector< LArSingleFloatP, BASE >::do_cast_nc ( typename PtrVector::value_type p )

staticinherited

Helper to shorten calls to DataModel_detail::DVLCast.

Parameters

p	The value to convert.

Returns: The value as a T*.

The conversion will be done with static_cast if possible, with dynamic_cast otherwise.

◆ dv_typeid()

virtual const std::type_info & DataVector< LArSingleFloatP, BASE >::dv_typeid ( ) const

overrideprivatevirtualinherited

Find the most-derived DataVector class in the hierarchy.

Returns: The type_info for the class for which this method gets run.

This is used to generate a nice error message when the most-derived check for insertions fails. Every DataVector defines this virtual method, so when it's called, the one corresponding to the most-derived DataVector gets run.

◆ dvlinfo()

const DataModel_detail::DVLInfoBase & DataVector< LArSingleFloatP, BASE >::dvlinfo ( )

staticinherited

Return the DV/DL info struct for this class.

This can be used to make sure that it's instantiated.

◆ dvlinfo_v()

virtual const DataModel_detail::DVLInfoBase & DataVector< LArSingleFloatP, BASE >::dvlinfo_v ( ) const

overridevirtualinherited

Return the DV/DL info struct for this class.

This can be used to make sure that it's instantiated.

◆ emplace()

iterator DataVector< LArSingleFloatP, BASE >::emplace	(	iterator	position,
		value_type	pElem )

inherited

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

For DataVector, this is just the same as insert. It's included just for interface compatibility with std::vector.

◆ emplace_back()

value_type DataVector< LArSingleFloatP, BASE >::emplace_back ( value_type pElem )

inherited

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

For DataVector, this is like the same as push_back, and it returns the pushed element. It's included just for interface compatibility with std::vector.

◆ empty()

ConstReference LArConditionsContainer< LArSingleFloatP >::empty ( ) const

protectedinherited

Access to standard empty value.

◆ end() [1/4]

const_iterator DataVector< LArSingleFloatP, BASE >::end ( ) const

noexceptinherited

Return a const_iterator pointing past the end of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ end() [2/4]

iterator DataVector< LArSingleFloatP, BASE >::end ( )

noexceptinherited

Return an iterator pointing past the end of the collection.

Returns: An iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ end() [3/4]

ConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::end ( unsigned int gain )

inherited

◆ end() [4/4]

ConstConditionsMapIterator LArConditionsContainer< LArSingleFloatP >::end ( unsigned int gain ) const

inherited

end of all channels for this gain

◆ erase() [1/2]

iterator DataVector< LArSingleFloatP, BASE >::erase	(	iterator	first,
		iterator	last )

inherited

Remove a range of elements.

Parameters

first	Iterator pointing to the first element to be removed.
last	Iterator pointing one past the last element to be removed.

Returns: An iterator pointing to the element pointed to by last prior to erasing (or end()).

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

◆ erase() [2/2]

iterator DataVector< LArSingleFloatP, BASE >::erase ( iterator position )

inherited

Remove element at a given position.

Parameters

position Iterator pointing to the element to be removed.

Returns: An iterator pointing to the next element (or end()).

If the container owns its elements, then the pointed-to element will be deleted.

◆ febIdVector()

const LArConditionsContainerBase::FEBIdVector & LArConditionsContainerBase::febIdVector	(	unsigned int	gain,
		unsigned int	coolChannel ) const

inherited

Access to a FEB ID vector for a given gain and COOL channel.

Definition at line 83 of file LArConditionsContainerBase.cxx.

{
    return (m_febIdChanMap.febIdVector(gain, coolChannel));
}

◆ front() [1/2]

ElementProxy DataVector< LArSingleFloatP, BASE >::front ( )

inherited

Access the first element in the collection as an lvalue.

Returns: Proxy to the first element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ front() [2/2]

const LArSingleFloatP * DataVector< LArSingleFloatP, BASE >::front ( ) const

inherited

Access the first element in the collection as an rvalue.

Returns: The first element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a const T* rather than a reference.

◆ get() [1/3]

Reference LArConditionsContainer< LArSingleFloatP >::get	(	const HWIdentifier	id,
		unsigned int	gain = 0 )

inherited

non-const get data with online identifier

◆ get() [2/3]

ConstReference LArConditionsContainer< LArSingleFloatP >::get	(	const HWIdentifier	id,
		unsigned int	gain = 0 ) const

inherited

get data with online identifier

◆ get() [3/3]

const LArSingleFloatP * DataVector< LArSingleFloatP, BASE >::get ( size_type n ) const

inherited

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

This is a synonym for operator[] const, to be used when calling from root (where we can't readily call just the const version of a method).

◆ groupingType()

unsigned int LArConditionsContainer< LArSingleFloatP >::groupingType ( ) const

inherited

Type of grouping - defined in LArConditionContainerBase.h.

◆ groupingTypeToString()

std::string LArConditionsContainer< LArSingleFloatP >::groupingTypeToString ( ) const

inherited

Type of grouping - defined in LArConditionContainerBase.h.

◆ groupNumber()

unsigned int LArConditionsContainer< LArSingleFloatP >::groupNumber ( unsigned int coolChannel ) const

inherited

Return the group number of a COOL channel (0 - correction group, 1-N for FEB ID groups)

◆ hasUniqueIOV()

bool CondMultChanCollection< LArSingleFloatP >::hasUniqueIOV ( ) const

inlineinherited

Check whether there is a unique IOV for all channels.

Definition at line 86 of file CondMultChanCollection.h.

{
    return (m_impl.hasUniqueIOV());
}

◆ implementation()

CondMultChanCollImpl * CondMultChanCollection< LArSingleFloatP >::implementation ( )

inlineinherited

Get implementation.

Definition at line 106 of file CondMultChanCollection.h.

{
    return &m_impl;
}

◆ initGrouping()

StatusCode LArConditionsContainerBase::initGrouping ( )

protectedinherited

Definition at line 96 of file LArConditionsContainerBase.cxx.

{
    MsgStream log(Athena::getMessageSvc(), "LArConditionsContainerBase");
    log << MSG::DEBUG << "initGrouping "<< endmsg;
 
    // We allow for different groupings
 
    if (Unknown == m_groupType) {
    log << MSG::ERROR << "Unknown grouping "<< endmsg;
 
    // Not yet known
    }
    if (SingleGroup == m_groupType || SuperCells == m_groupType) {
 
    log << MSG::DEBUG << "Single group "<< endmsg;
 
    // Only one group - add all feb ids to channel 0
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
    LArCondFEBIdChanMap::FEBIdVector febIds; 
    for (; febIt != febEnd; ++febIt) {
        febIds.push_back((*febIt).get_identifier32().get_compact());
    }
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = 1;
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
    m_febIdChanMap.addFEBIdVector(0, febIds);
    }
    else if (SubDetectorGrouping == m_groupType) {
 
    log << MSG::DEBUG << "Subdetector  grouping "<< endmsg;
 
    // Set up LArCondFEBIdChanMap for four groups: EM barrel, EMEM, HEC, FCal 
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
    LArCondFEBIdChanMap::FEBIdVector emBarrel; 
    LArCondFEBIdChanMap::FEBIdVector emEndcap; 
    LArCondFEBIdChanMap::FEBIdVector hec; 
    LArCondFEBIdChanMap::FEBIdVector fcal; 
 
    for (; febIt != febEnd; ++febIt) {
            unsigned int febId = (*febIt).get_identifier32().get_compact();
        if (m_onlineHelper->isEMBchannel(*febIt)) {
        emBarrel.push_back(febId);
        }
        else if (m_onlineHelper->isEMECchannel(*febIt)) {
        emEndcap.push_back(febId);
        }
        else if (m_onlineHelper->isHECchannel(*febIt)) {
        hec.push_back(febId);
        }
        else if (m_onlineHelper->isFCALchannel(*febIt)) {
        fcal.push_back(febId);
        }
        else {
            log << MSG::DEBUG << "Uassociated FEB id: "
            << MSG::hex << (febId) << MSG::dec 
            << " isCalib " << m_onlineHelper->isCalibration(*febIt)
            << "  " << m_onlineHelper->show_to_string(*febIt)
            << endmsg;
        }
    }
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = 4;
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
    m_febIdChanMap.addFEBIdVector(0, emBarrel);
    m_febIdChanMap.addFEBIdVector(1, emEndcap);
    m_febIdChanMap.addFEBIdVector(2, hec);
    m_febIdChanMap.addFEBIdVector(3, fcal);
 
//  unsigned int coolChannel;
//  for (unsigned int gain = 0; gain < nGains; ++gain) {
//      for (unsigned int i = 0; i < emBarrel.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(emBarrel[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for em barrel - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      for (unsigned int i = 0; i < emEndcap.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(emEndcap[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for em endcap - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      for (unsigned int i = 0; i < hec.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(hec[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for hec - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      for (unsigned int i = 0; i < fcal.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(fcal[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for fcal - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      }
    }
    else if (ExtendedSubDetGrouping == m_groupType) {
        log << MSG::DEBUG << "Extended Subdetector  grouping "<< endmsg;
 
    // Set up LArCondFEBIdChanMap for four groups: EM barrel, EM barrel PS ,EMEC EMEC PS, HEC, FCal 
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
    LArCondFEBIdChanMap::FEBIdVector emBarrel[2] = {};
    LArCondFEBIdChanMap::FEBIdVector emBarrelPS[2] = {};
    LArCondFEBIdChanMap::FEBIdVector emEndcap[2] = {};
    LArCondFEBIdChanMap::FEBIdVector emEndcapPS[2] = {};
    LArCondFEBIdChanMap::FEBIdVector hec[2] = {};
    LArCondFEBIdChanMap::FEBIdVector fcal[2] = {};
 
    for (; febIt != febEnd; ++febIt) {
            int iside = m_onlineHelper->pos_neg(*febIt);
            // Sanity check
            if(iside <0 || iside > 1) {
          log << MSG::ERROR << "Wrong side id: "<< iside <<" from: "  
          << MSG::hex << *febIt << MSG::dec << endmsg;
          return (StatusCode::FAILURE);
        }
            unsigned int febId = (*febIt).get_identifier32().get_compact();
        if (m_onlineHelper->isEMBPS(*febIt)) {
          emBarrelPS[iside].push_back(febId);
        }
        else if (m_onlineHelper->isEMECPS(*febIt)) {
          emEndcapPS[iside].push_back(febId);
        }
        else if (m_onlineHelper->isEMBchannel(*febIt)) {
          emBarrel[iside].push_back(febId);
        }
        else if (m_onlineHelper->isEMECchannel(*febIt)) {
          emEndcap[iside].push_back(febId);
        }
        else if (m_onlineHelper->isHECchannel(*febIt)) {
          hec[iside].push_back(febId);
        }
        else if (m_onlineHelper->isFCALchannel(*febIt)) {
          fcal[iside].push_back(febId);
        }
        else {
          log << MSG::DEBUG << "Uassociated FEB id: "
          << MSG::hex << (febId) << MSG::dec 
          << " isCalib " << m_onlineHelper->isCalibration(*febIt)
          << "  " << m_onlineHelper->show_to_string(*febIt)
          << endmsg;
        }
    }
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = 12;
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
        for (int iside=0; iside<2; ++iside) {
      m_febIdChanMap.addFEBIdVector(0+iside*6, emBarrel[iside]);
      m_febIdChanMap.addFEBIdVector(1+iside*6, emBarrelPS[iside]);
      m_febIdChanMap.addFEBIdVector(2+iside*6, emEndcap[iside]);
      m_febIdChanMap.addFEBIdVector(3+iside*6, emEndcapPS[iside]);
      m_febIdChanMap.addFEBIdVector(4+iside*6, hec[iside]);
      m_febIdChanMap.addFEBIdVector(5+iside*6, fcal[iside]);
        }
 
    }
    else if (FeedThroughGrouping == m_groupType) {
        log << MSG::DEBUG << "FeedThrough  grouping "<< endmsg;
 
        // Set up LArCondFEBIdChanMap for four groups: EM barrel, EMEM, HEC, FCal
        std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
        std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
        std::vector<LArCondFEBIdChanMap::FEBIdVector> ft(m_onlineHelper->feedthroughHashMax());
 
 
        for (; febIt != febEnd; ++febIt) {
            // Find the feedthru hash and add to vector
            HWIdentifier febId = (*febIt);
            int b_ec = m_onlineHelper->barrel_ec(febId);
            int p_n  = m_onlineHelper->pos_neg(febId);
            int f_t  = m_onlineHelper->feedthrough(febId);
            HWIdentifier ftid   = m_onlineHelper->feedthrough_Id(b_ec, p_n, f_t);
            IdentifierHash fthash = m_onlineHelper->feedthrough_Hash(ftid);
            if (fthash < ft.size()) {
                ft[fthash].push_back(febId.get_identifier32().get_compact());
            }
            else {
                log << MSG::ERROR << "Feedthru hash > channel map size: id, hash, size "
                    << MSG::hex << febId << MSG::dec << " "
                    << ftid << " " << ft.size()
                    << endmsg;
                return (StatusCode::FAILURE);
            }
        }
        // add for LArCondFEBIdChanMap
        unsigned int nChanPerGain = ft.size();
        unsigned int minGain      = 0;
        unsigned int nGains       = 3;
        m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
        for (unsigned int i = 0; i < ft.size(); ++i) {
            m_febIdChanMap.addFEBIdVector(i, ft[i]);
        }
    }
    else if (ExtendedFTGrouping == m_groupType) {
 
    log << MSG::DEBUG << "Extended FeedThrough  grouping (PS goes seperatly, EMEC in HEC as well)"<< endmsg;
 
    // Set up LArCondFEBIdChanMap for four groups: EM barrel, EMEM, HEC, FCal 
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
    //Vectors of groups
    //Standard Febs (one group per FT)
    std::vector<LArCondFEBIdChanMap::FEBIdVector> ft(m_onlineHelper->feedthroughHashMax());
    //Presampler FEBs (one group per FT)
    std::vector<LArCondFEBIdChanMap::FEBIdVector> ftPS(m_onlineHelper->feedthroughHashMax());
    //EMEC channel in special crate:
    std::vector<LArCondFEBIdChanMap::FEBIdVector> ftSpecial(8); //How many are there?
 
    for (; febIt != febEnd; ++febIt) {
        // Find the feedthru hash and add to vector
        HWIdentifier febId = (*febIt);
        int b_ec = m_onlineHelper->barrel_ec(febId);
        int p_n  = m_onlineHelper->pos_neg(febId);
        int f_t  = m_onlineHelper->feedthrough(febId);
        HWIdentifier ftid   = m_onlineHelper->feedthrough_Id(b_ec, p_n, f_t);
        IdentifierHash fthash = m_onlineHelper->feedthrough_Hash(ftid);
 
        //sanity check
        if (fthash >= ft.size()) {
          log << MSG::ERROR << "Feedthru hash > channel map size: id, hash, size " 
          << MSG::hex << febId << MSG::dec << " "
          << ftid << " " << ft.size() 
          << endmsg;
          return (StatusCode::FAILURE);
        }
 
        //Subdivide into specific cases:
        if (!m_onlineHelper->isEMECinHECchannel(febId)) { //this is taken care of further down
          if (m_onlineHelper->isPS(febId))
        ftPS[fthash].push_back(febId.get_identifier32().get_compact());  //PS goes in separate channels
          else
        ft[fthash].push_back(febId.get_identifier32().get_compact());
        }
    }
    //EMEC in HEC crate: Do 'by hand'
    //FTs: 3,10,16,22 Slots: 1,2
    //parameters: ec,pn,ft,slot
    ftSpecial[0].push_back(m_onlineHelper->feb_Id(1,0,3,1).get_identifier32().get_compact()); 
    ftSpecial[0].push_back(m_onlineHelper->feb_Id(1,0,3,2).get_identifier32().get_compact()); 
 
    ftSpecial[1].push_back(m_onlineHelper->feb_Id(1,1,3,1).get_identifier32().get_compact()); 
    ftSpecial[1].push_back(m_onlineHelper->feb_Id(1,1,3,2).get_identifier32().get_compact()); 
        
    ftSpecial[2].push_back(m_onlineHelper->feb_Id(1,0,10,1).get_identifier32().get_compact()); 
    ftSpecial[2].push_back(m_onlineHelper->feb_Id(1,0,10,2).get_identifier32().get_compact()); 
 
    ftSpecial[3].push_back(m_onlineHelper->feb_Id(1,1,10,1).get_identifier32().get_compact()); 
    ftSpecial[3].push_back(m_onlineHelper->feb_Id(1,1,10,2).get_identifier32().get_compact()); 
 
    ftSpecial[4].push_back(m_onlineHelper->feb_Id(1,0,16,1).get_identifier32().get_compact()); 
    ftSpecial[4].push_back(m_onlineHelper->feb_Id(1,0,16,2).get_identifier32().get_compact()); 
 
    ftSpecial[5].push_back(m_onlineHelper->feb_Id(1,1,16,1).get_identifier32().get_compact()); 
    ftSpecial[5].push_back(m_onlineHelper->feb_Id(1,1,16,2).get_identifier32().get_compact()); 
 
    ftSpecial[6].push_back(m_onlineHelper->feb_Id(1,0,22,1).get_identifier32().get_compact()); 
    ftSpecial[6].push_back(m_onlineHelper->feb_Id(1,0,22,2).get_identifier32().get_compact()); 
 
    ftSpecial[7].push_back(m_onlineHelper->feb_Id(1,1,22,1).get_identifier32().get_compact()); 
    ftSpecial[7].push_back(m_onlineHelper->feb_Id(1,1,22,2).get_identifier32().get_compact()); 
 
 
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = ft.size()+ftPS.size()+ftSpecial.size();
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    unsigned int iCoolChannel=0;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
    for (unsigned int i = 0; i < ft.size(); ++i) {
        m_febIdChanMap.addFEBIdVector(iCoolChannel++, ft[i]);
    }
    for (unsigned int i = 0; i < ftPS.size(); ++i) {
        m_febIdChanMap.addFEBIdVector(iCoolChannel++, ftPS[i]);
    }
    for (unsigned int i = 0; i < ftSpecial.size(); ++i) {
        m_febIdChanMap.addFEBIdVector(iCoolChannel++, ftSpecial[i]);
    }
    } else {
      log << MSG::ERROR << "Unknown COOL Channel grouping " << m_groupType << endmsg;
      return StatusCode::FAILURE;
    }
    // Resize the vector mapping the COOL channel to the
    // DataVector. 
    m_channelToMultChanCollIndex = std::vector<unsigned int>(m_febIdChanMap.totalChannels(), 9999);
 
    log << MSG::DEBUG << "Number of channels per gain " 
    << m_febIdChanMap.channelsPerGain()
    << endmsg;
 
    log << MSG::DEBUG << "Mininum gain value          "
    << m_febIdChanMap.minGain() 
    << endmsg;
    
    log << MSG::DEBUG << "Number of gain values       "
    << m_febIdChanMap.nGains()
    << endmsg;
 
    log << MSG::DEBUG << "Number of offset channels   "
    << m_febIdChanMap.nOffsetChannels() 
    << endmsg;
 
    log << MSG::DEBUG << "Total number of channels    "
    << m_febIdChanMap.totalChannels()
    << endmsg;
 
    return (StatusCode::SUCCESS);
    
}

◆ initialize()

StatusCode LArDAC2uAMC::initialize ( )

virtual

Initialization done after creation or read back - derived classes may augment the functionality.

Reimplemented from LArConditionsContainer< LArSingleFloatP >.

Definition at line 10 of file LArDAC2uAMC.cxx.

                                    {   
  return (CONTAINER::initialize()) ;
}

◆ initializeBase()

StatusCode LArConditionsContainerBase::initializeBase ( )

inherited

initialize

Definition at line 66 of file LArConditionsContainerBase.cxx.

{
    //Get LArOnlineID....
    ServiceHandle<StoreGateSvc> detStore("DetectorStore", "LArConditionsContainerBase");
    CHECK( detStore.isValid() );
 
    if (m_groupType == LArConditionsContainerBase::SuperCells) {
      //Dealing with supercells, need supercell identifier helper
      const LArOnline_SuperCellID* onlID = nullptr;
      CHECK( detStore->retrieve(onlID,"LArOnline_SuperCellID") );
      m_onlineHelper=onlID;//cast to base-class
 
      const CaloCell_SuperCell_ID* oflID = nullptr;
      CHECK( detStore->retrieve(oflID,"CaloCell_SuperCell_ID") );
      m_offlineHelper=oflID; //cast to base-class
    }
    else {
      //Regular readout
      const LArOnlineID* onlID = nullptr;
      CHECK( detStore->retrieve(onlID,"LArOnlineID") );
      m_onlineHelper=onlID;//cast to base-class
 
      const CaloCell_ID* oflID = nullptr;
      CHECK( detStore->retrieve(oflID,"CaloCell_ID") );
      m_offlineHelper=oflID; //cast to base-class
    }
 
    // initialize the grouping
    CHECK( initGrouping() );
 
    // Set initialized to true
    m_isInitialized = true;
 
    return (StatusCode::SUCCESS);
}

◆ insert() [1/5]

void DataVector< LArSingleFloatP, BASE >::insert	(	iterator	position,
		InputIterator	first,
		InputIterator	last )

inherited

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
first	The start of the range to put in the container.
last	The end of the range to put in the container.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

This overload is for the case where the iterator value type is convertible to T*.

◆ insert() [2/5]

void DataVector< LArSingleFloatP, BASE >::insert	(	iterator	position,
		InputIterator	first,
		InputIterator	last )

inherited

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
first	The start of the range to put in the container.
last	The end of the range to put in the container.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

This overload is for the case where the iterator value type is convertible to unique_ptr<T>.

◆ insert() [3/5]

void DataVector< LArSingleFloatP, BASE >::insert	(	iterator	position,
		std::initializer_list< value_type >	l )

inherited

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
l	An initializer list.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insert() [4/5]

iterator DataVector< LArSingleFloatP, BASE >::insert	(	iterator	position,
		std::unique_ptr< base_value_type >	pElem )

inherited

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container must be an owning container.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insert() [5/5]

iterator DataVector< LArSingleFloatP, BASE >::insert	(	iterator	position,
		value_type	pElem )

inherited

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insertCorrection()

StatusCode LArConditionsContainer< LArSingleFloatP >::insertCorrection	(	HWIdentifier	id,
		const LArSingleFloatP &	cond,
		unsigned int	gain,
		bool	corrChannel = true )

inherited

access to corrections -

Insert a new channel id / T pair. If new channel id is the same as an existing one, the new T replaces the old T

◆ insertMove()

void DataVector< LArSingleFloatP, BASE >::insertMove	(	iterator	position,
		DataVector &	other )

inherited

Insert the contents of another DataVector, with auxiliary data copied via move semantics.

Parameters

position	Iterator before which the new elements will be added.
other	The vector to add.

The ownership mode of this vector must be the same as other; otherwise, an exception will be thrown.

If both vectors are view vectors, then this is the same as insert (position, other.begin(), other.end()) .

Otherwise, the elements from other will be inserted into this vector. This vector will take ownership of the elements, and the ownership mode of other will be changed to VIEW_ELEMENTS. Auxiliary data for these elements will be transferred, using move semantics if possible. (Thus, the auxiliary store for other may be modified and must not be locked.) Finally, the auxiliary store pointer for other will be cleared (but the store itself will not be deleted since it's not owned by the vector).

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ iov_begin()

iov_const_iterator LArConditionsContainer< LArSingleFloatP >::iov_begin ( ) const

inherited

Access to IOVs via iterators - from MultChanCollection.

◆ iov_end()

iov_const_iterator LArConditionsContainer< LArSingleFloatP >::iov_end ( ) const

inherited

◆ iov_size()

iov_size_type LArConditionsContainer< LArSingleFloatP >::iov_size ( ) const

inherited

number of IOVs - from MultChanCollection

◆ iter_swap()

void DataVector< LArSingleFloatP, BASE >::iter_swap	(	iterator	a,
		iterator	b )

staticinherited

Swap the referents of two DataVector iterators.

Parameters

a	The first iterator for the swap.
b	The second iterator for the swap.

◆ max_size()

size_type DataVector< LArSingleFloatP, BASE >::max_size ( ) const

noexceptinherited

Returns the size() of the largest possible collection.

◆ merge()

bool LArConditionsContainer< LArSingleFloatP >::merge ( const LArConditionsContainer< LArSingleFloatP > & other )

inherited

◆ minGain()

unsigned int LArConditionsContainer< LArSingleFloatP >::minGain ( ) const

inherited

Mininum gain value.

◆ minRange()

IOVRange CondMultChanCollection< LArSingleFloatP >::minRange ( ) const

inlineinherited

Current minimal IOVRange.

Definition at line 83 of file CondMultChanCollection.h.

{
    return (m_impl.minRange());
}

◆ nGains()

unsigned int LArConditionsContainer< LArSingleFloatP >::nGains ( ) const

inherited

Number of gain values.

◆ nGroups()

unsigned int LArConditionsContainer< LArSingleFloatP >::nGroups ( ) const

inherited

Number of groups - minimum is 2 (1 correction group, 1 FEB ID group)

◆ offlineHelper()

const CaloCell_Base_ID * LArConditionsContainerBase::offlineHelper ( ) const

inherited

provide access to offline id helper

Definition at line 80 of file LArConditionsContainerBase.cxx.

{
    return (m_offlineHelper);
}

◆ onlineHelper()

const LArOnlineID_Base * LArConditionsContainerBase::onlineHelper ( ) const

inherited

provide access to online id helper

Definition at line 77 of file LArConditionsContainerBase.cxx.

{
    return (m_onlineHelper);
}

◆ operator[]() [1/2]

ElementProxy DataVector< LArSingleFloatP, BASE >::operator[] ( size_type n )

inherited

Access an element, as an lvalue.

Parameters

n	Array index to access.

Returns: Proxy to the element at n.

No bounds checking is done. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ operator[]() [2/2]

const LArSingleFloatP * DataVector< LArSingleFloatP, BASE >::operator[] ( size_type n ) const

inherited

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

No bounds checking is done. Note that we return a const T* rather than a reference.

◆ ownPolicy()

SG::OwnershipPolicy DataVector< LArSingleFloatP, BASE >::ownPolicy ( ) const

inherited

Return the ownership policy setting for this container.

◆ pop_back() [1/2]

void DataVector< LArSingleFloatP, BASE >::pop_back ( )

inherited

Remove the last element from the collection.

If the container owns its elements, then the removed element will be deleted.

◆ pop_back() [2/2]

void DataVector< LArSingleFloatP, BASE >::pop_back ( )

inherited

◆ push_back() [1/2]

value_type DataVector< LArSingleFloatP, BASE >::push_back ( std::unique_ptr< base_value_type > pElem )

inherited

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container must be an owning container.

Note: this method may only be called using the most derived DataVector in the hierarchy.

Returns the pushed pointer.

◆ push_back() [2/2]

value_type DataVector< LArSingleFloatP, BASE >::push_back ( value_type pElem )

inherited

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

Returns the pushed pointer.

◆ push_new()

size_type DataVector< LArSingleFloatP, BASE >::push_new	(	size_type	n,
		F	alloc )

inherited

Create and add a number of new elements to the end of the container.

Parameters

n	The number of new elements to add.
alloc	Functional to call to allocate a new element to push. Should be callable like `T* = alloc();` For example: dv.push_new (n, [](){ return new Foo; }); Foo Definition FooBar.h:9 It may also be useful to allocate from a `DataPool`.

Note: this method may only be called using the most derived DataVector in the hierarchy.

Returns the original size of the vector.

◆ rbegin() [1/2]

const_reverse_iterator DataVector< LArSingleFloatP, BASE >::rbegin ( ) const

noexceptinherited

Return a const_reverse_iterator pointing past the end of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ rbegin() [2/2]

reverse_iterator DataVector< LArSingleFloatP, BASE >::rbegin ( )

noexceptinherited

Return a reverse_iterator pointing past the end of the collection.

Returns: A reverse_iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ removeConditions()

void LArConditionsContainer< LArSingleFloatP >::removeConditions ( )

inherited

Remove conditions leaving the corrections - may be needed to only write out the corrections when both are present.

◆ removeConditionsChannel()

void LArConditionsContainer< LArSingleFloatP >::removeConditionsChannel ( unsigned int coolChannel )

inherited

Remove the conditions for a specific cool channel - e.g.

in order not to write it out

◆ rend() [1/2]

const_reverse_iterator DataVector< LArSingleFloatP, BASE >::rend ( ) const

noexceptinherited

Return a const_reverse_iterator pointing at the beginning of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ rend() [2/2]

reverse_iterator DataVector< LArSingleFloatP, BASE >::rend ( )

noexceptinherited

Return a reverse_iterator pointing at the beginning of the collection.

Returns: A reverse_iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ reserve()

void DataVector< LArSingleFloatP, BASE >::reserve ( size_type n )

inherited

Attempt to preallocate enough memory for a specified number of elements.

Parameters

n	Number of elements required.

◆ resetChannelNumbers()

void CondMultChanCollection< LArSingleFloatP >::resetChannelNumbers ( )

inlineinherited

Reset channel numbers - needed to allow sorting.

Definition at line 103 of file CondMultChanCollection.h.

{
    m_impl.resetChannelNumbers();
}

◆ resize() [1/2]

void DataVector< LArSingleFloatP, BASE >::resize ( size_type sz )

inherited

Resizes the collection to the specified number of elements.

Parameters

sz	The new size of the collection.

Note that this function differs from the standard in that it does not allow specifying the value of any inserted elements. They will always be 0.

If the container is shrunk, elements will be deleted as with erase().

◆ resize() [2/2]

void DataVector< LArSingleFloatP, BASE >::resize ( size_type sz )

inherited

◆ resortAux()

void DataVector< LArSingleFloatP, BASE >::resortAux	(	iterator	beg,
		iterator	end )

inherited

Reset indices / reorder aux data after elements have been permuted.

Parameters

beg	Start of the range of elements to process.
end	End of the range of elements to process.

Call this after some operation that has permuted the elements in the container (such as sort). The index information in the elements will be used to permute all auxiliary data in the same way. Finally, all the indices will be reset in the correct order.

◆ set()

void LArDAC2uAComplete::set	(	const HWIdentifier &	CellID,
		const float	vDAC2uA )

inherited

Definition at line 13 of file LArDAC2uAComplete.cxx.

                                                                         {
    this->setPdata(chid,DAC2uA); 
}

◆ setGroupingType() [1/2]

StatusCode LArConditionsContainerBase::setGroupingType	(	const std::string &	groupingStr,
		MsgStream &	logStr )

inherited

allow group type to be set externally based on a string returns an FAILURE and a message to logStr if unknown string is supplied

Definition at line 74 of file LArConditionsContainerBase.cxx.

{
 // Set grouping type - default is SubDet
  if (groupingStr == "Single") 
    {setGroupingType(LArConditionsContainerBase:: SingleGroup);
     return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "SubDetector") 
    {setGroupingType(LArConditionsContainerBase:: SubDetectorGrouping);
     return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "ExtendedSubDetector") 
    {setGroupingType(LArConditionsContainerBase::ExtendedSubDetGrouping);
    return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "FeedThrough") 
    {setGroupingType(LArConditionsContainerBase:: FeedThroughGrouping);
     return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "ExtendedFeedThrough") {
    setGroupingType(LArConditionsContainerBase:: ExtendedFTGrouping);
    return StatusCode::SUCCESS;
  }
  else if (groupingStr == "SuperCells") {
    setGroupingType(LArConditionsContainerBase::SuperCells);
    return StatusCode::SUCCESS;
  }
 
  logStr << MSG::ERROR << "Unknown COOL Channel Grouping '"<< groupingStr <<"'.  Allowed values are:" << endmsg;
  logStr << MSG::ERROR << "'Single','SubDetector', 'ExtendedSubDetector','FeedThrough','ExtendedFeedThrough'" << endmsg;
  return StatusCode::FAILURE;
}

◆ setGroupingType() [2/2]

void LArConditionsContainerBase::setGroupingType ( GroupingType type )

inherited

allow group type to be set externally - need to (re)initialize after setting grouping type

Definition at line 70 of file LArConditionsContainerBase.cxx.

{
    m_groupType = type;
}

◆ setMostDerived()

virtual void DataVector< LArSingleFloatP, BASE >::setMostDerived ( )

overrideprotectedvirtualinherited

Set m_isMostDerived for this instance and clear it for all bases.

Called from testInsert if the test fails. The flag may not have been set if this container was made via copy construction, so set it appropriately now so we can test again.

◆ setPdata()

void LArConditionsContainer< LArSingleFloatP >::setPdata	(	const HWIdentifier	id,
		const LArSingleFloatP &	payload,
		unsigned int	gain = 0 )

inherited

put payload in persistent data

◆ shift()

void DataVector< LArSingleFloatP, BASE >::shift	(	size_t	pos,
		ptrdiff_t	offs )

privateinherited

Shift the auxiliary elements of the container.

Parameters

pos	The starting index for the shift.
offs	The (signed) amount of the shift.

The elements in the container should have already been shifted; this operation will then adjust the element indices and also shift the elements in the vectors for all aux data items. offs may be either positive or negative.

If offs is positive, then the container is growing. The container size should be increased by offs, the element at pos moved to pos + offs, and similarly for following elements. The elements between pos and pos + offs should be default-initialized.

If offs is negative, then the container is shrinking. The element at pos should be moved to pos + offs, and similarly for following elements. The container should then be shrunk by -offs elements (running destructors as appropriate).

◆ shrink_to_fit()

void DataVector< LArSingleFloatP, BASE >::shrink_to_fit ( )

inherited

◆ size()

size_type DataVector< LArSingleFloatP, BASE >::size ( ) const

noexceptinherited

Returns the number of elements in the collection.

Could in principle be inherited from the base class, but redeclared in the derived class to avoid root6 bugs.

◆ sort() [1/2]

void DataVector< LArSingleFloatP, BASE >::sort ( )

inherited

Sort the container.

This just sorts by pointer value, so it's probably not very useful.

◆ sort() [2/2]

void DataVector< LArSingleFloatP, BASE >::sort ( COMPARE comp )

inherited

Sort the container with a user-specified comparison operator.

Parameters

comp	Functional to compare two values.

◆ sortSubsets()

void LArConditionsContainer< LArSingleFloatP >::sortSubsets ( )

privateinherited

Sort subsets by channel number.

◆ stdcont()

const PtrVector & DataVector< LArSingleFloatP, BASE >::stdcont ( ) const

inherited

Return the underlying std::vector of the container.

Returns: Reference to the std::vector actually holding the collection.

Note that DataVector<T>::stdcont does not necessarily return a std::vector<T*> if DataVector inheritance is being used.

◆ swap()

void DataVector< LArSingleFloatP, BASE >::swap ( DataVector & rhs )

inherited

Swap this collection with another.

Parameters

rhs	The collection with which to swap.

Ownership is swapped along with the collection content.

Note: this method may only be called using the most-derived DataVector in the hierarchy. The rhs must also be referenced using the most-derived DataVector.

◆ swapElement() [1/4]

void DataVector< LArSingleFloatP, BASE >::swapElement	(	iterator	pos,
		std::unique_ptr< base_value_type >	newElem,
		std::unique_ptr< base_value_type > &	oldElem )

inherited

Swap one element out of the container.

Parameters

pos	The element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element pos of the collection (no bounds checking). Then element index is set to newElem.

The collection must own its elements to use its interface. The collection will take ownership of newElem and will return ownership of oldElem.

Note: this method may only be called using the most derived DataList in the hierarchy.

◆ swapElement() [2/4]

void DataVector< LArSingleFloatP, BASE >::swapElement	(	iterator	pos,
		value_type	newElem,
		reference	oldElem )

inherited

Swap one element out of the container.

Parameters

pos	The element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element pos of the collection (no bounds checking). Then element index is set to newElem. If the collection owns its elements, then it will take ownership of newElem and release (without deleting) the element returned through oldElem.

Note: this method may only be called using the most derived DataList in the hierarchy.

◆ swapElement() [3/4]

void DataVector< LArSingleFloatP, BASE >::swapElement	(	size_type	index,
		std::unique_ptr< base_value_type >	newElem,
		std::unique_ptr< base_value_type > &	oldElem )

inherited

Swap one element out of the container.

Parameters

index	Index of the element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element index of the collection (no bounds checking). Then element index is set to newElem.

The collection must own its elements to use its interface. The collection will take ownership of newElem and will return ownership of oldElem.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ swapElement() [4/4]

void DataVector< LArSingleFloatP, BASE >::swapElement	(	size_type	index,
		value_type	newElem,
		reference	oldElem )

inherited

Swap one element out of the container.

Parameters

index	Index of the element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element index of the collection (no bounds checking). Then element index is set to newElem. If the collection owns its elements, then it will take ownership of newElem and release (without deleting) the element returned through oldElem.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ testInsert()

void DataVector< LArSingleFloatP, BASE >::testInsert ( const char * op )

inherited

Test if we can insert; raise an exception if not.

Parameters

op	Description of the attempted operation.

In order to maintain type-safety, we can only allow insertions using the most-derived instance of DataVector. This checks this by testing the m_isMostDerived, which is set by the constructors to true only for the most-derived instance. If the test fails, we call to potentially out-of-line code to continue.

◆ testInsertOol()

void DataVector< LArSingleFloatP, BASE >::testInsertOol ( const char * op )

inherited

Test if we can insert; raise an exception if not.

Parameters

op	Description of the attempted operation.

This continues the test of testInsert. There is one case where m_isMostDerived may not be set correctly. If this container was made via copy construction, then all the m_isMostDerived flags will be false. So we call setMostDerived to set the flags correctly and test again. If the test fails again, then we raise an exception.

◆ totalNumberOfConditions()

unsigned int LArConditionsContainer< LArSingleFloatP >::totalNumberOfConditions ( ) const

inherited

Statistics: total number of conditions.

◆ totalNumberOfCorrections()

unsigned int LArConditionsContainer< LArSingleFloatP >::totalNumberOfCorrections ( ) const

inherited

Statistics: total number of corrections.

◆ undoCorrBegin()

ConstCorrectionIt LArConditionsContainer< LArSingleFloatP >::undoCorrBegin ( unsigned int gain ) const

inherited

get iterator over the Undo-Vector for a certain gain

◆ undoCorrections()

StatusCode LArConditionsContainer< LArSingleFloatP >::undoCorrections ( )

inherited

undo corrections that have been already applied

◆ undoCorrEnd()

ConstCorrectionIt LArConditionsContainer< LArSingleFloatP >::undoCorrEnd ( unsigned int gain ) const

inherited

◆ updateConditionsMap()

StatusCode LArConditionsContainer< LArSingleFloatP >::updateConditionsMap	(	FebId	id,
		unsigned int	gain,
		ConditionsMap &	conditionsMap )

privateinherited

Update the ConditionsMap for a new FEB ID.

Member Data Documentation

◆ dummy

float LArDAC2uAMC::dummy =LArElecCalib::ERRORCODE

staticconstexpr

Definition at line 34 of file LArDAC2uAMC.h.

◆ has_virtual

const bool DataVector< LArSingleFloatP, BASE >::has_virtual

staticinherited

This is true for any DataVector class if we need to use virtual derivation to get to the base DataVector class.

Definition at line 802 of file DataVector.h.

◆ m_cached

GainMap LArConditionsContainer< LArSingleFloatP >::m_cached

protectedinherited

Map indexed by gain providing pointers into the data in the CondMultChanCollection.

Definition at line 286 of file LArConditionsContainer.h.

◆ m_channelToMultChanCollIndex

std::vector<unsigned int> LArConditionsContainerBase::m_channelToMultChanCollIndex

protectedinherited

Definition at line 114 of file LArConditionsContainerBase.h.

◆ m_correctionsApplied

bool LArConditionsContainer< LArSingleFloatP >::m_correctionsApplied

privateinherited

Definition at line 327 of file LArConditionsContainer.h.

◆ m_correctionsUndo

CorrectionVectors LArConditionsContainer< LArSingleFloatP >::m_correctionsUndo

privateinherited

Definition at line 326 of file LArConditionsContainer.h.

◆ m_dummyCorrIt

ConstCorrectionIt LArConditionsContainer< LArSingleFloatP >::m_dummyCorrIt

privateinherited

Dummy iterator (returned if requested for invalid gain)

Definition at line 291 of file LArConditionsContainer.h.

◆ m_emptyCorrectionVec

CorrectionVector LArConditionsContainer< LArSingleFloatP >::m_emptyCorrectionVec

privateinherited

Definition at line 328 of file LArConditionsContainer.h.

◆ m_febIdChanMap

LArCondFEBIdChanMap LArConditionsContainerBase::m_febIdChanMap

protectedinherited

Definition at line 108 of file LArConditionsContainerBase.h.

◆ m_groupType

GroupingType LArConditionsContainerBase::m_groupType

protectedinherited

Definition at line 107 of file LArConditionsContainerBase.h.

◆ m_impl

CondMultChanCollImpl CondMultChanCollection< LArSingleFloatP >::m_impl

privateinherited

Definition at line 110 of file CondMultChanCollection.h.

◆ m_isInitialized

bool LArConditionsContainerBase::m_isInitialized

protectedinherited

Definition at line 115 of file LArConditionsContainerBase.h.

◆ m_isMostDerived

SG::IsMostDerivedFlag DataVector< LArSingleFloatP, BASE >::m_isMostDerived

privateinherited

This flag is true if this DV instance is the most-derived one.

We set this to true in the top-level constructor; the constructor then calls clearMostDerived on the base classes.

Definition at line 2059 of file DataVector.h.

◆ m_offlineHelper

const CaloCell_Base_ID* LArConditionsContainerBase::m_offlineHelper

protectedinherited

Definition at line 110 of file LArConditionsContainerBase.h.

◆ m_onlineHelper

const LArOnlineID_Base* LArConditionsContainerBase::m_onlineHelper

protectedinherited

Definition at line 109 of file LArConditionsContainerBase.h.

◆ must_own

bool DataVector< LArSingleFloatP, BASE >::must_own

staticconstexprinherited

If true, then this type must own its contents.

Definition at line 860 of file DataVector.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Non-standard operations.

Swap and sort.

Internal operations.

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ base_data_vector

◆ base_value_type

◆ BaseContainer

◆ chan_const_iterator

◆ chan_iterator

◆ chan_size_type

◆ ChannelVector

◆ ChannelVectorIterator

◆ ChanNum

◆ ChanVec

◆ ConditionsMap

◆ ConditionsMapIterator

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ const_value_type

◆ ConstConditionsMapIterator

◆ ConstCorrectionIt

◆ ConstCorrectionVecIt

◆ ConstGainMapIterator

◆ ConstPointer

◆ ConstReference

◆ CONTAINER

◆ CorrectionPair

◆ CorrectionVector

◆ CorrectionVectors

◆ DataVector_BASE

◆ Deleter

◆ difference_type

◆ DVL_BASE

◆ ElementProxy

◆ FebId

◆ FEBIdVector

◆ FebPairReference

◆ GainMap

◆ GainMapIterator

◆ GainPair

◆ iov_const_iterator

◆ iov_iterator

◆ iov_size_type

◆ IOVVec

◆ iterator

◆ LArCondObj

◆ MultChanCollection

◆ Pointer

◆ pointer

◆ PtrVector

◆ Reference

◆ reference

◆ reverse_iterator

◆ self

◆ size_type

◆ Subset

◆ SubsetDV

◆ Traits

◆ TVector

◆ TVectorIterator

◆ TVectorMap

◆ TVectorMapIterator

◆ unique_type

◆ value_type

Member Enumeration Documentation

◆ anonymous enum

◆ GroupingType