L1CaloPprDisabledChannelContainerRun2 Class Reference

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

#include <L1CaloPprDisabledChannelContainerRun2.h>

Inheritance diagram for L1CaloPprDisabledChannelContainerRun2:

Collaboration diagram for L1CaloPprDisabledChannelContainerRun2:

Public Types
enum	eCoolFolders
typedef std::map< unsignedint, L1CaloPprDisabledChannel >::const_iterator	const_iterator

Public Member Functions
	L1CaloPprDisabledChannelContainerRun2 ()
	L1CaloPprDisabledChannelContainerRun2 (const std::map< L1CaloPprDisabledChannelContainerRun2::eCoolFolders, std::string > &folderKeysMap)
virtual	~L1CaloPprDisabledChannelContainerRun2 ()
virtual std::vector< std::string >	coolInputKeys () const
virtual std::string	coolOutputKey () const
virtual DataObject *	makePersistent () const
virtual void	makeTransient (const std::map< std::string, const CondAttrListCollection * > &condAttrListCollectionMap)
virtual void	makeTransient (const std::map< std::string, const AthenaAttributeList * > &condAttributeList)
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 void	clear ()
void	dump () const
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 }

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

Private Attributes
std::map< L1CaloPprDisabledChannelContainerRun2::eCoolFolders, std::string >	m_coolFoldersKeysMap
L1CaloPprDisabledChannelMap	m_mPprDisabledChannelMap
std::map< L1CaloPprDisabledChannelContainer::eCoolFolders, std::string >	m_mCoolFoldersKeysMap

Detailed Description

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

Implement the IL1CaloPersistenceCapable interface.

Modified to work with the Run-2 database.

Author

Veit Scharf

Definition at line 29 of file L1CaloPprDisabledChannelContainerRun2.h.

Member Typedef Documentation

const_iterator

typedef std::map<unsignedint,L1CaloPprDisabledChannel>::const_iterator L1CaloPprDisabledChannelContainer::const_iterator

Definition at line 35 of file L1CaloPprDisabledChannelContainer.h.

Member Enumeration Documentation

eAttrSpecification

enum L1CaloPprDisabledChannelContainer::eAttrSpecification

privateinherited

Enumerator
eChanDeadErrorCode
eChanCalibErrorCode
eCaloDisableMask
eEtaDisableMask
ePhiDisableMask
eChanDisableMask
eNoiseCut
eDisabledBits

Definition at line 30 of file L1CaloPprDisabledChannelContainer.h.

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

eCoolFolders

enum L1CaloPprDisabledChannelContainer::eCoolFolders

Definition at line 33 of file L1CaloPprDisabledChannelContainer.h.

{ ePpmDeadChannels, ePprChanCalib, eDisabledTowers, eOKS2COOL };

Constructor & Destructor Documentation

L1CaloPprDisabledChannelContainerRun2() [1/2]

L1CaloPprDisabledChannelContainerRun2::L1CaloPprDisabledChannelContainerRun2

(

)

Definition at line 18 of file L1CaloPprDisabledChannelContainerRun2.cxx.

  : AbstractL1CaloPersistentCondition("CondAttrListCollection") {
 
  m_coolFoldersKeysMap[L1CaloPprDisabledChannelContainer::ePpmDeadChannels] = std::string("/TRIGGER/L1Calo/V1/Calibration/PpmDeadChannels");
  m_coolFoldersKeysMap[L1CaloPprDisabledChannelContainer::ePprChanCalib] = std::string("/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib");
  m_coolFoldersKeysMap[L1CaloPprDisabledChannelContainer::eDisabledTowers] = std::string("/TRIGGER/L1Calo/V1/Conditions/DisabledTowers");
}

L1CaloPprDisabledChannelContainerRun2() [2/2]

L1CaloPprDisabledChannelContainerRun2::L1CaloPprDisabledChannelContainerRun2

