L1CaloPprChanCalibContainer Class Reference

#include <L1CaloPprChanCalibContainer.h>

Inheritance diagram for L1CaloPprChanCalibContainer:

Collaboration diagram for L1CaloPprChanCalibContainer:

Public Types
using	iterator = std::vector<L1CaloPprChanCalib>::iterator
using	const_iterator = std::vector<L1CaloPprChanCalib>::const_iterator

Public Member Functions
	L1CaloPprChanCalibContainer ()
	L1CaloPprChanCalibContainer (const std::string &folderKey)
virtual	~L1CaloPprChanCalibContainer ()
virtual void	makeTransient (const std::map< std::string, const CondAttrListCollection * > &)
virtual DataObject *	makePersistent () const
virtual std::vector< std::string >	coolInputKeys () const
virtual std::string	coolOutputKey () const
virtual void	clear ()
const L1CaloPprChanCalib *	pprChanCalib (unsigned int channelId) const
const L1CaloPprChanCalib *	pprChanCalib (const L1CaloCoolChannelId &channelId) const
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
void	addPprChanCalib (const L1CaloPprChanCalib &pprChanCalib)
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 {   eErrorCode , ePedMean , ePedValue , ePedFirSum ,   eExtBcidThreshold , eSatBcidThreshLow , eSatBcidThreshHigh , eSatBcidLevel ,   eBcidEnergyRangeLow , eBcidEnergyRangeHigh , eFirStartBit , eFirCoeff1 ,   eFirCoeff2 , eFirCoeff3 , eFirCoeff4 , eFirCoeff5 ,   eLutCpStrategy , eLutCpOffset , eLutCpNoiseCut , eLutCpSlope ,   eLutCpPar1 , eLutCpPar2 , eLutCpPar3 , eLutCpPar4 ,   eLutCpScale , eLutJepStrategy , eLutJepOffset , eLutJepNoiseCut ,   eLutJepSlope , eLutJepPar1 , eLutJepPar2 , eLutJepPar3 ,   eLutJepPar4 , eLutJepScale }
typedef std::map< int, std::string >	AttrSpecificationMap

Private Attributes
std::vector< L1CaloPprChanCalib >	m_pprChanCalibs
std::string	m_coolFolderKey = "/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib"
AttrSpecificationMap	m_attrSpecificationNameMap
AttrSpecificationMap	m_attrSpecificationTypeMap
std::string	m_strConditionType

Detailed Description

Definition at line 26 of file L1CaloPprChanCalibContainer.h.

Member Typedef Documentation

AttrSpecificationMap

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

privateinherited

Definition at line 50 of file AbstractL1CaloPersistentCondition.h.

const_iterator

using L1CaloPprChanCalibContainer::const_iterator = std::vector<L1CaloPprChanCalib>::const_iterator

Definition at line 52 of file L1CaloPprChanCalibContainer.h.

iterator

using L1CaloPprChanCalibContainer::iterator = std::vector<L1CaloPprChanCalib>::iterator

Definition at line 49 of file L1CaloPprChanCalibContainer.h.

Member Enumeration Documentation

eAttrSpecification

enum L1CaloPprChanCalibContainer::eAttrSpecification

private

Enumerator
eErrorCode
ePedMean
ePedValue
ePedFirSum
eExtBcidThreshold
eSatBcidThreshLow
eSatBcidThreshHigh
eSatBcidLevel
eBcidEnergyRangeLow
eBcidEnergyRangeHigh
eFirStartBit
eFirCoeff1
eFirCoeff2
eFirCoeff3
eFirCoeff4
eFirCoeff5
eLutCpStrategy
eLutCpOffset
eLutCpNoiseCut
eLutCpSlope
eLutCpPar1
eLutCpPar2
eLutCpPar3
eLutCpPar4
eLutCpScale
eLutJepStrategy
eLutJepOffset
eLutJepNoiseCut
eLutJepSlope
eLutJepPar1
eLutJepPar2
eLutJepPar3
eLutJepPar4
eLutJepScale

Definition at line 29 of file L1CaloPprChanCalibContainer.h.

