L1CaloPprConditionsContainerRun2 Class Reference

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

#include <L1CaloPprConditionsContainerRun2.h>

Inheritance diagram for L1CaloPprConditionsContainerRun2:

Collaboration diagram for L1CaloPprConditionsContainerRun2:

Public Types
enum	eCoolFolders { ePprChanDefaults, ePprChanCalib, ePprChanCalibCommon, ePprChanCalibStrategy }

Public Member Functions
	L1CaloPprConditionsContainerRun2 ()
	L1CaloPprConditionsContainerRun2 (const std::map< L1CaloPprConditionsContainerRun2::eCoolFolders, std::string > &folderKeysMap)
virtual	~L1CaloPprConditionsContainerRun2 ()
virtual DataObject *	makePersistent () const
virtual void	makeTransient (const std::map< std::string, const CondAttrListCollection * > &condAttrListCollectionMap)
const L1CaloPprConditionsRun2 *	pprConditions (unsigned int channelId) const
const L1CaloPprConditionsRun2 *	pprConditions (const L1CaloCoolChannelId &channelId) const
int	bcidDecision1 () const
int	satOverride1 () const
int	bcidDecision2 () const
int	satOverride2 () const
int	bcidDecision3 () const
int	satOverride3 () const
int	peakFinderCond () const
int	decisionSource () 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 {   eExtBcidThreshold, eSatBcidThreshLow, eSatBcidThreshHigh, eSatBcidLevel,   eBcidEnergyRangeLow, eBcidEnergyRangeHigh, eFirStartBit, eBcidDecision1,   eSatOverride1, eBcidDecision2, eSatOverride2, eBcidDecision3,   eSatOverride3, ePeakFinderCond, eDecisionSource, eFirCoeff1,   eFirCoeff2, eFirCoeff3, eFirCoeff4, eFirCoeff5,   ePedValue, ePedMean, ePedFirSum, eLutCpStrategy,   eLutCpOffset, eLutCpNoiseCut, eLutCpSlope, eLutCpPar1,   eLutCpPar2, eLutCpPar3, eLutCpPar4, eLutCpScale,   eLutJepStrategy, eLutJepOffset, eLutJepNoiseCut, eLutJepSlope,   eLutJepPar1, eLutJepPar2, eLutJepPar3, eLutJepPar4,   eLutJepScale }
typedef std::vector< L1CaloPprConditionsRun2 * >	L1CaloPprConditionsVec
typedef std::map< int, std::string >	AttrSpecificationMap

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

Private Attributes
L1CaloPprConditionsVec	m_pprConditionsVec
std::map< L1CaloPprConditionsContainerRun2::eCoolFolders, std::string >	m_coolFoldersKeysMap
int	m_bcidDecision1 = 0
int	m_satOverride1 = 0
int	m_bcidDecision2 = 0
int	m_satOverride2 = 0
int	m_bcidDecision3 = 0
int	m_satOverride3 = 0
int	m_peakFinderCond = 0
int	m_decisionSource = 0
AttrSpecificationMap	m_attrSpecificationNameMap
AttrSpecificationMap	m_attrSpecificationTypeMap
std::string	m_strConditionType

Static Private Attributes
static const unsigned int	s_vectorSize = 8192

Detailed Description

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

Implement the IL1CaloPersistenceCapable interface.

Implementation for the Run-2 database.

Author

Veit Scharf

Definition at line 32 of file L1CaloPprConditionsContainerRun2.h.

Member Typedef Documentation

AttrSpecificationMap

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

privateinherited

Definition at line 50 of file AbstractL1CaloPersistentCondition.h.

L1CaloPprConditionsVec

typedef std::vector<L1CaloPprConditionsRun2*> L1CaloPprConditionsContainerRun2::L1CaloPprConditionsVec

private

Definition at line 78 of file L1CaloPprConditionsContainerRun2.h.

Member Enumeration Documentation

eAttrSpecification

enum L1CaloPprConditionsContainerRun2::eAttrSpecification

private