(

const std::map< L1CaloPprDisabledChannelContainerRun2::eCoolFolders, std::string > &

folderKeysMap

)

Definition at line 26 of file L1CaloPprDisabledChannelContainerRun2.cxx.

  : AbstractL1CaloPersistentCondition("CondAttrListCollection")
  , m_coolFoldersKeysMap(folderKeysMap)
{
}

~L1CaloPprDisabledChannelContainerRun2()

virtual L1CaloPprDisabledChannelContainerRun2::~L1CaloPprDisabledChannelContainerRun2 ( )

inlinevirtual

Definition at line 39 of file L1CaloPprDisabledChannelContainerRun2.h.

{};

Member Function Documentation

addPprDisabledChannel() [1/2]

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

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

{ return m_mPprDisabledChannelMap.begin(); };

clear()

void L1CaloPprDisabledChannelContainer::clear ( )

virtual

Reimplemented from L1CaloPprDisabledChannelContainer.

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

{ return m_strConditionType; };

coolFolderKey()

std::string L1CaloPprDisabledChannelContainerRun2::coolFolderKey ( L1CaloPprDisabledChannelContainer::eCoolFolders efolder ) const

privatevirtual

Reimplemented from L1CaloPprDisabledChannelContainer.

Definition at line 32 of file L1CaloPprDisabledChannelContainerRun2.cxx.

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

coolInputKeys()

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

virtual

Reimplemented from L1CaloPprDisabledChannelContainer.

Definition at line 42 of file L1CaloPprDisabledChannelContainerRun2.cxx.

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

coolOutputKey()

std::string L1CaloPprDisabledChannelContainerRun2::coolOutputKey ( ) const

virtual

Reimplemented from L1CaloPprDisabledChannelContainer.

Definition at line 50 of file L1CaloPprDisabledChannelContainerRun2.cxx.

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

{ return m_mPprDisabledChannelMap.end(); };

makePersistent()

DataObject * L1CaloPprDisabledChannelContainer::makePersistent ( ) const

virtual

Reimplemented from L1CaloPprDisabledChannelContainer.

Definition at line 40 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/2]

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

virtual

Reimplemented from L1CaloPprDisabledChannelContainer.

Definition at line 43 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/2]

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

virtual

Reimplemented from L1CaloPprDisabledChannelContainer.

Definition at line 44 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 47 of file L1CaloPprDisabledChannelContainer.cxx.

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

pprDisabledChannel() [2/2]

const L1CaloPprDisabledChannel * L1CaloPprDisabledChannelContainer::pprDisabledChannel

(

unsigned int

channelId

)

const

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

                                                                               {
  auto p = m_attrSpecificationNameMap.find(specId);
  if (p == m_attrSpecificationNameMap.end()) return "";
    return p->second;
}

specificationType()

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

inherited

Definition at line 50 of file AbstractL1CaloPersistentCondition.cxx.

                                                                               {
  auto p = m_attrSpecificationTypeMap.find(specId);
  if (p == m_attrSpecificationTypeMap.end()) return "";
    return p->second;
}

Member Data Documentation

m_coolFoldersKeysMap

std::map<L1CaloPprDisabledChannelContainerRun2::eCoolFolders, std::string> L1CaloPprDisabledChannelContainerRun2::m_coolFoldersKeysMap

private

Definition at line 58 of file L1CaloPprDisabledChannelContainerRun2.h.

m_mCoolFoldersKeysMap

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

privateinherited

Definition at line 65 of file L1CaloPprDisabledChannelContainer.h.

m_mPprDisabledChannelMap

L1CaloPprDisabledChannelMap L1CaloPprDisabledChannelContainer::m_mPprDisabledChannelMap

privateinherited

Definition at line 64 of file L1CaloPprDisabledChannelContainer.h.

---

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

• L1CaloPprDisabledChannelContainerRun2.h
• L1CaloPprDisabledChannelContainerRun2.cxx