#include <L1CaloPprDisabledChannelContainer.h>

Inheritance diagram for L1CaloPprDisabledChannelContainer:

Collaboration diagram for L1CaloPprDisabledChannelContainer:

Public Types
enum	eCoolFolders { ePpmDeadChannels, ePprChanCalib, eDisabledTowers, eOKS2COOL }

typedef std::map< unsigned int, L1CaloPprDisabledChannel >::const_iterator	const_iterator

Public Member Functions
	L1CaloPprDisabledChannelContainer ()

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

virtual	~L1CaloPprDisabledChannelContainer ()

virtual DataObject *	makePersistent () const

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

const L1CaloPprDisabledChannel *	pprDisabledChannel (unsigned int channelId) const

const L1CaloPprDisabledChannel *	pprDisabledChannel (const L1CaloCoolChannelId &channelId) const

void	addPprDisabledChannel (unsigned int channelId, const L1CaloPprDisabledChannel &pprDisabledChannel)

void	addPprDisabledChannel (const L1CaloCoolChannelId &channelId, const L1CaloPprDisabledChannel &pprDisabledChannel)

L1CaloPprDisabledChannelMap::const_iterator	begin () const

L1CaloPprDisabledChannelMap::const_iterator	end () const

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

virtual std::string	coolOutputKey () const

virtual void	clear ()

void	dump () const

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 { eChanDeadErrorCode, eChanCalibErrorCode, eCaloDisableMask, eEtaDisableMask, ePhiDisableMask, eChanDisableMask, eNoiseCut, eDisabledBits }

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

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

Private Attributes
L1CaloPprDisabledChannelMap	m_mPprDisabledChannelMap

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

AttrSpecificationMap	m_attrSpecificationNameMap

AttrSpecificationMap	m_attrSpecificationTypeMap

std::string	m_strConditionType

Detailed Description

Definition at line 27 of file L1CaloPprDisabledChannelContainer.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 std::map<unsigned int, L1CaloPprDisabledChannel>::const_iterator L1CaloPprDisabledChannelContainer::const_iterator

Definition at line 35 of file L1CaloPprDisabledChannelContainer.h.

Member Enumeration Documentation

◆ eAttrSpecification

enum L1CaloPprDisabledChannelContainer::eAttrSpecification

private

Enumerator
eChanDeadErrorCode
eChanCalibErrorCode
eCaloDisableMask
eEtaDisableMask
ePhiDisableMask
eChanDisableMask
eNoiseCut
eDisabledBits

Definition at line 30 of file L1CaloPprDisabledChannelContainer.h.

30 { eChanDeadErrorCode, eChanCalibErrorCode, eCaloDisableMask, eEtaDisableMask, ePhiDisableMask, eChanDisableMask, eNoiseCut, eDisabledBits };

◆ eCoolFolders

enum L1CaloPprDisabledChannelContainer::eCoolFolders

Enumerator
ePpmDeadChannels
ePprChanCalib
eDisabledTowers
eOKS2COOL

Definition at line 33 of file L1CaloPprDisabledChannelContainer.h.

33 { ePpmDeadChannels, ePprChanCalib, eDisabledTowers, eOKS2COOL };

Constructor & Destructor Documentation

◆ L1CaloPprDisabledChannelContainer() [1/2]

L1CaloPprDisabledChannelContainer::L1CaloPprDisabledChannelContainer ( )

Definition at line 18 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                     :AbstractL1CaloPersistentCondition("CondAttrListCollection") {
     // Define DB rows names and types in order to construct the AttributeListSpecification object
         this->addSpecification(eChanDeadErrorCode, std::string("ErrorCode"), std::string("UInt32"));
     this->addSpecification(eChanCalibErrorCode, std::string("ErrorCode"), std::string("UInt32"));
  
     // noiseCut from PpmDeadChannels db
     this->addSpecification(eNoiseCut, std::string("NoiseCut"), std::string("UInt16"));
  
     // disabledBits from DisabledTowers db
     this->addSpecification(eDisabledBits, std::string("disabledBits"), std::string("UInt32"));
  
     //OKS stuff
     this->addSpecification(eCaloDisableMask, std::string("caloDisableMask"), std::string("Int64"));
     this->addSpecification(eEtaDisableMask, std::string("etaDisableMask"), std::string("Int64"));
     this->addSpecification(ePhiDisableMask, std::string("phiDisableMask"), std::string("Int64"));
     this->addSpecification(eChanDisableMask, std::string("chanDisableMask"), std::string("Int64"));
  
     
 }