Enumerator
eExtBcidThreshold
eSatBcidThreshLow
eSatBcidThreshHigh
eSatBcidLevel
eBcidEnergyRangeLow
eBcidEnergyRangeHigh
eFirStartBit
eBcidDecision1
eSatOverride1
eBcidDecision2
eSatOverride2
eBcidDecision3
eSatOverride3
ePeakFinderCond
eDecisionSource
eFirCoeff1
eFirCoeff2
eFirCoeff3
eFirCoeff4
eFirCoeff5
ePedValue
ePedMean
ePedFirSum
eLutCpStrategy
eLutCpOffset
eLutCpNoiseCut
eLutCpSlope
eLutCpPar1
eLutCpPar2
eLutCpPar3
eLutCpPar4
eLutCpScale
eLutJepStrategy
eLutJepOffset
eLutJepNoiseCut
eLutJepSlope
eLutJepPar1
eLutJepPar2
eLutJepPar3
eLutJepPar4
eLutJepScale

Definition at line 35 of file L1CaloPprConditionsContainerRun2.h.

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

eCoolFolders

enum L1CaloPprConditionsContainerRun2::eCoolFolders

Enumerator
ePprChanDefaults
ePprChanCalib
ePprChanCalibCommon
ePprChanCalibStrategy

Definition at line 45 of file L1CaloPprConditionsContainerRun2.h.

{ ePprChanDefaults, ePprChanCalib, ePprChanCalibCommon, ePprChanCalibStrategy };

Constructor & Destructor Documentation

L1CaloPprConditionsContainerRun2() [1/2]

L1CaloPprConditionsContainerRun2::L1CaloPprConditionsContainerRun2

(

)

Definition at line 17 of file L1CaloPprConditionsContainerRun2.cxx.

    : AbstractL1CaloPersistentCondition("CondAttrListCollection"),
      m_coolFoldersKeysMap(
          {{L1CaloPprConditionsContainerRun2::ePprChanCalib,
            "/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib"},
           {L1CaloPprConditionsContainerRun2::ePprChanDefaults,
            "/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults"}}) {
  this->addSpecification(eBcidDecision1, std::string("CR12_BcidDecision1"),
                         std::string("Int32"));
  this->addSpecification(eSatOverride1, std::string("CR12_SatOverride1"),
                         std::string("Int32"));
  this->addSpecification(eBcidDecision2, std::string("CR13_BcidDecision2"),
                         std::string("Int32"));
  this->addSpecification(eSatOverride2, std::string("CR13_SatOverride2"),
                         std::string("Int32"));
  this->addSpecification(eBcidDecision3, std::string("CR14_BcidDecision3"),
                         std::string("Int32"));
  this->addSpecification(eSatOverride3, std::string("CR14_SatOverride3"),
                         std::string("Int32"));
  this->addSpecification(ePeakFinderCond, std::string("CR15_PeakFinderCond"),
                         std::string("Int32"));
  this->addSpecification(eDecisionSource, std::string("CR15_DecisionSource"),
                         std::string("Int32"));
 
  // ------------------------------------------------------------------------------------------------------------------
  // Common
  // ------------------------------------------------------------------------------------------------------------------
  // Define DB rows names and types in order to construct the
  // AttributeListSpecification object
  this->addSpecification(eExtBcidThreshold, std::string("ExtBcidThreshold"),
                         std::string("UInt16"));
  this->addSpecification(eSatBcidThreshLow, std::string("SatBcidThreshLow"),
                         std::string("UInt16"));
  this->addSpecification(eSatBcidThreshHigh, std::string("SatBcidThreshHigh"),
                         std::string("UInt16"));
  this->addSpecification(eSatBcidLevel, std::string("SatBcidLevel"),
                         std::string("UInt16"));
  this->addSpecification(eBcidEnergyRangeLow, std::string("BcidEnergyRangeLow"),
                         std::string("UInt16"));
  this->addSpecification(eBcidEnergyRangeHigh,
                         std::string("BcidEnergyRangeHigh"),
                         std::string("UInt16"));
 
  this->addSpecification(ePedValue, std::string("PedValue"),
                         std::string("UInt32"));
  this->addSpecification(ePedMean, std::string("PedMean"),
                         std::string("Double"));
 
  this->addSpecification(eLutCpStrategy, std::string("LutCpStrategy"),
                         std::string("UInt16"));
 
  this->addSpecification(eLutCpScale, std::string("LutCpScale"),
                         std::string("UInt16"));
  this->addSpecification(eLutCpPar1, std::string("LutCpPar1"),
                         std::string("UInt16"));
  this->addSpecification(eLutCpPar2, std::string("LutCpPar2"),
                         std::string("UInt16"));
  this->addSpecification(eLutCpPar3, std::string("LutCpPar3"),
                         std::string("UInt16"));
  this->addSpecification(eLutCpPar4, std::string("LutCpPar4"),
                         std::string("UInt16"));
 
  this->addSpecification(eLutJepStrategy, std::string("LutJepStrategy"),
                         std::string("UInt16"));
 
  this->addSpecification(eLutJepScale, std::string("LutJepScale"),
                         std::string("UInt16"));
  this->addSpecification(eLutJepPar1, std::string("LutJepPar1"),
                         std::string("UInt16"));
  this->addSpecification(eLutJepPar2, std::string("LutJepPar2"),
                         std::string("UInt16"));
  this->addSpecification(eLutJepPar3, std::string("LutJepPar3"),
                         std::string("UInt16"));
  this->addSpecification(eLutJepPar4, std::string("LutJepPar4"),
                         std::string("UInt16"));
 
  // Missing attributes in model with strategy
  this->addSpecification(ePedFirSum, std::string("PedFirSum"),
                         std::string("UInt32"));
  this->addSpecification(eLutCpOffset, std::string("LutCpOffset"),
                         std::string("UInt16"));
  this->addSpecification(eLutJepOffset, std::string("LutJepOffset"),
                         std::string("UInt16"));
  // ------------------------------------------------------------------------------------------------------------------
  // Strategy
  // ------------------------------------------------------------------------------------------------------------------
  this->addSpecification(eFirStartBit, std::string("FirStartBit"),
                         std::string("UInt16"));
  this->addSpecification(eFirCoeff1, std::string("FirCoeff1"),
                         std::string("short"));
  this->addSpecification(eFirCoeff2, std::string("FirCoeff2"),
                         std::string("short"));
  this->addSpecification(eFirCoeff3, std::string("FirCoeff3"),
                         std::string("short"));
  this->addSpecification(eFirCoeff4, std::string("FirCoeff4"),
                         std::string("short"));
  this->addSpecification(eFirCoeff5, std::string("FirCoeff5"),
                         std::string("short"));
  this->addSpecification(eLutCpNoiseCut, std::string("LutCpNoiseCut"),
                         std::string("UInt16"));
  this->addSpecification(eLutCpSlope, std::string("LutCpSlope"),
                         std::string("UInt16"));
  this->addSpecification(eLutJepNoiseCut, std::string("LutJepNoiseCut"),
                         std::string("UInt16"));
  this->addSpecification(eLutJepSlope, std::string("LutJepSlope"),
                         std::string("UInt16"));
  // ------------------------------------------------------------------------------------------------------------------
 
  m_pprConditionsVec.reserve(s_vectorSize);
  this->clear();
}