{ eErrorCode, ePedMean, ePedValue, ePedFirSum, eExtBcidThreshold, eSatBcidThreshLow, eSatBcidThreshHigh, eSatBcidLevel, eBcidEnergyRangeLow, eBcidEnergyRangeHigh, eFirStartBit, eFirCoeff1, eFirCoeff2, eFirCoeff3, eFirCoeff4, eFirCoeff5, eLutCpStrategy, eLutCpOffset, eLutCpNoiseCut, eLutCpSlope, eLutCpPar1, eLutCpPar2, eLutCpPar3, eLutCpPar4, eLutCpScale, eLutJepStrategy, eLutJepOffset, eLutJepNoiseCut, eLutJepSlope, eLutJepPar1, eLutJepPar2, eLutJepPar3, eLutJepPar4, eLutJepScale };

Constructor & Destructor Documentation

L1CaloPprChanCalibContainer() [1/2]

L1CaloPprChanCalibContainer::L1CaloPprChanCalibContainer

(

)

Definition at line 15 of file L1CaloPprChanCalibContainer.cxx.

  : AbstractL1CaloPersistentCondition("CondAttrListCollection") 
{
  this->addSpecification(eErrorCode, "ErrorCode", "unsigned int");
  this->addSpecification(ePedMean, "PedMean", "double");
  this->addSpecification(ePedValue, "PedValue", "unsigned int");
  this->addSpecification(ePedFirSum, "PedFirSum", "unsigned int");
  this->addSpecification(eExtBcidThreshold, "ExtBcidThreshold", "unsigned short");
  this->addSpecification(eSatBcidThreshLow, "SatBcidThreshLow", "unsigned short");
  this->addSpecification(eSatBcidThreshHigh, "SatBcidThreshHigh", "unsigned short");
  this->addSpecification(eSatBcidLevel, "SatBcidLevel", "unsigned short");
  this->addSpecification(eBcidEnergyRangeLow, "BcidEnergyRangeLow", "unsigned short");
  this->addSpecification(eBcidEnergyRangeHigh, "BcidEnergyRangeHigh", "unsigned short");
  this->addSpecification(eFirStartBit, "FirStartBit", "unsigned short");
  this->addSpecification(eFirCoeff1, "FirCoeff1", "short");
  this->addSpecification(eFirCoeff2, "FirCoeff2", "short");
  this->addSpecification(eFirCoeff3, "FirCoeff3", "short");
  this->addSpecification(eFirCoeff4, "FirCoeff4", "short");
  this->addSpecification(eFirCoeff5, "FirCoeff5", "short");
  this->addSpecification(eLutCpStrategy, "LutCpStrategy", "unsigned short");
  this->addSpecification(eLutCpOffset, "LutCpOffset", "unsigned short");
  this->addSpecification(eLutCpNoiseCut, "LutCpNoiseCut", "unsigned short");
  this->addSpecification(eLutCpSlope, "LutCpSlope", "unsigned short");
  this->addSpecification(eLutCpPar1, "LutCpPar1", "short");
  this->addSpecification(eLutCpPar2, "LutCpPar2", "short");
  this->addSpecification(eLutCpPar3, "LutCpPar3", "short");
  this->addSpecification(eLutCpPar4, "LutCpPar4", "short");
  this->addSpecification(eLutCpScale, "LutCpScale", "unsigned short");
  this->addSpecification(eLutJepStrategy, "LutJepStrategy", "unsigned short");
  this->addSpecification(eLutJepOffset, "LutJepOffset", "unsigned short");
  this->addSpecification(eLutJepNoiseCut, "LutJepNoiseCut", "unsigned short");
  this->addSpecification(eLutJepSlope, "LutJepSlope", "unsigned short");
  this->addSpecification(eLutJepPar1, "LutJepPar1", "short");
  this->addSpecification(eLutJepPar2, "LutJepPar2", "short");
  this->addSpecification(eLutJepPar3, "LutJepPar3", "short");
  this->addSpecification(eLutJepPar4, "LutJepPar4", "short");
  this->addSpecification(eLutJepScale, "LutJepScale", "unsigned short");
}

L1CaloPprChanCalibContainer() [2/2]

L1CaloPprChanCalibContainer::L1CaloPprChanCalibContainer

(

const std::string &

folderKey

)

