L1CaloPprChanCalibV1Container Class Reference

#include <L1CaloPprChanCalibV1Container.h>

Inheritance diagram for L1CaloPprChanCalibV1Container:

Collaboration diagram for L1CaloPprChanCalibV1Container:

Public Types
using	const_iterator = std::vector<L1CaloPprChanCalibV1>::const_iterator

Public Member Functions
	L1CaloPprChanCalibV1Container ()
	L1CaloPprChanCalibV1Container (const std::string &folderKey)
virtual	~L1CaloPprChanCalibV1Container ()
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 L1CaloPprChanCalibV1 *	pprChanCalibV1 (unsigned int channelId) const
const L1CaloPprChanCalibV1 *	pprChanCalibV1 (const L1CaloCoolChannelId &channelId) const
const_iterator	begin () const
const_iterator	end () const
void	addPprChanCalibV1 (const L1CaloPprChanCalibV1 &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 , eExtBcidThreshold ,   eSatBcidThreshLow , eSatBcidThreshHigh , eSatBcidLevel , eBcidEnergyRangeLow ,   eBcidEnergyRangeHigh , eFirStartBit , eFirCoeff1 , eFirCoeff2 ,   eFirCoeff3 , eFirCoeff4 , eFirCoeff5 , eLutStrategy ,   eLutOffset , eLutNoiseCut , eLutSlope }
typedef std::map< int, std::string >	AttrSpecificationMap

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

Detailed Description

Definition at line 26 of file L1CaloPprChanCalibV1Container.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 L1CaloPprChanCalibV1Container::const_iterator = std::vector<L1CaloPprChanCalibV1>::const_iterator

Definition at line 49 of file L1CaloPprChanCalibV1Container.h.

Member Enumeration Documentation

eAttrSpecification

enum L1CaloPprChanCalibV1Container::eAttrSpecification

private

Enumerator
eErrorCode
ePedMean
ePedValue
eExtBcidThreshold
eSatBcidThreshLow
eSatBcidThreshHigh
eSatBcidLevel
eBcidEnergyRangeLow
eBcidEnergyRangeHigh
eFirStartBit
eFirCoeff1
eFirCoeff2
eFirCoeff3
eFirCoeff4
eFirCoeff5
eLutStrategy
eLutOffset
eLutNoiseCut
eLutSlope

Definition at line 29 of file L1CaloPprChanCalibV1Container.h.

{ eErrorCode, ePedMean, ePedValue, eExtBcidThreshold, eSatBcidThreshLow, eSatBcidThreshHigh, eSatBcidLevel, eBcidEnergyRangeLow, eBcidEnergyRangeHigh, eFirStartBit, eFirCoeff1, eFirCoeff2, eFirCoeff3, eFirCoeff4, eFirCoeff5, eLutStrategy, eLutOffset, eLutNoiseCut, eLutSlope };

Constructor & Destructor Documentation

L1CaloPprChanCalibV1Container() [1/2]

L1CaloPprChanCalibV1Container::L1CaloPprChanCalibV1Container

(

)