L1CaloPprConditionsContainerRun2() [2/2]

L1CaloPprConditionsContainerRun2::L1CaloPprConditionsContainerRun2

(

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

folderKeysMap

)

Definition at line 129 of file L1CaloPprConditionsContainerRun2.cxx.

    : L1CaloPprConditionsContainerRun2()  // delegating constructor
{
  m_coolFoldersKeysMap = folderKeysMap;
}

~L1CaloPprConditionsContainerRun2()

L1CaloPprConditionsContainerRun2::~L1CaloPprConditionsContainerRun2 ( )

virtual

Definition at line 137 of file L1CaloPprConditionsContainerRun2.cxx.

                                                                    {
  this->clear();
}

Member Function Documentation

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

bcidDecision1()

int L1CaloPprConditionsContainerRun2::bcidDecision1 ( ) const

inline

Definition at line 59 of file L1CaloPprConditionsContainerRun2.h.

{ return m_bcidDecision1; }

bcidDecision2()

int L1CaloPprConditionsContainerRun2::bcidDecision2 ( ) const

inline

Definition at line 61 of file L1CaloPprConditionsContainerRun2.h.

{ return m_bcidDecision2; }

bcidDecision3()

int L1CaloPprConditionsContainerRun2::bcidDecision3 ( ) const

inline

Definition at line 63 of file L1CaloPprConditionsContainerRun2.h.

{ return m_bcidDecision3; }

clear()

