Container of L1CaloHVCorrections objects, inherit from the abstract base class AbstractL1CaloConditionContainer. More...

#include <L1CaloHVCorrectionsContainer.h>

Inheritance diagram for L1CaloHVCorrectionsContainer:

Collaboration diagram for L1CaloHVCorrectionsContainer:

Public Types
enum	eCoolFolders { eHVCorrections }

typedef std::map< unsigned int, L1CaloHVCorrections >	L1CaloHVCorrectionsMap

typedef L1CaloHVCorrectionsMap::const_iterator	const_iterator

Public Member Functions
	L1CaloHVCorrectionsContainer ()

	L1CaloHVCorrectionsContainer (const std::map< L1CaloHVCorrectionsContainer::eCoolFolders, std::string > &folderKeysMap)

virtual	~L1CaloHVCorrectionsContainer ()

virtual DataObject *	makePersistent () const

virtual void	makeTransient (const std::map< std::string, const CondAttrListCollection * > &condAttrListCollectionMap)

const L1CaloHVCorrections *	hvCorrections (unsigned int channelId) const

const L1CaloHVCorrections *	hvCorrections (const L1CaloRxCoolChannelId &channelId) const

void	addHVCorrections (unsigned int channelId, L1CaloHVCorrections &&hvCorrections)

void	addHVCorrections (const L1CaloRxCoolChannelId &channelId, L1CaloHVCorrections &&hvCorrections)

const_iterator	begin () const

const_iterator	end () const

virtual std::vector< std::string >	coolInputKeys () const

virtual std::string	coolOutputKey () const

virtual void	clear ()

virtual void	makeTransient (const std::map< std::string, const CondAttrListCollection * > &condAttrListCollectionMap)

virtual void	makeTransient (const std::map< std::string, const AthenaAttributeList * > &condAttributeList)

virtual void	makeTransient (const std::map< std::string, const AthenaAttributeList * > &condAttributeList)

std::string	specificationName (int specId) const

std::string	specificationType (int specId) const

void	addSpecification (int specId, const std::string &specName, const std::string &specType)

coral::AttributeListSpecification *	createAttributeListSpecification () const

virtual std::string	conditionType () const

Private Types
enum	eAttrSpecification { eRxMean, eAffectedCells1, eAffectedCells2, eAffectedCells3, eAffectedCells4, eLayerMean1, eLayerMean2, eLayerMean3, eLayerMean4 }

typedef std::map< int, std::string >	AttrSpecificationMap

Private Member Functions
std::string	coolFolderKey (L1CaloHVCorrectionsContainer::eCoolFolders efolder) const

Private Attributes
L1CaloHVCorrectionsMap	m_mHVCorrectionsMap

std::map< L1CaloHVCorrectionsContainer::eCoolFolders, std::string >	m_mCoolFoldersKeysMap

AttrSpecificationMap	m_attrSpecificationNameMap

AttrSpecificationMap	m_attrSpecificationTypeMap

std::string	m_strConditionType

Detailed Description

Container of L1CaloHVCorrections objects, inherit from the abstract base class AbstractL1CaloConditionContainer.

Implement the IL1CaloPersistenceCapable interface.

Author: Peter Faulkner

Definition at line 28 of file L1CaloHVCorrectionsContainer.h.

Member Typedef Documentation

◆ AttrSpecificationMap

typedef std::map<int, std::string> AbstractL1CaloPersistentCondition::AttrSpecificationMap

privateinherited

Definition at line 50 of file AbstractL1CaloPersistentCondition.h.

◆ const_iterator

typedef L1CaloHVCorrectionsMap::const_iterator L1CaloHVCorrectionsContainer::const_iterator

Definition at line 38 of file L1CaloHVCorrectionsContainer.h.

◆ L1CaloHVCorrectionsMap

typedef std::map<unsigned int, L1CaloHVCorrections> L1CaloHVCorrectionsContainer::L1CaloHVCorrectionsMap