Definition at line 54 of file L1CaloPprChanCalibContainer.cxx.

  : L1CaloPprChanCalibContainer() // delegating constructor
{
  // cppcheck-suppress useInitializationList
  m_coolFolderKey = folderKey;
}

~L1CaloPprChanCalibContainer()

virtual L1CaloPprChanCalibContainer::~L1CaloPprChanCalibContainer ( )

inlinevirtual

Definition at line 33 of file L1CaloPprChanCalibContainer.h.

{}

Member Function Documentation

addPprChanCalib()

void L1CaloPprChanCalibContainer::addPprChanCalib

(

const L1CaloPprChanCalib &

pprChanCalib

)

Definition at line 182 of file L1CaloPprChanCalibContainer.cxx.

{
  // insert into the correct position mainting the sorted vector
  m_pprChanCalibs.insert(std::lower_bound(std::begin(m_pprChanCalibs),
                                           std::end(m_pprChanCalibs),
                                           pprChanCalib.channelId(),
                                           [](const L1CaloPprChanCalib& el, unsigned int va) -> bool {
                                             return el.channelId() < va;
                                           }),
                          pprChanCalib);
}

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() [1/2]

iterator L1CaloPprChanCalibContainer::begin ( )

inline

Definition at line 50 of file L1CaloPprChanCalibContainer.h.

{ return m_pprChanCalibs.begin(); }

begin() [2/2]

const_iterator L1CaloPprChanCalibContainer::begin ( ) const

inline

Definition at line 53 of file L1CaloPprChanCalibContainer.h.

{ return m_pprChanCalibs.begin(); }

clear()

virtual void L1CaloPprChanCalibContainer::clear ( )

inlinevirtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 41 of file L1CaloPprChanCalibContainer.h.

{ m_pprChanCalibs.clear(); }

conditionType()

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

inlinevirtualinherited

Implements IL1CaloPersistenceCapable.

Definition at line 37 of file AbstractL1CaloPersistentCondition.h.

{ return m_strConditionType; };

coolInputKeys()

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

inlinevirtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 39 of file L1CaloPprChanCalibContainer.h.

{ return {m_coolFolderKey}; }

coolOutputKey()

virtual std::string L1CaloPprChanCalibContainer::coolOutputKey ( ) const

inlinevirtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 40 of file L1CaloPprChanCalibContainer.h.

{ return m_coolFolderKey; }

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() [1/2]

iterator L1CaloPprChanCalibContainer::end ( )

inline

Definition at line 51 of file L1CaloPprChanCalibContainer.h.

{ return m_pprChanCalibs.end(); }

end() [2/2]

const_iterator L1CaloPprChanCalibContainer::end ( ) const

inline

Definition at line 54 of file L1CaloPprChanCalibContainer.h.

{ return m_pprChanCalibs.end(); }

makePersistent()

DataObject * L1CaloPprChanCalibContainer::makePersistent ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 62 of file L1CaloPprChanCalibContainer.cxx.