void L1CaloPprConditionsContainerRun2::clear ( )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 523 of file L1CaloPprConditionsContainerRun2.cxx.

                                             {
  for (L1CaloPprConditionsRun2* p : m_pprConditionsVec) {
    if (p) delete p;
  }
  m_pprConditionsVec.assign(s_vectorSize, nullptr);
}

conditionType()

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

inlinevirtualinherited

Implements IL1CaloPersistenceCapable.

Definition at line 37 of file AbstractL1CaloPersistentCondition.h.

{ return m_strConditionType; };

coolFolderKey()

std::string L1CaloPprConditionsContainerRun2::coolFolderKey ( L1CaloPprConditionsContainerRun2::eCoolFolders  efolder ) const

private

Definition at line 141 of file L1CaloPprConditionsContainerRun2.cxx.

                                                                {
  auto it = m_coolFoldersKeysMap.find(efolder);
  if (it != m_coolFoldersKeysMap.end()) {
    return it->second;
  } else {
    return std::string("");
  }
}

coolInputKeys()

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

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 151 of file L1CaloPprConditionsContainerRun2.cxx.

          {
  std::vector<std::string> result{
      this->coolFolderKey(L1CaloPprConditionsContainerRun2::ePprChanDefaults)};
  std::string calibKey =
      this->coolFolderKey(L1CaloPprConditionsContainerRun2::ePprChanCalib);
 
  if (!calibKey.empty()) {
    result.push_back(calibKey);
  } else {
    result.push_back(this->coolFolderKey(
        L1CaloPprConditionsContainerRun2::ePprChanCalibCommon));
    result.push_back(this->coolFolderKey(
        L1CaloPprConditionsContainerRun2::ePprChanCalibStrategy));
  }
 
  return result;
}

coolOutputKey()

std::string L1CaloPprConditionsContainerRun2::coolOutputKey ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 170 of file L1CaloPprConditionsContainerRun2.cxx.

                                                                {
  return this->coolFolderKey(L1CaloPprConditionsContainerRun2::ePprChanCalib);
}

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

decisionSource()

int L1CaloPprConditionsContainerRun2::decisionSource ( ) const

inline

Definition at line 66 of file L1CaloPprConditionsContainerRun2.h.

{ return m_decisionSource; }

dump()

void L1CaloPprConditionsContainerRun2::dump

(

)

const

Definition at line 508 of file L1CaloPprConditionsContainerRun2.cxx.

                                                  {
  std::cout << "bcidDecision1: " << m_bcidDecision1 << ", "
            << "satOverride1: " << m_satOverride1 << ", "
            << "bcidDecision2: " << m_bcidDecision2 << ", "
            << "satOverride2: " << m_satOverride2 << ", "
            << "bcidDecision3: " << m_bcidDecision3 << ", "
            << "satOverride3: " << m_satOverride3 << ", "
            << "peakFinderCond: " << m_peakFinderCond << ", "
            << "decisionSource: " << m_decisionSource << std::endl;
  std::size_t index(0);
  for (auto* C : m_pprConditionsVec) {
    if (C) std::cout << "index " << index++ << " * item: " << *C << std::endl;
  }
}

makePersistent()

DataObject * L1CaloPprConditionsContainerRun2::makePersistent ( ) const

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 174 of file L1CaloPprConditionsContainerRun2.cxx.

                                                                   {
  // this container is not supposed to be saved to COOL
  return 0;
}

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 L1CaloPprConditionsContainerRun2::makeTransient ( const std::map< std::string, const CondAttrListCollection * > &  condAttrListCollectionMap )

virtual

Reimplemented from AbstractL1CaloPersistentCondition.