Definition at line 37 of file L1CaloHVCorrectionsContainer.h.

Member Enumeration Documentation

◆ eAttrSpecification

enum L1CaloHVCorrectionsContainer::eAttrSpecification

private

Enumerator
eRxMean
eAffectedCells1
eAffectedCells2
eAffectedCells3
eAffectedCells4
eLayerMean1
eLayerMean2
eLayerMean3
eLayerMean4

Definition at line 32 of file L1CaloHVCorrectionsContainer.h.

32 { eRxMean, eAffectedCells1, eAffectedCells2, eAffectedCells3, eAffectedCells4,

33 eLayerMean1, eLayerMean2, eLayerMean3, eLayerMean4 };

◆ eCoolFolders

enum L1CaloHVCorrectionsContainer::eCoolFolders

Enumerator
eHVCorrections

Definition at line 40 of file L1CaloHVCorrectionsContainer.h.

40 { eHVCorrections };

Constructor & Destructor Documentation

◆ L1CaloHVCorrectionsContainer() [1/2]

L1CaloHVCorrectionsContainer::L1CaloHVCorrectionsContainer ( )

Definition at line 14 of file L1CaloHVCorrectionsContainer.cxx.

                                                           :AbstractL1CaloPersistentCondition("CondAttrListCollection") {
     // Define DB rows names and types in order to construct the AttributeListSpecification object
     this->addSpecification(eRxMean, std::string("RxMean"), std::string("float"));
     this->addSpecification(eAffectedCells1, std::string("AffectedCells1"), std::string("unsigned char"));
     this->addSpecification(eAffectedCells2, std::string("AffectedCells2"), std::string("unsigned char"));
     this->addSpecification(eAffectedCells3, std::string("AffectedCells3"), std::string("unsigned char"));
     this->addSpecification(eAffectedCells4, std::string("AffectedCells4"), std::string("unsigned char"));
     this->addSpecification(eLayerMean1, std::string("LayerMean1"), std::string("float"));
     this->addSpecification(eLayerMean2, std::string("LayerMean2"), std::string("float"));
     this->addSpecification(eLayerMean3, std::string("LayerMean3"), std::string("float"));
     this->addSpecification(eLayerMean4, std::string("LayerMean4"), std::string("float"));
  
     m_mCoolFoldersKeysMap[L1CaloHVCorrectionsContainer::eHVCorrections] = std::string("/TRIGGER/L1Calo/V1/Results/HVCorrections");
 }

◆ L1CaloHVCorrectionsContainer() [2/2]

L1CaloHVCorrectionsContainer::L1CaloHVCorrectionsContainer ( const std::map< L1CaloHVCorrectionsContainer::eCoolFolders, std::string > & folderKeysMap )

Definition at line 29 of file L1CaloHVCorrectionsContainer.cxx.

                                                                                                                                            : 
   AbstractL1CaloPersistentCondition("CondAttrListCollection"),
   m_mCoolFoldersKeysMap(folderKeysMap)
 {
     // Define DB rows names and types in order to construct the AttributeListSpecification object
     this->addSpecification(eRxMean, std::string("RxMean"), std::string("float"));
     this->addSpecification(eAffectedCells1, std::string("AffectedCells1"), std::string("unsigned char"));
     this->addSpecification(eAffectedCells2, std::string("AffectedCells2"), std::string("unsigned char"));
     this->addSpecification(eAffectedCells3, std::string("AffectedCells3"), std::string("unsigned char"));
     this->addSpecification(eAffectedCells4, std::string("AffectedCells4"), std::string("unsigned char"));
     this->addSpecification(eLayerMean1, std::string("LayerMean1"), std::string("float"));
     this->addSpecification(eLayerMean2, std::string("LayerMean2"), std::string("float"));
     this->addSpecification(eLayerMean3, std::string("LayerMean3"), std::string("float"));
     this->addSpecification(eLayerMean4, std::string("LayerMean4"), std::string("float"));
 }