{
  using std::make_unique;
 
  if(m_coolFolderKey.empty()) return nullptr;
 
  auto* attrSpecification = this->createAttributeListSpecification();
  if(!attrSpecification || !attrSpecification->size()) return nullptr;
 
  auto attrListCollection = make_unique<CondAttrListCollection>(true);
  for(const auto& item : m_pprChanCalibs) {
    AthenaAttributeList attrList(*attrSpecification);
    attrList[specificationName(eErrorCode)].setValue(item.errorCode());
    attrList[specificationName(ePedMean)].setValue(item.pedMean());
    attrList[specificationName(ePedValue)].setValue(item.pedValue());
    attrList[specificationName(ePedFirSum)].setValue(item.pedFirSum());
    attrList[specificationName(eExtBcidThreshold)].setValue(item.extBcidThreshold());
    attrList[specificationName(eSatBcidThreshLow)].setValue(item.satBcidThreshLow());
    attrList[specificationName(eSatBcidThreshHigh)].setValue(item.satBcidThreshHigh());
    attrList[specificationName(eSatBcidLevel)].setValue(item.satBcidLevel());
    attrList[specificationName(eBcidEnergyRangeLow)].setValue(item.bcidEnergyRangeLow());
    attrList[specificationName(eBcidEnergyRangeHigh)].setValue(item.bcidEnergyRangeHigh());
    attrList[specificationName(eFirStartBit)].setValue(item.firStartBit());
    attrList[specificationName(eFirCoeff1)].setValue(item.firCoeff1());
    attrList[specificationName(eFirCoeff2)].setValue(item.firCoeff2());
    attrList[specificationName(eFirCoeff3)].setValue(item.firCoeff3());
    attrList[specificationName(eFirCoeff4)].setValue(item.firCoeff4());
    attrList[specificationName(eFirCoeff5)].setValue(item.firCoeff5());
    attrList[specificationName(eLutCpStrategy)].setValue(item.lutCpStrategy());
    attrList[specificationName(eLutCpOffset)].setValue(item.lutCpOffset());
    attrList[specificationName(eLutCpNoiseCut)].setValue(item.lutCpNoiseCut());
    attrList[specificationName(eLutCpSlope)].setValue(item.lutCpSlope());
    attrList[specificationName(eLutCpPar1)].setValue(item.lutCpPar1());
    attrList[specificationName(eLutCpPar2)].setValue(item.lutCpPar2());
    attrList[specificationName(eLutCpPar3)].setValue(item.lutCpPar3());
    attrList[specificationName(eLutCpPar4)].setValue(item.lutCpPar4());
    attrList[specificationName(eLutCpScale)].setValue(item.lutCpScale());
    attrList[specificationName(eLutJepStrategy)].setValue(item.lutJepStrategy());
    attrList[specificationName(eLutJepOffset)].setValue(item.lutJepOffset());
    attrList[specificationName(eLutJepNoiseCut)].setValue(item.lutJepNoiseCut());
    attrList[specificationName(eLutJepSlope)].setValue(item.lutJepSlope());
    attrList[specificationName(eLutJepPar1)].setValue(item.lutJepPar1());
    attrList[specificationName(eLutJepPar2)].setValue(item.lutJepPar2());
    attrList[specificationName(eLutJepPar3)].setValue(item.lutJepPar3());
    attrList[specificationName(eLutJepPar4)].setValue(item.lutJepPar4());
    attrList[specificationName(eLutJepScale)].setValue(item.lutJepScale());
    
    attrListCollection->add(item.channelId(), attrList);
  }
  return static_cast<DataObject*>(attrListCollection.release());
}

makeTransient() [1/2]

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

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

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() [2/2]

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

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 114 of file L1CaloPprChanCalibContainer.cxx.