Definition at line 179 of file L1CaloPprConditionsContainerRun2.cxx.

                                                                                                                                      {
  this->clear();
  // --------------------------------------------------------------------------
  // Folder names
  std::string chanCalibFolderKey;
  std::string chanCalibCommonFolderKey;
  std::string chanCalibStrategyFolderKey;
  std::string chanDefaultsFolderKey; 
 
  // cppcheck-suppress duplicateAssignExpression
  auto it_pprChanCalibAttrListCollection = condAttrListCollectionMap.end();
  
  auto it_pprChanCalibStrategyAttrListCollection = condAttrListCollectionMap.end();
 
  // --------------------------------------------------------------------------
  
  if (condAttrListCollectionMap.empty()) return;
 
  // Reading cool paths
  for (const auto& [name, coll] : condAttrListCollectionMap) {
    if (name.find("PprChanDefaults")!=std::string::npos){
      chanDefaultsFolderKey=name;}
    if(name.find("PprChanCalib")!=std::string::npos){
      chanCalibFolderKey=name;
    }
    if(name.find("PprChanCommon")!=std::string::npos){
      chanCalibCommonFolderKey=name;
    }
    if(name.find("Mu")!=std::string::npos){
      chanCalibStrategyFolderKey=name;
    }
  }
    
 
  // Check that folders exist
  bool isUseStrategy = false;
  if (!chanCalibFolderKey.empty()) {
    it_pprChanCalibAttrListCollection =
      condAttrListCollectionMap.find(chanCalibFolderKey);
  }
  else {
    isUseStrategy = true;
    it_pprChanCalibAttrListCollection =    condAttrListCollectionMap.find(chanCalibCommonFolderKey);
    it_pprChanCalibStrategyAttrListCollection = condAttrListCollectionMap.find(chanCalibStrategyFolderKey);
  }
    
 
 
  
  // --------------------------------------------------------------------------
  if (isUseStrategy) {
    // Check that strategy folder exists
    if (it_pprChanCalibStrategyAttrListCollection ==
        condAttrListCollectionMap.end()) {
      std::cout << "L1CaloPprConditionsContainerRun2 : Could not find "
                   "requested CondAttrListCollection"
                << chanCalibStrategyFolderKey << std::endl;
      return;
    }
 
    // Check that common folder exists
    if (it_pprChanCalibAttrListCollection == condAttrListCollectionMap.end()) {
      std::cout << "L1CaloPprConditionsContainerRun2 : Could not find "
                   "requested CondAttrListCollection "
                << chanCalibCommonFolderKey << std::endl;
      return;
    }
  } else{
    if (it_pprChanCalibAttrListCollection == condAttrListCollectionMap.end()) {
      std::cout << "L1CaloPprConditionsContainerRun2 : Could not find "
                   "requested CondAttrListCollection"
                << chanCalibCommonFolderKey << std::endl;
      return;
    }
  }
  // --------------------------------------------------------------------------
  const CondAttrListCollection* chanCalibAttrListCollection =
      it_pprChanCalibAttrListCollection->second;
 
 
  auto it_pprChanDefaultsAttrListCollection =
      condAttrListCollectionMap.find(chanDefaultsFolderKey);
  if (it_pprChanDefaultsAttrListCollection == condAttrListCollectionMap.end()) {
    std::cout << "L1CaloPprConditionsContainerRun2 : Could not find requested "
                 "CondAttrListCollection" << chanDefaultsFolderKey
              << std::endl;
    return;
  }
  // --------------------------------------------------------------------------
  const CondAttrListCollection* chanDefaultsAttrListCollection =
      it_pprChanDefaultsAttrListCollection->second;
 
  // There should be only one channel (channel#1 in data, #0 in MC) in the Default folder
  const coral::AttributeList& chanDefaultAttrList = std::cbegin(*chanDefaultsAttrListCollection)->second;
 
  m_bcidDecision1 =
      chanDefaultAttrList[this->specificationName(eBcidDecision1)].data<int>();
  m_satOverride1 =
      chanDefaultAttrList[this->specificationName(eSatOverride1)].data<int>();
  m_bcidDecision2 =
      chanDefaultAttrList[this->specificationName(eBcidDecision2)].data<int>();
  m_satOverride2 =
      chanDefaultAttrList[this->specificationName(eSatOverride2)].data<int>();
  m_bcidDecision3 =
      chanDefaultAttrList[this->specificationName(eBcidDecision3)].data<int>();
  m_satOverride3 =
      chanDefaultAttrList[this->specificationName(eSatOverride3)].data<int>();
  m_peakFinderCond =
      chanDefaultAttrList[this->specificationName(ePeakFinderCond)].data<int>();
  m_decisionSource =
      chanDefaultAttrList[this->specificationName(eDecisionSource)].data<int>();
  // ------------------------------------------------------------------------
  // loop over CondAttrListCollection
  auto it_AttrListColl = chanCalibAttrListCollection->begin();
  auto it_AttrListCollE = chanCalibAttrListCollection->end();
  // --------------------------------------------------------------------------
  for (; it_AttrListColl != it_AttrListCollE; ++it_AttrListColl) {
    // ------------------------------------------------------------------------
    L1CaloCoolChannelId coolId(it_AttrListColl->first);
    unsigned int index = (coolId.crate() << 10) + (coolId.module() << 6) +
                         (coolId.subModule() << 2) + coolId.channel();
    // ------------------------------------------------------------------------                     
    if (index >= s_vectorSize) {
      continue;
    }
    // ------------------------------------------------------------------------
    const coral::AttributeList& chanCalibAttrList(it_AttrListColl->second);
    // ------------------------------------------------------------------------
    unsigned short extBcidThreshold =
        chanCalibAttrList[this->specificationName(eExtBcidThreshold)]
            .data<unsigned short>();
    unsigned short satBcidThreshLow =
        chanCalibAttrList[this->specificationName(eSatBcidThreshLow)]
            .data<unsigned short>();
    unsigned short satBcidThreshHigh =
        chanCalibAttrList[this->specificationName(eSatBcidThreshHigh)]
            .data<unsigned short>();
    unsigned short satBcidLevel =
        chanCalibAttrList[this->specificationName(eSatBcidLevel)]
            .data<unsigned short>();
 
    unsigned short bcidEnergyRangeLow =
        chanCalibAttrList[this->specificationName(eBcidEnergyRangeLow)]
            .data<unsigned short>();
    unsigned short bcidEnergyRangeHigh =
        chanCalibAttrList[this->specificationName(eBcidEnergyRangeHigh)]
            .data<unsigned short>();
    unsigned short lutCpStrategy =
        chanCalibAttrList[this->specificationName(eLutCpStrategy)]
            .data<unsigned short>();
 
    short lutCpPar1 =
        chanCalibAttrList[this->specificationName(eLutCpPar1)].data<short>();
    short lutCpPar2 =
        chanCalibAttrList[this->specificationName(eLutCpPar2)].data<short>();
    short lutCpPar3 =
        chanCalibAttrList[this->specificationName(eLutCpPar3)].data<short>();
    short lutCpPar4 =
        chanCalibAttrList[this->specificationName(eLutCpPar4)].data<short>();
    unsigned short lutJepStrategy =
        chanCalibAttrList[this->specificationName(eLutJepStrategy)]
            .data<unsigned short>();
 
    unsigned short lutCpScale =
        chanCalibAttrList[this->specificationName(eLutCpScale)]
            .data<unsigned short>();
    unsigned short lutJepScale =
        chanCalibAttrList[this->specificationName(eLutJepScale)]
            .data<unsigned short>();
    short lutJepPar1 =
        chanCalibAttrList[this->specificationName(eLutJepPar1)].data<short>();
    short lutJepPar2 =
        chanCalibAttrList[this->specificationName(eLutJepPar2)].data<short>();
    short lutJepPar3 =
        chanCalibAttrList[this->specificationName(eLutJepPar3)].data<short>();
    short lutJepPar4 =
        chanCalibAttrList[this->specificationName(eLutJepPar4)].data<short>();
    unsigned int pedValue =
        chanCalibAttrList[this->specificationName(ePedValue)]
            .data<unsigned int>();
    float pedMean =
        (float)
        chanCalibAttrList[this->specificationName(ePedMean)].data<double>();
 
    unsigned short lutJepOffset =
        isUseStrategy
            ? 0
            : chanCalibAttrList[this->specificationName(eLutJepOffset)]
                  .data<unsigned short>();
    unsigned short lutCpOffset =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eLutCpOffset)]
                            .data<unsigned short>();
    unsigned int pedFirSum =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(ePedFirSum)]
                            .data<unsigned int>();
 
    unsigned short firStartBit =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eFirStartBit)]
                            .data<unsigned short>();
    short int firCoeff1 =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eFirCoeff1)]
                            .data<short>();
    short int firCoeff2 =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eFirCoeff2)]
                            .data<short>();
    short int firCoeff3 =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eFirCoeff3)]
                            .data<short>();
    short int firCoeff4 =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eFirCoeff4)]
                            .data<short>();
    short int firCoeff5 =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eFirCoeff5)]
                            .data<short>();
 
    unsigned short lutCpSlope =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eLutCpSlope)]
                            .data<unsigned short>();
    unsigned short lutCpNoiseCut =
        isUseStrategy
            ? 0
            : chanCalibAttrList[this->specificationName(eLutCpNoiseCut)]
                  .data<unsigned short>();
    unsigned short lutJepSlope =
        isUseStrategy ? 0
                      : chanCalibAttrList[this->specificationName(eLutJepSlope)]
                            .data<unsigned short>();
    unsigned short lutJepNoiseCut =
        isUseStrategy
            ? 0
            : chanCalibAttrList[this->specificationName(eLutJepNoiseCut)]
                  .data<unsigned short>();
    // ------------------------------------------------------------------------
    m_pprConditionsVec[index] = new L1CaloPprConditionsRun2(
        extBcidThreshold, satBcidThreshLow, satBcidThreshHigh, satBcidLevel,
        bcidEnergyRangeLow, bcidEnergyRangeHigh, firStartBit, firCoeff1,
        firCoeff2, firCoeff3, firCoeff4, firCoeff5, lutCpStrategy, lutCpOffset,
        lutCpSlope, lutCpNoiseCut, lutCpPar1, lutCpPar2, lutCpPar3, lutCpPar4,
        lutCpScale, lutJepStrategy, lutJepOffset, lutJepSlope, lutJepNoiseCut,
        lutJepPar1, lutJepPar2, lutJepPar3, lutJepPar4, lutJepScale, pedValue,
        pedMean, pedFirSum);
  }
  // --------------------------------------------------------------------------
  if (isUseStrategy){
    // ------------------------------------------------------------------------
    const CondAttrListCollection* chanCalibAttrListCollection =
      it_pprChanCalibStrategyAttrListCollection->second; 
    auto it_AttrListColl = chanCalibAttrListCollection->begin();
    auto it_AttrListCollE = chanCalibAttrListCollection->end();
    // ------------------------------------------------------------------------
    for (; it_AttrListColl != it_AttrListCollE; ++it_AttrListColl) {
      L1CaloCoolChannelId coolId(it_AttrListColl->first);
      unsigned int index = (coolId.crate() << 10) + (coolId.module() << 6) +
                           (coolId.subModule() << 2) + coolId.channel();
 
      if (index >= s_vectorSize) {
        continue;
      }
 
      const coral::AttributeList& chanCalibAttrList(it_AttrListColl->second);
 
      if (m_pprConditionsVec[index] == nullptr){
          std::cout << "L1CaloPprConditionsContainerRun2 : Could not find channel "
                 << " with index " << index << std::endl;
          return;
      }
 
      unsigned short firStartBit =
          chanCalibAttrList[this->specificationName(eFirStartBit)]
              .data<unsigned short>();
      short int firCoeff1 =
          chanCalibAttrList[this->specificationName(eFirCoeff1)].data<short>();
      short int firCoeff2 =
          chanCalibAttrList[this->specificationName(eFirCoeff2)].data<short>();
      short int firCoeff3 =
          chanCalibAttrList[this->specificationName(eFirCoeff3)].data<short>();
      short int firCoeff4 =
          chanCalibAttrList[this->specificationName(eFirCoeff4)].data<short>();
      short int firCoeff5 =
          chanCalibAttrList[this->specificationName(eFirCoeff5)].data<short>();
 
      unsigned short lutCpSlope =
          chanCalibAttrList[this->specificationName(eLutCpSlope)]
              .data<unsigned short>();
      unsigned short lutCpNoiseCut =
          chanCalibAttrList[this->specificationName(eLutCpNoiseCut)]
              .data<unsigned short>();
      unsigned short lutJepSlope =
          chanCalibAttrList[this->specificationName(eLutJepSlope)]
              .data<unsigned short>();
      unsigned short lutJepNoiseCut =
          chanCalibAttrList[this->specificationName(eLutJepNoiseCut)]
              .data<unsigned short>();
      m_pprConditionsVec[index]->initializeByStrategy(
          firStartBit, firCoeff1, firCoeff2, firCoeff3, firCoeff4, firCoeff5,
          lutCpSlope, lutCpNoiseCut, lutJepSlope, lutJepNoiseCut);
 
    } // end for
    // ------------------------------------------------------------------------
  } // end isUseStrategy
  // --------------------------------------------------------------------------
 
}