◆ ~L1CaloHVCorrectionsContainer()

virtual L1CaloHVCorrectionsContainer::~L1CaloHVCorrectionsContainer ( )

inlinevirtual

Definition at line 44 of file L1CaloHVCorrectionsContainer.h.

44 {};

Member Function Documentation

◆ addHVCorrections() [1/2]

void L1CaloHVCorrectionsContainer::addHVCorrections	(	const L1CaloRxCoolChannelId &	channelId,
		L1CaloHVCorrections &&	hvCorrections
	)

Definition at line 179 of file L1CaloHVCorrectionsContainer.cxx.

                                                                                                                                {
     this->addHVCorrections(channelId.id(), std::move(hvCorrections));
 }

◆ addHVCorrections() [2/2]

void L1CaloHVCorrectionsContainer::addHVCorrections	(	unsigned int	channelId,
		L1CaloHVCorrections &&	hvCorrections
	)

Definition at line 175 of file L1CaloHVCorrectionsContainer.cxx.

                                                                                                                {
     m_mHVCorrectionsMap[channelId] = std::move(hvCorrections);
 }

◆ addSpecification()

void AbstractL1CaloPersistentCondition::addSpecification	(	int	specId,
		const std::string &	specName,
		const std::string &	specType
	)

inherited

Definition at line 26 of file AbstractL1CaloPersistentCondition.cxx.

                                                                                                                          {
     m_attrSpecificationNameMap[specId] = specName;
     m_attrSpecificationTypeMap[specId] = specType;
 }

◆ begin()

const_iterator L1CaloHVCorrectionsContainer::begin ( ) const

inline

Definition at line 59 of file L1CaloHVCorrectionsContainer.h.

59 { return m_mHVCorrectionsMap.begin(); };

◆ clear()

void L1CaloHVCorrectionsContainer::clear ( )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 183 of file L1CaloHVCorrectionsContainer.cxx.

                                          {
     m_mHVCorrectionsMap.clear();
 }

◆ conditionType()

virtual std::string AbstractL1CaloPersistentCondition::conditionType ( ) const

inlinevirtualinherited

Implements IL1CaloPersistenceCapable.

Definition at line 37 of file AbstractL1CaloPersistentCondition.h.

37 { return m_strConditionType; };

◆ coolFolderKey()

std::string L1CaloHVCorrectionsContainer::coolFolderKey ( L1CaloHVCorrectionsContainer::eCoolFolders efolder ) const

private

Definition at line 45 of file L1CaloHVCorrectionsContainer.cxx.

                                                                                                             {
  
     std::map<L1CaloHVCorrectionsContainer::eCoolFolders, std::string>::const_iterator it = m_mCoolFoldersKeysMap.find(efolder);
     if(it!=m_mCoolFoldersKeysMap.end()) {
         return it->second;
     } else {
         return std::string("");
     }
 }

◆ coolInputKeys()

std::vector< std::string > L1CaloHVCorrectionsContainer::coolInputKeys ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 55 of file L1CaloHVCorrectionsContainer.cxx.

                                                                        {
     std::vector<std::string> v;
     v.push_back(this->coolFolderKey(L1CaloHVCorrectionsContainer::eHVCorrections));
     return v;
 }

◆ coolOutputKey()

std::string L1CaloHVCorrectionsContainer::coolOutputKey ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 61 of file L1CaloHVCorrectionsContainer.cxx.

                                                             {
     return this->coolFolderKey(L1CaloHVCorrectionsContainer::eHVCorrections);
 }

◆ createAttributeListSpecification()

coral::AttributeListSpecification * AbstractL1CaloPersistentCondition::createAttributeListSpecification ( ) const

inherited