Definition at line 16 of file L1CaloPprChanCalibV1Container.cxx.

  : AbstractL1CaloPersistentCondition("CondAttrListCollection") 
{
  this->addSpecification(eErrorCode, "ErrorCode", "unsigned int");
  this->addSpecification(ePedMean, "PedMean", "double");
  this->addSpecification(ePedValue, "PedValue", "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(eLutStrategy, "LutStrategy", "unsigned short");
  this->addSpecification(eLutOffset, "LutOffset", "unsigned short");
  this->addSpecification(eLutNoiseCut, "LutNoiseCut", "unsigned short");
  this->addSpecification(eLutSlope, "LutSlope", "unsigned short");
}

L1CaloPprChanCalibV1Container() [2/2]

L1CaloPprChanCalibV1Container::L1CaloPprChanCalibV1Container

(

const std::string &

folderKey

)

Definition at line 40 of file L1CaloPprChanCalibV1Container.cxx.

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

~L1CaloPprChanCalibV1Container()

L1CaloPprChanCalibV1Container::~L1CaloPprChanCalibV1Container ( )

virtual

Definition at line 47 of file L1CaloPprChanCalibV1Container.cxx.

{
}

Member Function Documentation

addPprChanCalibV1()

void L1CaloPprChanCalibV1Container::addPprChanCalibV1

(

const L1CaloPprChanCalibV1 &

pprChanCalib

)

Definition at line 136 of file L1CaloPprChanCalibV1Container.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 L1CaloPprChanCalibV1& 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()

const_iterator L1CaloPprChanCalibV1Container::begin

(

)

const

clear()

void L1CaloPprChanCalibV1Container::clear ( )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 148 of file L1CaloPprChanCalibV1Container.cxx.

{
  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 > L1CaloPprChanCalibV1Container::coolInputKeys ( ) const

inlinevirtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 39 of file L1CaloPprChanCalibV1Container.h.

{ return {m_coolFolderKey}; }

coolOutputKey()

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

inlinevirtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 40 of file L1CaloPprChanCalibV1Container.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()

const_iterator L1CaloPprChanCalibV1Container::end

(

)

const

makePersistent()

DataObject * L1CaloPprChanCalibV1Container::makePersistent ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 51 of file L1CaloPprChanCalibV1Container.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(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(eLutStrategy)].setValue(item.lutStrategy());
    attrList[specificationName(eLutOffset)].setValue(item.lutOffset());
    attrList[specificationName(eLutNoiseCut)].setValue(item.lutNoiseCut());
    attrList[specificationName(eLutSlope)].setValue(item.lutSlope());
    
    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 L1CaloPprChanCalibV1Container::makeTransient ( const std::map< std::string, const CondAttrListCollection * > & condAttrListCollectionMap )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 88 of file L1CaloPprChanCalibV1Container.cxx.

{
  clear();
 
  auto it = condAttrListCollectionMap.find(m_coolFolderKey);
  if(it == std::end(condAttrListCollectionMap)) return;
 
  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 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 lutStrategy = attrList[specificationName(eLutStrategy)].data<unsigned short>();
    auto lutOffset = attrList[specificationName(eLutOffset)].data<unsigned short>();
    auto lutNoiseCut = attrList[specificationName(eLutNoiseCut)].data<unsigned short>();
    auto lutSlope = attrList[specificationName(eLutSlope)].data<unsigned short>();
 
    addPprChanCalibV1(L1CaloPprChanCalibV1(chanNum, errorCode, pedMean, pedValue, extBcidThreshold, satBcidThreshLow, satBcidThreshHigh, satBcidLevel, bcidEnergyRangeLow, bcidEnergyRangeHigh, firStartBit, firCoeff1, firCoeff2, firCoeff3, firCoeff4, firCoeff5, lutStrategy, lutOffset, lutNoiseCut, lutSlope));
  }
}

pprChanCalibV1() [1/2]

const L1CaloPprChanCalibV1 * L1CaloPprChanCalibV1Container::pprChanCalibV1 ( const L1CaloCoolChannelId & channelId ) const

inline

Definition at line 45 of file L1CaloPprChanCalibV1Container.h.

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

pprChanCalibV1() [2/2]

const L1CaloPprChanCalibV1 * L1CaloPprChanCalibV1Container::pprChanCalibV1

(

unsigned int

channelId

)

const

Definition at line 124 of file L1CaloPprChanCalibV1Container.cxx.

{
  auto it = std::lower_bound(std::begin(m_pprChanCalibs),
                            std::end(m_pprChanCalibs),
                            channelId,
                            [](const L1CaloPprChanCalibV1& 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 L1CaloPprChanCalibV1Container::m_coolFolderKey = "/TRIGGER/L1Calo/V1/Calibration/Physics/PprChanCalib"

private

Definition at line 58 of file L1CaloPprChanCalibV1Container.h.

m_pprChanCalibs

std::vector<L1CaloPprChanCalibV1> L1CaloPprChanCalibV1Container::m_pprChanCalibs

private

Definition at line 57 of file L1CaloPprChanCalibV1Container.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:

• L1CaloPprChanCalibV1Container.h
• L1CaloPprChanCalibV1Container.cxx