peakFinderCond()

int L1CaloPprConditionsContainerRun2::peakFinderCond ( ) const

inline

Definition at line 65 of file L1CaloPprConditionsContainerRun2.h.

{ return m_peakFinderCond; }

pprConditions() [1/2]

const L1CaloPprConditionsRun2 * L1CaloPprConditionsContainerRun2::pprConditions

(

const L1CaloCoolChannelId &

channelId

)

const

Definition at line 498 of file L1CaloPprConditionsContainerRun2.cxx.

                                                {
  unsigned int index = (channelId.crate() << 10) + (channelId.module() << 6) +
                       (channelId.subModule() << 2) + channelId.channel();
  if (index < s_vectorSize)
    return m_pprConditionsVec[index];
  else
    return 0;
}

pprConditions() [2/2]

const L1CaloPprConditionsRun2 * L1CaloPprConditionsContainerRun2::pprConditions

(

unsigned int

channelId

)

const

Definition at line 492 of file L1CaloPprConditionsContainerRun2.cxx.

                                  {
  L1CaloCoolChannelId coolId(channelId);
  return pprConditions(coolId);
}

satOverride1()

int L1CaloPprConditionsContainerRun2::satOverride1 ( ) const

inline

Definition at line 60 of file L1CaloPprConditionsContainerRun2.h.