◆ L1CaloPprDisabledChannelContainer() [2/2]

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

Definition at line 38 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                                                                                                          :AbstractL1CaloPersistentCondition("CondAttrListCollection"),
     m_mCoolFoldersKeysMap(folderKeysMap)
 {
     // Define DB rows names and types in order to construct the AttributeListSpecification object
     this->addSpecification(eChanDeadErrorCode, std::string("ErrorCode"), std::string("UInt32"));
     this->addSpecification(eChanCalibErrorCode, std::string("ErrorCode"), std::string("UInt32"));
     this->addSpecification(eNoiseCut, std::string("NoiseCut"), std::string("UInt16"));
     this->addSpecification(eDisabledBits, std::string("disabledBits"), std::string("UInt32"));
  
     //OKS stuff
     this->addSpecification(eCaloDisableMask, std::string("caloDisableMask"), std::string("Int64"));
     this->addSpecification(eEtaDisableMask, std::string("etaDisableMask"), std::string("Int64"));
     this->addSpecification(ePhiDisableMask, std::string("phiDisableMask"), std::string("Int64"));
     this->addSpecification(eChanDisableMask, std::string("chanDisableMask"), std::string("Int64"));
 }

◆ ~L1CaloPprDisabledChannelContainer()

virtual L1CaloPprDisabledChannelContainer::~L1CaloPprDisabledChannelContainer ( )

inlinevirtual

Definition at line 39 of file L1CaloPprDisabledChannelContainer.h.

39 {};

Member Function Documentation

◆ addPprDisabledChannel() [1/2]

void L1CaloPprDisabledChannelContainer::addPprDisabledChannel	(	const L1CaloCoolChannelId &	channelId,
		const L1CaloPprDisabledChannel &	pprDisabledChannel
	)

Definition at line 238 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                                                                                                       {
     return this->addPprDisabledChannel(channelId.id(), pprDisabledChannel);
 }

◆ addPprDisabledChannel() [2/2]

void L1CaloPprDisabledChannelContainer::addPprDisabledChannel	(	unsigned int	channelId,
		const L1CaloPprDisabledChannel &	pprDisabledChannel
	)

Definition at line 234 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                                                                                         {
     m_mPprDisabledChannelMap[channelId] = pprDisabledChannel;
 }

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

L1CaloPprDisabledChannelMap::const_iterator L1CaloPprDisabledChannelContainer::begin ( ) const

inline

Definition at line 51 of file L1CaloPprDisabledChannelContainer.h.

51 { return m_mPprDisabledChannelMap.begin(); };

◆ clear()

