LArConditionsContainerBase Class Reference

This is a non-template implementation base class for LArConditionsContainer. More...

#include <LArConditionsContainerBase.h>

Collaboration diagram for LArConditionsContainerBase:

Public Types
enum	GroupingType {   Unknown = 0, SingleGroup, SubDetectorGrouping, FeedThroughGrouping,   ExtendedFTGrouping, ExtendedSubDetGrouping, SuperCells }
	Grouping type. More...
typedef LArCondFEBIdChanMap::FEBIdVector	FEBIdVector

Public Member Functions
	LArConditionsContainerBase ()
	Default constructor. More...
	LArConditionsContainerBase (GroupingType type)
	constructor defining grouping type More...
virtual	~LArConditionsContainerBase ()
	destructor More...
StatusCode	initializeBase ()
	initialize More...
void	setGroupingType (GroupingType type)
	allow group type to be set externally - need to (re)initialize after setting grouping type More...
StatusCode	setGroupingType (const std::string &groupingStr, MsgStream &logStr)
	allow group type to be set externally based on a string returns an FAILURE and a message to logStr if unknown string is supplied More...
const LArOnlineID_Base *	onlineHelper () const
	provide access to online id helper More...
const CaloCell_Base_ID *	offlineHelper () const
	provide access to offline id helper More...
const FEBIdVector &	febIdVector (unsigned int gain, unsigned int coolChannel) const
	Access to a FEB ID vector for a given gain and COOL channel. More...

Static Public Member Functions
static bool	applyCorrectionsAtInit (bool setFlag=false, bool flag=true)
	provide access to flag which determines corrections are applied at initialize, i.e. More...

Protected Member Functions
StatusCode	initGrouping ()
std::string	groupingTypeToString () const
void	correctionIndexAndCoolChannel (HWIdentifier id, unsigned int gain, unsigned int &index, unsigned int &coolChannel)

Protected Attributes
GroupingType	m_groupType
LArCondFEBIdChanMap	m_febIdChanMap
const LArOnlineID_Base *	m_onlineHelper
const CaloCell_Base_ID *	m_offlineHelper
std::vector< unsigned int >	m_channelToMultChanCollIndex
bool	m_isInitialized

Detailed Description

This is a non-template implementation base class for LArConditionsContainer.

This class contains implementation details in a non-template form allowing it code to be compiled into a library.

Definition at line 39 of file LArConditionsContainerBase.h.

Member Typedef Documentation

FEBIdVector

typedef LArCondFEBIdChanMap::FEBIdVector LArConditionsContainerBase::FEBIdVector

Definition at line 54 of file LArConditionsContainerBase.h.

Member Enumeration Documentation

GroupingType

enum LArConditionsContainerBase::GroupingType

Grouping type.

Enumerator
Unknown
SingleGroup
SubDetectorGrouping
FeedThroughGrouping
ExtendedFTGrouping
ExtendedSubDetGrouping
SuperCells

Definition at line 44 of file LArConditionsContainerBase.h.

                      {
        Unknown      = 0,
    SingleGroup,
    SubDetectorGrouping,
    FeedThroughGrouping,
    ExtendedFTGrouping,
    ExtendedSubDetGrouping,
    SuperCells
    };

Constructor & Destructor Documentation

LArConditionsContainerBase() [1/2]

LArConditionsContainerBase::LArConditionsContainerBase

(

)

Default constructor.

Definition at line 33 of file LArConditionsContainerBase.cxx.

    :
    m_groupType(SubDetectorGrouping),
    m_onlineHelper(nullptr),
    m_offlineHelper(nullptr),
    m_isInitialized(false)
{}

LArConditionsContainerBase() [2/2]

LArConditionsContainerBase::LArConditionsContainerBase

(

GroupingType

type

)

constructor defining grouping type

Definition at line 41 of file LArConditionsContainerBase.cxx.

    :
    m_groupType(type),
    m_onlineHelper(nullptr),
    m_offlineHelper(nullptr),
    m_isInitialized(false)
{}

~LArConditionsContainerBase()

LArConditionsContainerBase::~LArConditionsContainerBase ( )

virtual

destructor

Definition at line 50 of file LArConditionsContainerBase.cxx.

{}

Member Function Documentation