{ return m_satOverride1; }

satOverride2()

int L1CaloPprConditionsContainerRun2::satOverride2 ( ) const

inline

Definition at line 62 of file L1CaloPprConditionsContainerRun2.h.

{ return m_satOverride2; }

satOverride3()

int L1CaloPprConditionsContainerRun2::satOverride3 ( ) const

inline

Definition at line 64 of file L1CaloPprConditionsContainerRun2.h.

{ return m_satOverride3; }

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_bcidDecision1

int L1CaloPprConditionsContainerRun2::m_bcidDecision1 = 0

private

Definition at line 83 of file L1CaloPprConditionsContainerRun2.h.

m_bcidDecision2

int L1CaloPprConditionsContainerRun2::m_bcidDecision2 = 0

private

Definition at line 85 of file L1CaloPprConditionsContainerRun2.h.

m_bcidDecision3

int L1CaloPprConditionsContainerRun2::m_bcidDecision3 = 0

private

Definition at line 87 of file L1CaloPprConditionsContainerRun2.h.

m_coolFoldersKeysMap

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

private

Definition at line 81 of file L1CaloPprConditionsContainerRun2.h.

m_decisionSource

int L1CaloPprConditionsContainerRun2::m_decisionSource = 0

private

Definition at line 90 of file L1CaloPprConditionsContainerRun2.h.

