L1CaloRxLayersContainer Class Reference

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

#include <L1CaloRxLayersContainer.h>

Inheritance diagram for L1CaloRxLayersContainer:

Collaboration diagram for L1CaloRxLayersContainer:

Public Types
enum	eCoolFolders { eRxLayers }
typedef std::map< unsigned int, L1CaloRxLayers >	L1CaloRxLayersMap
typedef L1CaloRxLayersMap::const_iterator	const_iterator

Public Member Functions
	L1CaloRxLayersContainer ()
	L1CaloRxLayersContainer (const std::map< L1CaloRxLayersContainer::eCoolFolders, std::string > &folderKeysMap)
virtual	~L1CaloRxLayersContainer ()
virtual DataObject *	makePersistent () const
virtual void	makeTransient (const std::map< std::string, const CondAttrListCollection * > &condAttrListCollectionMap)
const L1CaloRxLayers *	rxLayers (unsigned int channelId) const
const L1CaloRxLayers *	rxLayers (const L1CaloRxCoolChannelId &channelId) const
void	addRxLayers (unsigned int channelId, L1CaloRxLayers &&rxLayers)
void	addRxLayers (const L1CaloRxCoolChannelId &channelId, L1CaloRxLayers &&rxLayers)
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 {   eNLayers, eName1, eName2, eName3,   eName4, eNCells1, eNCells2, eNCells3,   eNCells4 }
typedef std::map< int, std::string >	AttrSpecificationMap

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

Private Attributes
L1CaloRxLayersMap	m_mRxLayersMap
std::map< L1CaloRxLayersContainer::eCoolFolders, std::string >	m_mCoolFoldersKeysMap
AttrSpecificationMap	m_attrSpecificationNameMap
AttrSpecificationMap	m_attrSpecificationTypeMap
std::string	m_strConditionType

Detailed Description

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

Implement the IL1CaloPersistenceCapable interface.

Author

Peter Faulkner

Definition at line 28 of file L1CaloRxLayersContainer.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 L1CaloRxLayersMap::const_iterator L1CaloRxLayersContainer::const_iterator

Definition at line 37 of file L1CaloRxLayersContainer.h.

L1CaloRxLayersMap

typedef std::map<unsigned int, L1CaloRxLayers> L1CaloRxLayersContainer::L1CaloRxLayersMap

Definition at line 36 of file L1CaloRxLayersContainer.h.

Member Enumeration Documentation

eAttrSpecification

enum L1CaloRxLayersContainer::eAttrSpecification

private

Enumerator
eNLayers
eName1
eName2
eName3
eName4
eNCells1
eNCells2
eNCells3
eNCells4

Definition at line 32 of file L1CaloRxLayersContainer.h.

{ eNLayers, eName1, eName2, eName3, eName4, eNCells1, eNCells2, eNCells3, eNCells4 };

eCoolFolders

enum L1CaloRxLayersContainer::eCoolFolders

Enumerator
eRxLayers

Definition at line 39 of file L1CaloRxLayersContainer.h.

{ eRxLayers };

Constructor & Destructor Documentation

L1CaloRxLayersContainer() [1/2]

L1CaloRxLayersContainer::L1CaloRxLayersContainer

(

)

Definition at line 14 of file L1CaloRxLayersContainer.cxx.

                                                :AbstractL1CaloPersistentCondition("CondAttrListCollection") {
    // Define DB rows names and types in order to construct the AttributeListSpecification object
    this->addSpecification(eNLayers,  std::string("NLayers"),  std::string("unsigned char"));
    this->addSpecification(eName1,    std::string("Name1"),    std::string("unsigned char"));
    this->addSpecification(eName2,    std::string("Name2"),    std::string("unsigned char"));
    this->addSpecification(eName3,    std::string("Name3"),    std::string("unsigned char"));
    this->addSpecification(eName4,    std::string("Name4"),    std::string("unsigned char"));
    this->addSpecification(eNCells1,  std::string("NCells1"),  std::string("unsigned char"));
    this->addSpecification(eNCells2,  std::string("NCells2"),  std::string("unsigned char"));
    this->addSpecification(eNCells3,  std::string("NCells3"),  std::string("unsigned char"));
    this->addSpecification(eNCells4,  std::string("NCells4"),  std::string("unsigned char"));
 
    m_mCoolFoldersKeysMap[L1CaloRxLayersContainer::eRxLayers] = std::string("/TRIGGER/L1Calo/V1/Results/RxLayers");
}