void L1CaloPprDisabledChannelContainer::clear ( )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 249 of file L1CaloPprDisabledChannelContainer.cxx.

                                               {
     m_mPprDisabledChannelMap.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 L1CaloPprDisabledChannelContainer::coolFolderKey ( L1CaloPprDisabledChannelContainer::eCoolFolders efolder ) const

privatevirtual

Reimplemented in L1CaloPprDisabledChannelContainerRun2.

Definition at line 54 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                                                                       {
  
     std::map<L1CaloPprDisabledChannelContainer::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 > L1CaloPprDisabledChannelContainer::coolInputKeys ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Reimplemented in L1CaloPprDisabledChannelContainerRun2.

Definition at line 64 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                             {
     std::vector<std::string> v;
     v.push_back(this->coolFolderKey(L1CaloPprDisabledChannelContainer::ePpmDeadChannels));
     v.push_back(this->coolFolderKey(L1CaloPprDisabledChannelContainer::ePprChanCalib));
     v.push_back(this->coolFolderKey(L1CaloPprDisabledChannelContainer::eDisabledTowers));
     //v.push_back(this->coolFolderKey(L1CaloPprDisabledChannelContainer::eOKS2COOL));
     return v;
 }

◆ coolOutputKey()

std::string L1CaloPprDisabledChannelContainer::coolOutputKey ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Reimplemented in L1CaloPprDisabledChannelContainerRun2.

Definition at line 73 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                  {
     //return this->coolFolderKey(L1CaloPprDisabledChannelContainer::ePpmDeadChannels);
     return std::string("");
 }

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

◆ dump()

void L1CaloPprDisabledChannelContainer::dump ( ) const

Definition at line 242 of file L1CaloPprDisabledChannelContainer.cxx.

                                                    {
     L1CaloPprDisabledChannelContainer::const_iterator it = this->begin();
     for(;it!=this->end();++it) {
         std::cout << " * item: " <<it->first << " => "<<it->second <<std::endl;
     }
 }

◆ end()

L1CaloPprDisabledChannelMap::const_iterator L1CaloPprDisabledChannelContainer::end ( ) const

inline

Definition at line 52 of file L1CaloPprDisabledChannelContainer.h.

52 { return m_mPprDisabledChannelMap.end(); };

◆ makePersistent()

DataObject * L1CaloPprDisabledChannelContainer::makePersistent ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 78 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                     {
     return 0;
 /*
     if(m_mPprDisabledChannelMap.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);
  
     L1CaloPprDisabledChannelMap::const_iterator pos = m_mPprDisabledChannelMap.begin();
     for(;pos!=m_mPprDisabledChannelMap.end();++pos) {
         const unsigned int channelId = pos->first;
         const L1CaloPprDisabledChannel&  p = pos->second;
  
         AthenaAttributeList attrList(*attrSpecification);
  
         // Set value of each row for the current channel
         attrList[ this->specificationName(eChanDeadErrorCode) ].setValue(p.deadErrorCode().errorCode());
         attrList[ this->specificationName(eChanCalibErrorCode) ].setValue(p.calibErrorCode.errorCode());
  
         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 L1CaloPprDisabledChannelContainer::makeTransient ( const std::map< std::string, const CondAttrListCollection * > & condAttrListCollectionMap )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 108 of file L1CaloPprDisabledChannelContainer.cxx.

                                                                                                                                        {
  
   CondAttrListCollection::const_iterator it_attr;
   CondAttrListCollection::const_iterator it_attrE;
  
   if (condAttrListCollectionMap.empty()) return;
  
   // Reading cool paths and reading attributes 
   
   for (const auto& [name, coll] : condAttrListCollectionMap) {
     if (name.find("PpmDeadChannels")!=std::string::npos){
       auto it_deadChannelsAttrListCollection = condAttrListCollectionMap.find(name);
       const CondAttrListCollection* deadChannelsAttrListCollection = it_deadChannelsAttrListCollection->second;
  
       
       //Dead channel
       it_attr  = deadChannelsAttrListCollection->begin();
       it_attrE = deadChannelsAttrListCollection->end();
       for(;it_attr!=it_attrE;++it_attr) {
     
     const coral::AttributeList& attrList(it_attr->second);
     
     // Get value of each row for the current channel
     CondAttrListCollection::ChanNum chanNum(it_attr->first);
     
     ChanDeadErrorCode errorCode(attrList[ this->specificationName(eChanDeadErrorCode) ].data<unsigned int>());
     
     unsigned int noiseCut = attrList[this->specificationName(eNoiseCut)].data<unsigned int>();
     
     // test if the channel is really bad for the given IOV
     if(!errorCode.chanValid() || noiseCut > 0) {
       L1CaloPprDisabledChannelMap::iterator it_chan =  m_mPprDisabledChannelMap.find(chanNum);
       if(it_chan==m_mPprDisabledChannelMap.end()) {
         m_mPprDisabledChannelMap[chanNum] = L1CaloPprDisabledChannel(chanNum);
       }
       m_mPprDisabledChannelMap[chanNum].deadErrorCode(errorCode);
       m_mPprDisabledChannelMap[chanNum].setNoiseCut(noiseCut);
     }
       } 
  
       
       
     } // End PpmDeadChannels
     
     if(name.find("PprChanCalib")!=std::string::npos){
       auto it_calibChannelsAttrListCollection = condAttrListCollectionMap.find(name);
       const CondAttrListCollection* calibChannelsAttrListCollection =  it_calibChannelsAttrListCollection->second;
  
  
       
       // calib channels
       it_attr  = calibChannelsAttrListCollection->begin();
       it_attrE = calibChannelsAttrListCollection->end();
       for(;it_attr!=it_attrE;++it_attr) {
     
     const coral::AttributeList& attrList(it_attr->second);
     
     // Get value of each row for the current channel
     CondAttrListCollection::ChanNum chanNum(it_attr->first);
     
     ChanCalibErrorCode errorCode(attrList[ this->specificationName(eChanCalibErrorCode) ].data<unsigned int>());
     
     // test if the channel is correctly calibrated for the given IOV
     if(!errorCode.chanValid()) {
       L1CaloPprDisabledChannelMap::iterator it_chan =  m_mPprDisabledChannelMap.find(chanNum);
       if(it_chan==m_mPprDisabledChannelMap.end()) {
         m_mPprDisabledChannelMap[chanNum] = L1CaloPprDisabledChannel(chanNum);
       }
       m_mPprDisabledChannelMap[chanNum].calibErrorCode(errorCode);
     }
       }
       
       
     
  
     } // End PprChanCalib
  
     if(name.find("DisabledTowers")!=std::string::npos){
       auto it_disabledTowersAttrListCollection = condAttrListCollectionMap.find(name);
       const CondAttrListCollection* disabledTowersAttrListCollection = it_disabledTowersAttrListCollection->second;
       
       // disabled towers
       it_attr  = disabledTowersAttrListCollection->begin();
       it_attrE = disabledTowersAttrListCollection->end();
       for(;it_attr!=it_attrE;++it_attr) {
     
     const coral::AttributeList& attrList(it_attr->second);
     
     // Get value of each row for the current channel
     CondAttrListCollection::ChanNum chanNum(it_attr->first);
     
     unsigned int disabledBits = attrList[this->specificationName(eDisabledBits)].data<unsigned int>();
     
     if(disabledBits) {
       L1CaloPprDisabledChannelMap::iterator it_chan =  m_mPprDisabledChannelMap.find(chanNum);
       if(it_chan==m_mPprDisabledChannelMap.end()) {
         m_mPprDisabledChannelMap[chanNum] = L1CaloPprDisabledChannel(chanNum);
       }
       m_mPprDisabledChannelMap[chanNum].setDisabledBits(disabledBits);
     }
       }
       
       
  
       
     } // End DisabledTowers
     
   } // End cool loop 
   
   
  
  
  
  
 }

◆ pprDisabledChannel() [1/2]

const L1CaloPprDisabledChannel * L1CaloPprDisabledChannelContainer::pprDisabledChannel ( const L1CaloCoolChannelId & channelId ) const

Definition at line 230 of file L1CaloPprDisabledChannelContainer.cxx.

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

◆ pprDisabledChannel() [2/2]

const L1CaloPprDisabledChannel * L1CaloPprDisabledChannelContainer::pprDisabledChannel ( unsigned int channelId ) const

Definition at line 224 of file L1CaloPprDisabledChannelContainer.cxx.

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

◆ 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<L1CaloPprDisabledChannelContainer::eCoolFolders, std::string> L1CaloPprDisabledChannelContainer::m_mCoolFoldersKeysMap

private

Definition at line 65 of file L1CaloPprDisabledChannelContainer.h.

◆ m_mPprDisabledChannelMap

L1CaloPprDisabledChannelMap L1CaloPprDisabledChannelContainer::m_mPprDisabledChannelMap

private

Definition at line 64 of file L1CaloPprDisabledChannelContainer.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

Member Enumeration Documentation

◆ eAttrSpecification

◆ eCoolFolders

Constructor & Destructor Documentation

◆ L1CaloPprDisabledChannelContainer() [1/2]

◆ L1CaloPprDisabledChannelContainer() [2/2]

◆ ~L1CaloPprDisabledChannelContainer()

Member Function Documentation

◆ addPprDisabledChannel() [1/2]

◆ addPprDisabledChannel() [2/2]

◆ addSpecification()

◆ begin()

◆ clear()

◆ conditionType()

◆ coolFolderKey()

◆ coolInputKeys()

◆ coolOutputKey()

◆ createAttributeListSpecification()

◆ dump()

◆ end()

◆ makePersistent()

◆ makeTransient() [1/4]

◆ makeTransient() [2/4]

◆ makeTransient() [3/4]

◆ makeTransient() [4/4]

◆ pprDisabledChannel() [1/2]

◆ pprDisabledChannel() [2/2]

◆ specificationName()

◆ specificationType()

Member Data Documentation

◆ m_attrSpecificationNameMap

◆ m_attrSpecificationTypeMap

◆ m_mCoolFoldersKeysMap

◆ m_mPprDisabledChannelMap

◆ m_strConditionType