Definition at line 31 of file AbstractL1CaloPersistentCondition.cxx.

                                                                                                            {
  
     coral::AttributeListSpecification* attrSpecification =  new coral::AttributeListSpecification();
  
     AttrSpecificationMap::const_iterator it_name = m_attrSpecificationNameMap.begin();
     AttrSpecificationMap::const_iterator it_type = m_attrSpecificationTypeMap.begin();
  
     for(;it_name!=m_attrSpecificationNameMap.end();++it_name,++it_type) {
         attrSpecification->extend(it_name->second, it_type->second);
     }
     return attrSpecification;
 }

◆ end()

const_iterator L1CaloHVCorrectionsContainer::end ( ) const

inline

Definition at line 60 of file L1CaloHVCorrectionsContainer.h.

60 { return m_mHVCorrectionsMap.end(); };

◆ hvCorrections() [1/2]

const L1CaloHVCorrections * L1CaloHVCorrectionsContainer::hvCorrections ( const L1CaloRxCoolChannelId & channelId ) const

Definition at line 171 of file L1CaloHVCorrectionsContainer.cxx.

                                                                                                                    {
     return this->hvCorrections(channelId.id());
 }

◆ hvCorrections() [2/2]

const L1CaloHVCorrections * L1CaloHVCorrectionsContainer::hvCorrections ( unsigned int channelId ) const

Definition at line 165 of file L1CaloHVCorrectionsContainer.cxx.

                                                                                                    {
     L1CaloHVCorrectionsMap::const_iterator pos = m_mHVCorrectionsMap.find(channelId);
     if(pos==m_mHVCorrectionsMap.end()) return 0;
     else return &(pos->second);
 }

◆ makePersistent()

DataObject * L1CaloHVCorrectionsContainer::makePersistent ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 65 of file L1CaloHVCorrectionsContainer.cxx.

                                                                {
     if(m_mHVCorrectionsMap.size()==0) return 0;
  
     // Create AttributeListSpecification according to the attributes to be recorded
     // this is required to create the AttributeList objs
     coral::AttributeListSpecification* attrSpecification = this->createAttributeListSpecification();
     if(!attrSpecification->size()) return NULL;
  
     CondAttrListCollection* attrListCollection = new CondAttrListCollection(true);
  
     L1CaloHVCorrectionsMap::const_iterator pos = m_mHVCorrectionsMap.begin();
     L1CaloHVCorrectionsMap::const_iterator end = m_mHVCorrectionsMap.end();
     for(; pos!=end; ++pos) {
         const unsigned int channelId = pos->first;
         const L1CaloHVCorrections& p = pos->second;
     const std::vector<int>& affectedCells(p.affectedCells());
     const std::vector<float>& layerMeans(p.layerMeans());
     const unsigned char nlayers = affectedCells.size();
     const unsigned char affectedCells1 = (nlayers > 0) ? affectedCells[0] : 0;
     const unsigned char affectedCells2 = (nlayers > 1) ? affectedCells[1] : 0;
     const unsigned char affectedCells3 = (nlayers > 2) ? affectedCells[2] : 0;
     const unsigned char affectedCells4 = (nlayers > 3) ? affectedCells[3] : 0;
     const float         layerMean1     = (nlayers > 0) ? layerMeans[0] : 0.;
     const float         layerMean2     = (nlayers > 1) ? layerMeans[1] : 0.;
     const float         layerMean3     = (nlayers > 2) ? layerMeans[2] : 0.;
     const float         layerMean4     = (nlayers > 3) ? layerMeans[3] : 0.;
  
         AthenaAttributeList attrList(*attrSpecification);
  
         // Set value of each row for the current channel
         attrList[ this->specificationName(eRxMean) ].setValue(p.rxMean());
         attrList[ this->specificationName(eAffectedCells1) ].setValue(affectedCells1);
         attrList[ this->specificationName(eAffectedCells2) ].setValue(affectedCells2);
         attrList[ this->specificationName(eAffectedCells3) ].setValue(affectedCells3);
         attrList[ this->specificationName(eAffectedCells4) ].setValue(affectedCells4);
         attrList[ this->specificationName(eLayerMean1) ].setValue(layerMean1);
         attrList[ this->specificationName(eLayerMean2) ].setValue(layerMean2);
         attrList[ this->specificationName(eLayerMean3) ].setValue(layerMean3);
         attrList[ this->specificationName(eLayerMean4) ].setValue(layerMean4);
  
         attrListCollection->add(channelId, attrList);
     }
  
     return (DataObject*) attrListCollection;
 }