L1CaloRxLayersContainer() [2/2]

L1CaloRxLayersContainer::L1CaloRxLayersContainer

(

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

folderKeysMap

)

Definition at line 29 of file L1CaloRxLayersContainer.cxx.

                                                                                                                            : 
  AbstractL1CaloPersistentCondition("CondAttrListCollection"),
  m_mCoolFoldersKeysMap(folderKeysMap)
{
    // Define DB rows names and types in order to construct the AttributeListSpecification object
    this->addSpecification(eNLayers,  std::string("NLayers"),  std::string("unsigned char"));
    this->addSpecification(eName1,    std::string("Name1"),    std::string("unsigned char"));
    this->addSpecification(eName2,    std::string("Name2"),    std::string("unsigned char"));
    this->addSpecification(eName3,    std::string("Name3"),    std::string("unsigned char"));
    this->addSpecification(eName4,    std::string("Name4"),    std::string("unsigned char"));
    this->addSpecification(eNCells1,  std::string("NCells1"),  std::string("unsigned char"));
    this->addSpecification(eNCells2,  std::string("NCells2"),  std::string("unsigned char"));
    this->addSpecification(eNCells3,  std::string("NCells3"),  std::string("unsigned char"));
    this->addSpecification(eNCells4,  std::string("NCells4"),  std::string("unsigned char"));
}

~L1CaloRxLayersContainer()

virtual L1CaloRxLayersContainer::~L1CaloRxLayersContainer ( )

inlinevirtual

Definition at line 43 of file L1CaloRxLayersContainer.h.

{};

Member Function Documentation

addRxLayers() [1/2]

void L1CaloRxLayersContainer::addRxLayers	(	const L1CaloRxCoolChannelId &	channelId,
		L1CaloRxLayers &&	rxLayers
	)

Definition at line 175 of file L1CaloRxLayersContainer.cxx.

                                                                                                           {
    this->addRxLayers(channelId.id(), std::move(rxLayers));
}

addRxLayers() [2/2]

void L1CaloRxLayersContainer::addRxLayers	(	unsigned int	channelId,
		L1CaloRxLayers &&	rxLayers
	)

Definition at line 171 of file L1CaloRxLayersContainer.cxx.

                                                                                           {
    m_mRxLayersMap[channelId] = std::move(rxLayers);
}

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 L1CaloRxLayersContainer::begin ( ) const

inline

Definition at line 58 of file L1CaloRxLayersContainer.h.

{ return m_mRxLayersMap.begin(); };

clear()

void L1CaloRxLayersContainer::clear ( )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 179 of file L1CaloRxLayersContainer.cxx.

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

private

Definition at line 45 of file L1CaloRxLayersContainer.cxx.

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

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 55 of file L1CaloRxLayersContainer.cxx.

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

coolOutputKey()

std::string L1CaloRxLayersContainer::coolOutputKey ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 61 of file L1CaloRxLayersContainer.cxx.

                                                       {
    return this->coolFolderKey(L1CaloRxLayersContainer::eRxLayers);
}

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 L1CaloRxLayersContainer::end ( ) const

inline

Definition at line 59 of file L1CaloRxLayersContainer.h.

{ return m_mRxLayersMap.end(); };

makePersistent()