m_peakFinderCond

int L1CaloPprConditionsContainerRun2::m_peakFinderCond = 0

private

Definition at line 89 of file L1CaloPprConditionsContainerRun2.h.

m_pprConditionsVec

L1CaloPprConditionsVec L1CaloPprConditionsContainerRun2::m_pprConditionsVec

private

Definition at line 79 of file L1CaloPprConditionsContainerRun2.h.

m_satOverride1

int L1CaloPprConditionsContainerRun2::m_satOverride1 = 0

private

Definition at line 84 of file L1CaloPprConditionsContainerRun2.h.

m_satOverride2

int L1CaloPprConditionsContainerRun2::m_satOverride2 = 0

private

Definition at line 86 of file L1CaloPprConditionsContainerRun2.h.

m_satOverride3

int L1CaloPprConditionsContainerRun2::m_satOverride3 = 0

private

Definition at line 88 of file L1CaloPprConditionsContainerRun2.h.

m_strConditionType

std::string AbstractL1CaloPersistentCondition::m_strConditionType

privateinherited

Definition at line 53 of file AbstractL1CaloPersistentCondition.h.

s_vectorSize

const unsigned int L1CaloPprConditionsContainerRun2::s_vectorSize = 8192

staticprivate

Definition at line 92 of file L1CaloPprConditionsContainerRun2.h.

---

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

• L1CaloPprConditionsContainerRun2.h
• L1CaloPprConditionsContainerRun2.cxx