◆ makeTransient() [1/4]

void AbstractL1CaloPersistentCondition::makeTransient ( const std::map< std::string, const AthenaAttributeList * > & condAttributeList )

virtualinherited

Implements IL1CaloPersistenceCapable.

Definition at line 21 of file AbstractL1CaloPersistentCondition.cxx.

                                                                                                             {
     std::cout << "ERROR - The makeTransient(const map<std::string, const AthenaAttributeList*>) method you are calling is not implemented by the current class !" << std::endl;
     return;
 }

◆ makeTransient() [2/4]

void AbstractL1CaloPersistentCondition::makeTransient

Definition at line 30 of file AbstractL1CaloPersistentCondition.cxx.

                                                                                                             {
     std::cout << "ERROR - The makeTransient(const map<std::string, const AthenaAttributeList*>) method you are calling is not implemented by the current class !" << std::endl;
     return;
 }

◆ makeTransient() [3/4]

void AbstractL1CaloPersistentCondition::makeTransient

Definition at line 29 of file AbstractL1CaloPersistentCondition.cxx.

                                                                                                                {
     std::cout << "ERROR - The makeTransient(const map<std::string, const CondAttrListCollection*>) method you are calling is not implemented by the current class !" << std::endl;
     return;
 }

◆ makeTransient() [4/4]

void L1CaloHVCorrectionsContainer::makeTransient ( const std::map< std::string, const CondAttrListCollection * > & condAttrListCollectionMap )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 111 of file L1CaloHVCorrectionsContainer.cxx.

                                                                                                                                   {
  
     this->clear();
  
     std::map<std::string, const CondAttrListCollection*>::const_iterator
       it_map(condAttrListCollectionMap.find(this->coolFolderKey(L1CaloHVCorrectionsContainer::eHVCorrections)));
  
     if(it_map!=condAttrListCollectionMap.end()) {
  
         const CondAttrListCollection* attrListCollection = it_map->second;
  
         //loop over CondAttrListCollection
         CondAttrListCollection::const_iterator pos = attrListCollection->begin();
         CondAttrListCollection::const_iterator end = attrListCollection->end();
         for(; pos!= end; ++pos) {
  
             const coral::AttributeList& attrList = pos->second;
  
             // Get value of each row for the current channel
             CondAttrListCollection::ChanNum chanNum(pos->first);
  
             float rxMean = attrList[ this->specificationName(eRxMean) ].data<float>();
         std::vector<int> affectedCells;
         std::vector<float> layerMeans;
         float layerMean1 = attrList[ this->specificationName(eLayerMean1) ].data<float>();
         if (layerMean1 >= 1.) {
           layerMeans.push_back(layerMean1);
           affectedCells.push_back((int)attrList[ this->specificationName(eAffectedCells1) ].data<unsigned char>());
           float layerMean2 = attrList[ this->specificationName(eLayerMean2) ].data<float>();
           if (layerMean2 >= 1.) {
             layerMeans.push_back(layerMean2);
             affectedCells.push_back((int)attrList[ this->specificationName(eAffectedCells2) ].data<unsigned char>());
             float layerMean3 = attrList[ this->specificationName(eLayerMean3) ].data<float>();
             if (layerMean3 >= 1.) {
               layerMeans.push_back(layerMean3);
               affectedCells.push_back((int)attrList[ this->specificationName(eAffectedCells3) ].data<unsigned char>());
               float layerMean4 = attrList[ this->specificationName(eLayerMean4) ].data<float>();
               if (layerMean4 >= 1.) {
                 layerMeans.push_back(layerMean4);
                 affectedCells.push_back((int)attrList[ this->specificationName(eAffectedCells4) ].data<unsigned char>());
                   }
                 }
               }
             }
  
             L1CaloHVCorrections l1CaloHVCorrections(chanNum, rxMean, std::move(affectedCells), std::move(layerMeans));
             m_mHVCorrectionsMap[chanNum] = std::move(l1CaloHVCorrections);
         }
     } else {
         std::cout << "L1CaloHVCorrectionsContainer : Could not find requested CondAttrListCollection "
                   << this->coolFolderKey(L1CaloHVCorrectionsContainer::eHVCorrections) << std::endl;
     }
 }