applyCorrectionsAtInit()

bool LArConditionsContainerBase::applyCorrectionsAtInit ( bool  setFlag = false, bool  flag = true  )

static

provide access to flag which determines corrections are applied at initialize, i.e.

when conditions are read in. Default is true. This is a class (static) variable which applied to ALL conditions in a job! If one wants to change the value of the flag, pass in arguments:

Definition at line 603 of file LArConditionsContainerBase.cxx.

{
    // If setFlag is true, change the value of static flag, otherwise
    // return current value
 
    // Default value is true
    static std::atomic<bool> applyCorrs = true;
    
    if (setFlag) applyCorrs = flag;
    
    return (applyCorrs);
}

correctionIndexAndCoolChannel()

void LArConditionsContainerBase::correctionIndexAndCoolChannel ( HWIdentifier  id, unsigned int  gain, unsigned int &  index, unsigned int &  coolChannel  )

protected

Definition at line 539 of file LArConditionsContainerBase.cxx.

{
    MsgStream log(Athena::getMessageSvc(), "LArConditionsContainerBase");
 
    index       = 9999;
    coolChannel = 0;
    // First get cool channel number
    if (!m_onlineHelper) {
        log << MSG::ERROR << "correctionIndex> Could not get online id helper!" << endmsg;
        return;
    }
 
    int p_n  = m_onlineHelper->pos_neg(id);
    if (m_onlineHelper->isEMBPS(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::PSBA;  // PS Barrel
        else     coolChannel = LArCondFEBIdChanMap::PSBC;  // PS Barrel
    }
    else if (m_onlineHelper->isEMECPS(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::PSECA; // PS Endcap
        else     coolChannel = LArCondFEBIdChanMap::PSECC; // PS Endcap
    }
    else if (m_onlineHelper->isEMBchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::EMBA;  // EM Barrel
        else     coolChannel = LArCondFEBIdChanMap::EMBC;  // EM Barrel
    }
    else if (m_onlineHelper->isEMECchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::EMECA; // EM Endcap
        else     coolChannel = LArCondFEBIdChanMap::EMECC; // EM Endcap
    }
    else if (m_onlineHelper->isHECchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::HECA;  // HEC A
        else     coolChannel = LArCondFEBIdChanMap::HECC;  // HEC C
    }
    else if (m_onlineHelper->isFCALchannel(id)) {
        if (p_n) coolChannel = LArCondFEBIdChanMap::FCALA; // FCAL A
        else     coolChannel = LArCondFEBIdChanMap::FCALC; // FCAL C
    }
 
    if (!coolChannel) {
        log << MSG::ERROR << "correctionIndex> coolChannel not found! Online ids: " 
            << "  " << m_onlineHelper->show_to_string(id)
            << endmsg;
        return;
    }
 
    // add on offset for gain
    unsigned int gainOffset = (gain - m_febIdChanMap.minGain())*LArCondFEBIdChanMap::NCORRTYPE;
    coolChannel += gainOffset;
 
    // look up the index in the table
    if (coolChannel >= m_channelToMultChanCollIndex.size()) {
        log << MSG::ERROR << "correctionIndex> coolChannel larger than lookup table: chan, size " 
            << coolChannel << " " << m_channelToMultChanCollIndex.size()
            << endmsg;
    }
    else {
        index = m_channelToMultChanCollIndex[coolChannel];
    }
}

febIdVector()

const LArConditionsContainerBase::FEBIdVector & LArConditionsContainerBase::febIdVector	(	unsigned int	gain,
		unsigned int	coolChannel
	)		const

Access to a FEB ID vector for a given gain and COOL channel.

Definition at line 532 of file LArConditionsContainerBase.cxx.

{
    return (m_febIdChanMap.febIdVector(gain, coolChannel));
}

groupingTypeToString()

std::string LArConditionsContainerBase::groupingTypeToString ( ) const

protected

Definition at line 496 of file LArConditionsContainerBase.cxx.

{
    // Return grouping type in string form
    switch (m_groupType){
    case 0:
        return ("Unknown");
    case 1:
        return ("SingleGroup");
    case 2:
        return ("SubDetectorGrouping");
        case 3:
        return ("FeedThroughGrouping");
        case 4:
        return ("ExtendedFTGrouping");
        case 5:
        return ("ExtendedSubDetGrouping");
        case 6:
            return ("SuperCells");
    }
    return ("Unknown");
}

initGrouping()

StatusCode LArConditionsContainerBase::initGrouping ( )

protected

Definition at line 169 of file LArConditionsContainerBase.cxx.

{
    MsgStream log(Athena::getMessageSvc(), "LArConditionsContainerBase");
    log << MSG::DEBUG << "initGrouping "<< endmsg;
 
    // We allow for different groupings
 
    if (Unknown == m_groupType) {
    log << MSG::ERROR << "Unknown grouping "<< endmsg;
 
    // Not yet known
    }
    if (SingleGroup == m_groupType || SuperCells == m_groupType) {
 
    log << MSG::DEBUG << "Single group "<< endmsg;
 
    // Only one group - add all feb ids to channel 0
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
    LArCondFEBIdChanMap::FEBIdVector febIds; 
    for (; febIt != febEnd; ++febIt) {
        febIds.push_back((*febIt).get_identifier32().get_compact());
    }
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = 1;
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
    m_febIdChanMap.addFEBIdVector(0, febIds);
    }
    else if (SubDetectorGrouping == m_groupType) {
 
    log << MSG::DEBUG << "Subdetector  grouping "<< endmsg;
 
    // Set up LArCondFEBIdChanMap for four groups: EM barrel, EMEM, HEC, FCal 
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
    LArCondFEBIdChanMap::FEBIdVector emBarrel; 
    LArCondFEBIdChanMap::FEBIdVector emEndcap; 
    LArCondFEBIdChanMap::FEBIdVector hec; 
    LArCondFEBIdChanMap::FEBIdVector fcal; 
 
    for (; febIt != febEnd; ++febIt) {
            unsigned int febId = (*febIt).get_identifier32().get_compact();
        if (m_onlineHelper->isEMBchannel(*febIt)) {
        emBarrel.push_back(febId);
        }
        else if (m_onlineHelper->isEMECchannel(*febIt)) {
        emEndcap.push_back(febId);
        }
        else if (m_onlineHelper->isHECchannel(*febIt)) {
        hec.push_back(febId);
        }
        else if (m_onlineHelper->isFCALchannel(*febIt)) {
        fcal.push_back(febId);
        }
        else {
            log << MSG::DEBUG << "Uassociated FEB id: "
            << MSG::hex << (febId) << MSG::dec 
            << " isCalib " << m_onlineHelper->isCalibration(*febIt)
            << "  " << m_onlineHelper->show_to_string(*febIt)
            << endmsg;
        }
    }
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = 4;
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
    m_febIdChanMap.addFEBIdVector(0, emBarrel);
    m_febIdChanMap.addFEBIdVector(1, emEndcap);
    m_febIdChanMap.addFEBIdVector(2, hec);
    m_febIdChanMap.addFEBIdVector(3, fcal);
 
//  unsigned int coolChannel;
//  for (unsigned int gain = 0; gain < nGains; ++gain) {
//      for (unsigned int i = 0; i < emBarrel.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(emBarrel[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for em barrel - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      for (unsigned int i = 0; i < emEndcap.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(emEndcap[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for em endcap - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      for (unsigned int i = 0; i < hec.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(hec[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for hec - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      for (unsigned int i = 0; i < fcal.size(); ++i) {
//      if (!m_febIdChanMap.getChannel(fcal[i], gain, coolChannel)) {
//          log << MSG::DEBUG << "Unable to get cool channel for fcal - i = "
//          << i << endmsg;
//          return (StatusCode::FAILURE);
//      }
//      }
//      }
    }
    else if (ExtendedSubDetGrouping == m_groupType) {
        log << MSG::DEBUG << "Extended Subdetector  grouping "<< endmsg;
 
    // Set up LArCondFEBIdChanMap for four groups: EM barrel, EM barrel PS ,EMEC EMEC PS, HEC, FCal 
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
    LArCondFEBIdChanMap::FEBIdVector emBarrel[2];
    LArCondFEBIdChanMap::FEBIdVector emBarrelPS[2];
    LArCondFEBIdChanMap::FEBIdVector emEndcap[2]; 
    LArCondFEBIdChanMap::FEBIdVector emEndcapPS[2]; 
    LArCondFEBIdChanMap::FEBIdVector hec[2]; 
    LArCondFEBIdChanMap::FEBIdVector fcal[2]; 
 
    for (; febIt != febEnd; ++febIt) {
            int iside = m_onlineHelper->pos_neg(*febIt);
            // Sanity check
            if(iside <0 || iside > 1) {
          log << MSG::ERROR << "Wrong side id: "<< iside <<" from: "  
          << MSG::hex << *febIt << MSG::dec << endmsg;
          return (StatusCode::FAILURE);
        }
            unsigned int febId = (*febIt).get_identifier32().get_compact();
        if (m_onlineHelper->isEMBPS(*febIt)) {
          emBarrelPS[iside].push_back(febId);
        }
        else if (m_onlineHelper->isEMECPS(*febIt)) {
          emEndcapPS[iside].push_back(febId);
        }
        else if (m_onlineHelper->isEMBchannel(*febIt)) {
          emBarrel[iside].push_back(febId);
        }
        else if (m_onlineHelper->isEMECchannel(*febIt)) {
          emEndcap[iside].push_back(febId);
        }
        else if (m_onlineHelper->isHECchannel(*febIt)) {
          hec[iside].push_back(febId);
        }
        else if (m_onlineHelper->isFCALchannel(*febIt)) {
          fcal[iside].push_back(febId);
        }
        else {
          log << MSG::DEBUG << "Uassociated FEB id: "
          << MSG::hex << (febId) << MSG::dec 
          << " isCalib " << m_onlineHelper->isCalibration(*febIt)
          << "  " << m_onlineHelper->show_to_string(*febIt)
          << endmsg;
        }
    }
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = 12;
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
        for (int iside=0; iside<2; ++iside) {
      m_febIdChanMap.addFEBIdVector(0+iside*6, emBarrel[iside]);
      m_febIdChanMap.addFEBIdVector(1+iside*6, emBarrelPS[iside]);
      m_febIdChanMap.addFEBIdVector(2+iside*6, emEndcap[iside]);
      m_febIdChanMap.addFEBIdVector(3+iside*6, emEndcapPS[iside]);
      m_febIdChanMap.addFEBIdVector(4+iside*6, hec[iside]);
      m_febIdChanMap.addFEBIdVector(5+iside*6, fcal[iside]);
        }
 
    }
    else if (FeedThroughGrouping == m_groupType) {
        log << MSG::DEBUG << "FeedThrough  grouping "<< endmsg;
 
        // Set up LArCondFEBIdChanMap for four groups: EM barrel, EMEM, HEC, FCal
        std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
        std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
        std::vector<LArCondFEBIdChanMap::FEBIdVector> ft(m_onlineHelper->feedthroughHashMax());
 
 
        for (; febIt != febEnd; ++febIt) {
            // Find the feedthru hash and add to vector
            HWIdentifier febId = (*febIt);
            int b_ec = m_onlineHelper->barrel_ec(febId);
            int p_n  = m_onlineHelper->pos_neg(febId);
            int f_t  = m_onlineHelper->feedthrough(febId);
            HWIdentifier ftid   = m_onlineHelper->feedthrough_Id(b_ec, p_n, f_t);
            IdentifierHash fthash = m_onlineHelper->feedthrough_Hash(ftid);
            if (fthash < ft.size()) {
                ft[fthash].push_back(febId.get_identifier32().get_compact());
            }
            else {
                log << MSG::ERROR << "Feedthru hash > channel map size: id, hash, size "
                    << MSG::hex << febId << MSG::dec << " "
                    << ftid << " " << ft.size()
                    << endmsg;
                return (StatusCode::FAILURE);
            }
        }
        // add for LArCondFEBIdChanMap
        unsigned int nChanPerGain = ft.size();
        unsigned int minGain      = 0;
        unsigned int nGains       = 3;
        m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
        for (unsigned int i = 0; i < ft.size(); ++i) {
            m_febIdChanMap.addFEBIdVector(i, ft[i]);
        }
    }
    else if (ExtendedFTGrouping == m_groupType) {
 
    log << MSG::DEBUG << "Extended FeedThrough  grouping (PS goes seperatly, EMEC in HEC as well)"<< endmsg;
 
    // Set up LArCondFEBIdChanMap for four groups: EM barrel, EMEM, HEC, FCal 
    std::vector<HWIdentifier>::const_iterator febIt  = m_onlineHelper->feb_begin();
    std::vector<HWIdentifier>::const_iterator febEnd = m_onlineHelper->feb_end();
 
    //Vectors of groups
    //Standard Febs (one group per FT)
    std::vector<LArCondFEBIdChanMap::FEBIdVector> ft(m_onlineHelper->feedthroughHashMax());
    //Presampler FEBs (one group per FT)
    std::vector<LArCondFEBIdChanMap::FEBIdVector> ftPS(m_onlineHelper->feedthroughHashMax());
    //EMEC channel in special crate:
    std::vector<LArCondFEBIdChanMap::FEBIdVector> ftSpecial(8); //How many are there?
 
    for (; febIt != febEnd; ++febIt) {
        // Find the feedthru hash and add to vector
        HWIdentifier febId = (*febIt);
        int b_ec = m_onlineHelper->barrel_ec(febId);
        int p_n  = m_onlineHelper->pos_neg(febId);
        int f_t  = m_onlineHelper->feedthrough(febId);
        HWIdentifier ftid   = m_onlineHelper->feedthrough_Id(b_ec, p_n, f_t);
        IdentifierHash fthash = m_onlineHelper->feedthrough_Hash(ftid);
 
        //sanity check
        if (fthash >= ft.size()) {
          log << MSG::ERROR << "Feedthru hash > channel map size: id, hash, size " 
          << MSG::hex << febId << MSG::dec << " "
          << ftid << " " << ft.size() 
          << endmsg;
          return (StatusCode::FAILURE);
        }
 
        //Subdivide into specific cases:
        if (!m_onlineHelper->isEMECinHECchannel(febId)) { //this is taken care of further down
          if (m_onlineHelper->isPS(febId))
        ftPS[fthash].push_back(febId.get_identifier32().get_compact());  //PS goes in separate channels
          else
        ft[fthash].push_back(febId.get_identifier32().get_compact());
        }
    }
    //EMEC in HEC crate: Do 'by hand'
    //FTs: 3,10,16,22 Slots: 1,2
    //parameters: ec,pn,ft,slot
    ftSpecial[0].push_back(m_onlineHelper->feb_Id(1,0,3,1).get_identifier32().get_compact()); 
    ftSpecial[0].push_back(m_onlineHelper->feb_Id(1,0,3,2).get_identifier32().get_compact()); 
 
    ftSpecial[1].push_back(m_onlineHelper->feb_Id(1,1,3,1).get_identifier32().get_compact()); 
    ftSpecial[1].push_back(m_onlineHelper->feb_Id(1,1,3,2).get_identifier32().get_compact()); 
        
    ftSpecial[2].push_back(m_onlineHelper->feb_Id(1,0,10,1).get_identifier32().get_compact()); 
    ftSpecial[2].push_back(m_onlineHelper->feb_Id(1,0,10,2).get_identifier32().get_compact()); 
 
    ftSpecial[3].push_back(m_onlineHelper->feb_Id(1,1,10,1).get_identifier32().get_compact()); 
    ftSpecial[3].push_back(m_onlineHelper->feb_Id(1,1,10,2).get_identifier32().get_compact()); 
 
    ftSpecial[4].push_back(m_onlineHelper->feb_Id(1,0,16,1).get_identifier32().get_compact()); 
    ftSpecial[4].push_back(m_onlineHelper->feb_Id(1,0,16,2).get_identifier32().get_compact()); 
 
    ftSpecial[5].push_back(m_onlineHelper->feb_Id(1,1,16,1).get_identifier32().get_compact()); 
    ftSpecial[5].push_back(m_onlineHelper->feb_Id(1,1,16,2).get_identifier32().get_compact()); 
 
    ftSpecial[6].push_back(m_onlineHelper->feb_Id(1,0,22,1).get_identifier32().get_compact()); 
    ftSpecial[6].push_back(m_onlineHelper->feb_Id(1,0,22,2).get_identifier32().get_compact()); 
 
    ftSpecial[7].push_back(m_onlineHelper->feb_Id(1,1,22,1).get_identifier32().get_compact()); 
    ftSpecial[7].push_back(m_onlineHelper->feb_Id(1,1,22,2).get_identifier32().get_compact()); 
 
 
    // add for LArCondFEBIdChanMap
    unsigned int nChanPerGain = ft.size()+ftPS.size()+ftSpecial.size();
    unsigned int minGain      = 0;
    unsigned int nGains       = 3;
    unsigned int iCoolChannel=0;
    m_febIdChanMap = LArCondFEBIdChanMap(nChanPerGain, minGain, nGains);
    for (unsigned int i = 0; i < ft.size(); ++i) {
        m_febIdChanMap.addFEBIdVector(iCoolChannel++, ft[i]);
    }
    for (unsigned int i = 0; i < ftPS.size(); ++i) {
        m_febIdChanMap.addFEBIdVector(iCoolChannel++, ftPS[i]);
    }
    for (unsigned int i = 0; i < ftSpecial.size(); ++i) {
        m_febIdChanMap.addFEBIdVector(iCoolChannel++, ftSpecial[i]);
    }
    } else {
      log << MSG::ERROR << "Unknown COOL Channel grouping " << m_groupType << endmsg;
      return StatusCode::FAILURE;
    }
    // Resize the vector mapping the COOL channel to the
    // DataVector. 
    m_channelToMultChanCollIndex = std::vector<unsigned int>(m_febIdChanMap.totalChannels(), 9999);
 
    log << MSG::DEBUG << "Number of channels per gain " 
    << m_febIdChanMap.channelsPerGain()
    << endmsg;
 
    log << MSG::DEBUG << "Mininum gain value          "
    << m_febIdChanMap.minGain() 
    << endmsg;
    
    log << MSG::DEBUG << "Number of gain values       "
    << m_febIdChanMap.nGains()
    << endmsg;
 
    log << MSG::DEBUG << "Number of offset channels   "
    << m_febIdChanMap.nOffsetChannels() 
    << endmsg;
 
    log << MSG::DEBUG << "Total number of channels    "
    << m_febIdChanMap.totalChannels()
    << endmsg;
 
    return (StatusCode::SUCCESS);
    
}

initializeBase()

StatusCode LArConditionsContainerBase::initializeBase

(

)

initialize

Definition at line 56 of file LArConditionsContainerBase.cxx.

{
    MsgStream log(Athena::getMessageSvc(), "LArConditionsContainerBase");
    log << MSG::DEBUG << "initializeBase "<< endmsg;
 
    if (m_isInitialized) {
    log << MSG::DEBUG << "already initialized - returning "<< endmsg;
    return (StatusCode::SUCCESS);
    }
 
    //Get LArOnlineID....
    ISvcLocator* svcLoc = Gaudi::svcLocator( );
    StoreGateSvc* detStore;
    StatusCode sc = svcLoc->service("DetectorStore",detStore);
    if (sc.isFailure()) {
    log << MSG::ERROR << "Cannot get DetectorStore!" << endmsg;
    return sc;
    }
 
    if (m_groupType == LArConditionsContainerBase::SuperCells) {
      //Dealing with supercells, need supercell identifier helper
      const LArOnline_SuperCellID* onlID = nullptr;
      sc = detStore->retrieve(onlID,"LArOnline_SuperCellID");
      if (sc.isFailure()) {
    log << MSG::ERROR << "Cannot get LArOnline_SuperCellID!" << endmsg;
    return sc;
      }
      m_onlineHelper=onlID;//cast to base-class
 
      const CaloCell_SuperCell_ID* oflID = nullptr;
      sc = detStore->retrieve(oflID,"CaloCell_SuperCell_ID");
      if (sc.isFailure()) {
    log << MSG::ERROR << "Cannot get CaloCell_SuperCell_ID!" << endmsg;
    return sc;
      }
      m_offlineHelper=oflID; //cast to base-class
    }
    else {
      //Regular readout
      const LArOnlineID* onlID = nullptr;
      sc = detStore->retrieve(onlID,"LArOnlineID");
      if (sc.isFailure()) {
    log << MSG::ERROR << "Cannot get LArOnlineID!" << endmsg;
    return sc;
      }
      m_onlineHelper=onlID;//cast to base-class
 
      const CaloCell_ID* oflID = nullptr;
      sc = detStore->retrieve(oflID,"CaloCell_ID");
      if (sc.isFailure()) {
    log << MSG::ERROR << "Cannot get CaloCell_ID!" << endmsg;
    return sc;
      }
      m_offlineHelper=oflID; //cast to base-class
    }
 
    // initialize the grouping
    sc = initGrouping();
    if (sc.isFailure()) {
    log << MSG::ERROR << "Cannot initialize the Grouping" << endmsg;
    return sc;
    }
 
    // Set initialized to true
    m_isInitialized = true;
    log << MSG::DEBUG << "end initializeBase " << endmsg;
 
    return (StatusCode::SUCCESS);
}

offlineHelper()

const CaloCell_Base_ID * LArConditionsContainerBase::offlineHelper

(

)

const

provide access to offline id helper

Definition at line 525 of file LArConditionsContainerBase.cxx.

{
    return (m_offlineHelper);
}

onlineHelper()

const LArOnlineID_Base * LArConditionsContainerBase::onlineHelper

(

)

const

provide access to online id helper

Definition at line 519 of file LArConditionsContainerBase.cxx.

{
    return (m_onlineHelper);
}

setGroupingType() [1/2]

StatusCode LArConditionsContainerBase::setGroupingType	(	const std::string &	groupingStr,
		MsgStream &	logStr
	)

allow group type to be set externally based on a string returns an FAILURE and a message to logStr if unknown string is supplied

Definition at line 134 of file LArConditionsContainerBase.cxx.

{
 // Set grouping type - default is SubDet
  if (groupingStr == "Single") 
    {setGroupingType(LArConditionsContainerBase:: SingleGroup);
     return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "SubDetector") 
    {setGroupingType(LArConditionsContainerBase:: SubDetectorGrouping);
     return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "ExtendedSubDetector") 
    {setGroupingType(LArConditionsContainerBase::ExtendedSubDetGrouping);
    return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "FeedThrough") 
    {setGroupingType(LArConditionsContainerBase:: FeedThroughGrouping);
     return StatusCode::SUCCESS;
    } 
  else if (groupingStr == "ExtendedFeedThrough") {
    setGroupingType(LArConditionsContainerBase:: ExtendedFTGrouping);
    return StatusCode::SUCCESS;
  }
  else if (groupingStr == "SuperCells") {
    setGroupingType(LArConditionsContainerBase::SuperCells);
    return StatusCode::SUCCESS;
  }
 
  logStr << MSG::ERROR << "Unknown COOL Channel Grouping '"<< groupingStr <<"'.  Allowed values are:" << endmsg;
  logStr << MSG::ERROR << "'Single','SubDetector', 'ExtendedSubDetector','FeedThrough','ExtendedFeedThrough'" << endmsg;
  return StatusCode::FAILURE;
}

setGroupingType() [2/2]

void LArConditionsContainerBase::setGroupingType

(

GroupingType

type

)

allow group type to be set externally - need to (re)initialize after setting grouping type

Definition at line 127 of file LArConditionsContainerBase.cxx.

{
    m_groupType = type;
}

Member Data Documentation

m_channelToMultChanCollIndex

std::vector<unsigned int> LArConditionsContainerBase::m_channelToMultChanCollIndex

protected

Definition at line 114 of file LArConditionsContainerBase.h.

m_febIdChanMap

LArCondFEBIdChanMap LArConditionsContainerBase::m_febIdChanMap

protected

Definition at line 108 of file LArConditionsContainerBase.h.

m_groupType

GroupingType LArConditionsContainerBase::m_groupType

protected

Definition at line 107 of file LArConditionsContainerBase.h.

m_isInitialized

bool LArConditionsContainerBase::m_isInitialized

protected

Definition at line 115 of file LArConditionsContainerBase.h.

m_offlineHelper

const CaloCell_Base_ID* LArConditionsContainerBase::m_offlineHelper

protected

Definition at line 110 of file LArConditionsContainerBase.h.

m_onlineHelper

const LArOnlineID_Base* LArConditionsContainerBase::m_onlineHelper

protected

Definition at line 109 of file LArConditionsContainerBase.h.

---

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

• LArConditionsContainerBase.h
• LArConditionsContainerBase.cxx