{
  clear();
  
  // In the case of overlay, we need multiple instances of L1CaloPprChanCalibContainer
  // Take the last element in the map
  if (condAttrListCollectionMap.empty()) return;
  auto it = condAttrListCollectionMap.rbegin();
 
  auto attrListCollection = it->second;
 
  for(const auto& item : *attrListCollection) {
    auto chanNum = item.first;
    const auto& attrList = item.second;
    
    auto errorCode = attrList[specificationName(eErrorCode)].data<unsigned int>();
    auto pedMean = attrList[specificationName(ePedMean)].data<double>();
    auto pedValue = attrList[specificationName(ePedValue)].data<unsigned int>();
    auto pedFirSum = attrList[specificationName(ePedFirSum)].data<unsigned int>();
    auto extBcidThreshold = attrList[specificationName(eExtBcidThreshold)].data<unsigned short>();
    auto satBcidThreshLow = attrList[specificationName(eSatBcidThreshLow)].data<unsigned short>();
    auto satBcidThreshHigh = attrList[specificationName(eSatBcidThreshHigh)].data<unsigned short>();
    auto satBcidLevel = attrList[specificationName(eSatBcidLevel)].data<unsigned short>();
    auto bcidEnergyRangeLow = attrList[specificationName(eBcidEnergyRangeLow)].data<unsigned short>();
    auto bcidEnergyRangeHigh = attrList[specificationName(eBcidEnergyRangeHigh)].data<unsigned short>();
    auto firStartBit = attrList[specificationName(eFirStartBit)].data<unsigned short>();
    auto firCoeff1 = attrList[specificationName(eFirCoeff1)].data<short>();
    auto firCoeff2 = attrList[specificationName(eFirCoeff2)].data<short>();
    auto firCoeff3 = attrList[specificationName(eFirCoeff3)].data<short>();
    auto firCoeff4 = attrList[specificationName(eFirCoeff4)].data<short>();
    auto firCoeff5 = attrList[specificationName(eFirCoeff5)].data<short>();
    auto lutCpStrategy = attrList[specificationName(eLutCpStrategy)].data<unsigned short>();
    auto lutCpOffset = attrList[specificationName(eLutCpOffset)].data<unsigned short>();
    auto lutCpNoiseCut = attrList[specificationName(eLutCpNoiseCut)].data<unsigned short>();
    auto lutCpSlope = attrList[specificationName(eLutCpSlope)].data<unsigned short>();
    auto lutCpPar1 = attrList[specificationName(eLutCpPar1)].data<short>();
    auto lutCpPar2 = attrList[specificationName(eLutCpPar2)].data<short>();
    auto lutCpPar3 = attrList[specificationName(eLutCpPar3)].data<short>();
    auto lutCpPar4 = attrList[specificationName(eLutCpPar4)].data<short>();
    auto lutCpScale = attrList[specificationName(eLutCpScale)].data<unsigned short>();
    auto lutJepStrategy = attrList[specificationName(eLutJepStrategy)].data<unsigned short>();
    auto lutJepOffset = attrList[specificationName(eLutJepOffset)].data<unsigned short>();
    auto lutJepNoiseCut = attrList[specificationName(eLutJepNoiseCut)].data<unsigned short>();
    auto lutJepSlope = attrList[specificationName(eLutJepSlope)].data<unsigned short>();
    auto lutJepPar1 = attrList[specificationName(eLutJepPar1)].data<short>();
    auto lutJepPar2 = attrList[specificationName(eLutJepPar2)].data<short>();
    auto lutJepPar3 = attrList[specificationName(eLutJepPar3)].data<short>();
    auto lutJepPar4 = attrList[specificationName(eLutJepPar4)].data<short>();
    auto lutJepScale = attrList[specificationName(eLutJepScale)].data<unsigned short>();
 
    addPprChanCalib(L1CaloPprChanCalib(chanNum, errorCode, pedMean, pedValue, pedFirSum, extBcidThreshold, satBcidThreshLow, satBcidThreshHigh, satBcidLevel, bcidEnergyRangeLow, bcidEnergyRangeHigh, firStartBit, firCoeff1, firCoeff2, firCoeff3, firCoeff4, firCoeff5, lutCpStrategy, lutCpOffset, lutCpNoiseCut, lutCpSlope, lutCpPar1, lutCpPar2, lutCpPar3, lutCpPar4, lutCpScale, lutJepStrategy, lutJepOffset, lutJepNoiseCut, lutJepSlope, lutJepPar1, lutJepPar2, lutJepPar3, lutJepPar4, lutJepScale));
  }
  
//   }
}

pprChanCalib() [1/2]

const L1CaloPprChanCalib * L1CaloPprChanCalibContainer::pprChanCalib ( const L1CaloCoolChannelId & channelId ) const

inline

Definition at line 45 of file L1CaloPprChanCalibContainer.h.

                                                                                     {
    return pprChanCalib(channelId.id());
  }

pprChanCalib() [2/2]

const L1CaloPprChanCalib * L1CaloPprChanCalibContainer::pprChanCalib

(

unsigned int

channelId

)

const

Definition at line 170 of file L1CaloPprChanCalibContainer.cxx.

{
  auto it = std::lower_bound(std::begin(m_pprChanCalibs),
                            std::end(m_pprChanCalibs),
                            channelId,
                            [](const L1CaloPprChanCalib& el, unsigned int val) -> bool {
                              return el.channelId() < val;
                            });
  if(it == std::end(m_pprChanCalibs)) return nullptr;
  return &(*it);
}

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_coolFolderKey

std::string L1CaloPprChanCalibContainer::m_coolFolderKey = "/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib"

private

Definition at line 61 of file L1CaloPprChanCalibContainer.h.

m_pprChanCalibs

std::vector<L1CaloPprChanCalib> L1CaloPprChanCalibContainer::m_pprChanCalibs

private

Definition at line 60 of file L1CaloPprChanCalibContainer.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:

• L1CaloPprChanCalibContainer.h
• L1CaloPprChanCalibContainer.cxx