◆ specificationName()

std::string AbstractL1CaloPersistentCondition::specificationName ( int specId ) const

inherited

Definition at line 44 of file AbstractL1CaloPersistentCondition.cxx.

                                                                                {
     return m_attrSpecificationNameMap.find(specId)->second;
 }

◆ specificationType()

std::string AbstractL1CaloPersistentCondition::specificationType ( int specId ) const

inherited

Definition at line 48 of file AbstractL1CaloPersistentCondition.cxx.

                                                                                {
     return m_attrSpecificationTypeMap.find(specId)->second;
 }

Member Data Documentation

◆ m_attrSpecificationNameMap

AttrSpecificationMap AbstractL1CaloPersistentCondition::m_attrSpecificationNameMap

privateinherited

Definition at line 51 of file AbstractL1CaloPersistentCondition.h.

◆ m_attrSpecificationTypeMap

AttrSpecificationMap AbstractL1CaloPersistentCondition::m_attrSpecificationTypeMap

privateinherited

Definition at line 52 of file AbstractL1CaloPersistentCondition.h.

◆ m_mCoolFoldersKeysMap

std::map<L1CaloHVCorrectionsContainer::eCoolFolders, std::string> L1CaloHVCorrectionsContainer::m_mCoolFoldersKeysMap

private

Definition at line 71 of file L1CaloHVCorrectionsContainer.h.

◆ m_mHVCorrectionsMap

L1CaloHVCorrectionsMap L1CaloHVCorrectionsContainer::m_mHVCorrectionsMap

private

Definition at line 70 of file L1CaloHVCorrectionsContainer.h.

◆ m_strConditionType

std::string AbstractL1CaloPersistentCondition::m_strConditionType

privateinherited

Definition at line 53 of file AbstractL1CaloPersistentCondition.h.

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

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ AttrSpecificationMap

◆ const_iterator

◆ L1CaloHVCorrectionsMap

Member Enumeration Documentation

◆ eAttrSpecification

◆ eCoolFolders

Constructor & Destructor Documentation

◆ L1CaloHVCorrectionsContainer() [1/2]

◆ L1CaloHVCorrectionsContainer() [2/2]

◆ ~L1CaloHVCorrectionsContainer()

Member Function Documentation

◆ addHVCorrections() [1/2]

◆ addHVCorrections() [2/2]

◆ addSpecification()

◆ begin()

◆ clear()

◆ conditionType()

◆ coolFolderKey()

◆ coolInputKeys()

◆ coolOutputKey()

◆ createAttributeListSpecification()

◆ end()

◆ hvCorrections() [1/2]

◆ hvCorrections() [2/2]

◆ makePersistent()

◆ makeTransient() [1/4]

◆ makeTransient() [2/4]

◆ makeTransient() [3/4]

◆ makeTransient() [4/4]

◆ specificationName()

◆ specificationType()

Member Data Documentation

◆ m_attrSpecificationNameMap

◆ m_attrSpecificationTypeMap

◆ m_mCoolFoldersKeysMap

◆ m_mHVCorrectionsMap

◆ m_strConditionType