DataObject * L1CaloRxLayersContainer::makePersistent ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 65 of file L1CaloRxLayersContainer.cxx.

                                                          {
    if(m_mRxLayersMap.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);
 
    L1CaloRxLayersMap::const_iterator pos = m_mRxLayersMap.begin();
    L1CaloRxLayersMap::const_iterator end = m_mRxLayersMap.end();
    for(; pos!=end; ++pos) {
        const unsigned int channelId = pos->first;
        const L1CaloRxLayers&   p = pos->second;
    const std::vector<int>& names(p.names());
    const std::vector<int>& ncells(p.ncells());
    const unsigned char nlayers = names.size();
    const unsigned char name1   = (nlayers > 0) ? names[0]  : 0;
    const unsigned char name2   = (nlayers > 1) ? names[1]  : 0;
    const unsigned char name3   = (nlayers > 2) ? names[2]  : 0;
    const unsigned char name4   = (nlayers > 3) ? names[3]  : 0;
    const unsigned char ncells1 = (nlayers > 0) ? ncells[0] : 0;
    const unsigned char ncells2 = (nlayers > 1) ? ncells[1] : 0;
    const unsigned char ncells3 = (nlayers > 2) ? ncells[2] : 0;
    const unsigned char ncells4 = (nlayers > 3) ? ncells[3] : 0;
 
        AthenaAttributeList attrList(*attrSpecification);
 
        // Set value of each row for the current channel
        attrList[ this->specificationName(eNLayers) ].setValue(nlayers);
        attrList[ this->specificationName(eName1) ].setValue(name1);
        attrList[ this->specificationName(eName2) ].setValue(name2);
        attrList[ this->specificationName(eName3) ].setValue(name3);
        attrList[ this->specificationName(eName4) ].setValue(name4);
        attrList[ this->specificationName(eNCells1) ].setValue(ncells1);
        attrList[ this->specificationName(eNCells2) ].setValue(ncells2);
        attrList[ this->specificationName(eNCells3) ].setValue(ncells3);
        attrList[ this->specificationName(eNCells4) ].setValue(ncells4);
 
        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 L1CaloRxLayersContainer::makeTransient ( const std::map< std::string, const CondAttrListCollection * > &  condAttrListCollectionMap )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 111 of file L1CaloRxLayersContainer.cxx.

                                                                                                                             {
 
    this->clear();
 
    std::map<std::string, const CondAttrListCollection*>::const_iterator
      it_map(condAttrListCollectionMap.find(this->coolFolderKey(L1CaloRxLayersContainer::eRxLayers)));
 
    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);
 
            unsigned char nlayers = attrList[ this->specificationName(eNLayers) ].data<unsigned char>();
        std::vector<int> names;
        std::vector<int> ncells;
        if (nlayers > 0) {
          names.push_back((int)attrList[ this->specificationName(eName1) ].data<unsigned char>());
          ncells.push_back((int)attrList[ this->specificationName(eNCells1) ].data<unsigned char>());
            }
        if (nlayers > 1) {
          names.push_back((int)attrList[ this->specificationName(eName2) ].data<unsigned char>());
          ncells.push_back((int)attrList[ this->specificationName(eNCells2) ].data<unsigned char>());
            }
        if (nlayers > 2) {
          names.push_back((int)attrList[ this->specificationName(eName3) ].data<unsigned char>());
          ncells.push_back((int)attrList[ this->specificationName(eNCells3) ].data<unsigned char>());
            }
        if (nlayers > 3) {
          names.push_back((int)attrList[ this->specificationName(eName4) ].data<unsigned char>());
          ncells.push_back((int)attrList[ this->specificationName(eNCells4) ].data<unsigned char>());
            }
 
            L1CaloRxLayers l1CaloRxLayers(chanNum, std::move(names), std::move(ncells));
            m_mRxLayersMap[chanNum] = std::move(l1CaloRxLayers);
        }
    } else {
        std::cout << "L1CaloRxLayersContainer : Could not find requested CondAttrListCollection "
                  << this->coolFolderKey(L1CaloRxLayersContainer::eRxLayers) << std::endl;
    }
}

rxLayers() [1/2]

const L1CaloRxLayers * L1CaloRxLayersContainer::rxLayers

(

const L1CaloRxCoolChannelId &

channelId

)

const

Definition at line 167 of file L1CaloRxLayersContainer.cxx.

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

rxLayers() [2/2]

const L1CaloRxLayers * L1CaloRxLayersContainer::rxLayers

(

unsigned int

channelId

)

const

Definition at line 161 of file L1CaloRxLayersContainer.cxx.

                                                                                    {
    L1CaloRxLayersMap::const_iterator pos = m_mRxLayersMap.find(channelId);
    if(pos==m_mRxLayersMap.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<L1CaloRxLayersContainer::eCoolFolders, std::string> L1CaloRxLayersContainer::m_mCoolFoldersKeysMap

private

Definition at line 70 of file L1CaloRxLayersContainer.h.

m_mRxLayersMap

L1CaloRxLayersMap L1CaloRxLayersContainer::m_mRxLayersMap

private

Definition at line 69 of file L1CaloRxLayersContainer.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:

• L1CaloRxLayersContainer.h
• L1CaloRxLayersContainer.cxx