LArCellCont Class Reference

Class which contains statically allocated LArCellCollections. More...

#include <LArCellCont.h>

Inheritance diagram for LArCellCont:

Public Types
typedef LArCellCollection	IDENTIFIABLE
	Identifiable definition to be compatible with LArCellIDC.

Public Member Functions
	LArCellCont ()=default
	Constructor.
const std::vector< LArCellCollection * >::const_iterator	find (const HWIdentifier &id) const
	Finds a collection by its LArReadoutModuleID.
const std::vector< LArCellCollection * >::const_iterator	find (unsigned int id)
	Finds a collection by its ROD ID.
HWIdentifier	findsec (unsigned int id) const
	Each Collection contains data from 2 FEBs.
void	applyBCIDCorrection (unsigned int rodid)
	method to apply correction based on the luminosity to the energy
StatusCode	initialize (const LArRoIMap &roiMap, const LArOnOffIdMapping &onOffMap, const LArMCSym &mcsym, const LArFebRodMapping &febrod, const LArBadChannelCont &badchannel, const CaloDetDescrManager &ddm)
	initialize method.
StatusCode	finalize (void)
	finalize method.
void	eventNumber (const unsigned int eN)
	sets Event Number
void	lumiBlock_BCID (const unsigned int lumi_block, const unsigned int BCID)
	sets LumiBlock and BCID
const std::vector< uint32_t > &	MissingROBs (void)
	List of Missing ROBs.
bool	lumiBCIDCheck (const EventContext &context)
void	updateBCID (const CaloBCIDAverage &, const LArOnOffIdMapping &)
	update BCID dependent correction table for MT case

Public Attributes
T	elements
	STL member.

Private Attributes
LArRodIdHash	m_hash
	Hash ID Identifier mapping to collection index.
Hid2RESrcID	m_conv
	Hardware to Source ID conversion.
std::vector< HWIdentifier >	m_second
	FEB Hardware Identifier for second FEBs in a Collection.
std::vector< unsigned int >	m_eventNumber
	eventNumber of a given Collection
unsigned int	m_event {0}
	this event number
std::vector< DataVector< LArCell > * >	m_vecs
	One needs to destroy the TT vectors.
const ILArBadFebMasker *	m_badFebMasker = nullptr
	A tool to help mask cells.
std::vector< uint32_t >	m_MissingROBs
	List of Missing ROBs to be disabled at the RS.
std::vector< std::vector< int > >	m_hashSym
	hash references to BCID
std::vector< float >	m_corrBCID
	corrections for a given BCID
std::map< HWIdentifier, size_t >	m_indexset
	index table
unsigned int	m_lumi_block {0}
	current lumi_block
unsigned int	m_bcid {5000}
EventIDBase::event_number_t	m_bcidEvt {5000}
bool	m_BCIDcache {false}
	flag to only update cache when trying to apply corrections

Detailed Description

Class which contains statically allocated LArCellCollections.

Definition at line 41 of file LArCellCont.h.

Member Typedef Documentation

IDENTIFIABLE

typedef LArCellCollection LArCellCont::IDENTIFIABLE

Identifiable definition to be compatible with LArCellIDC.

Definition at line 47 of file LArCellCont.h.

Constructor & Destructor Documentation

LArCellCont()

LArCellCont::LArCellCont ( )

default

Constructor.

Does not do anything. Check initialize.

Member Function Documentation

applyBCIDCorrection()

void LArCellCont::applyBCIDCorrection

(

unsigned int

rodid

)

method to apply correction based on the luminosity to the energy

Definition at line 214 of file LArCellCont.cxx.

                                                        {
  const size_t idx = m_hash(rodid);
  LArCellCollection* col = *(this->begin()+idx);
  std::vector<int>& hashTab = m_hashSym[idx];
  for(size_t i=0; i<col->size(); ++i){
    LArCell* cell = (*col)[i];
    const float cellenergy = cell->energy();
    const float cor = m_corrBCID[ hashTab[i] ];
    cell->setEnergyFast( cellenergy  - cor );
    LOG_DEBUG("LArCellId= " << cell->ID() << " Ecorr= " << cor << " MeV");
  }
  return;
}

eventNumber()

void LArCellCont::eventNumber ( const unsigned int eN )

inline

sets Event Number

Definition at line 85 of file LArCellCont.h.

{ m_event=eN; };

finalize()

StatusCode LArCellCont::finalize

(

void

)

finalize method.

Destroys all cells and collections.

Definition at line 179 of file LArCellCont.cxx.

                                 {
  for(size_t i=0; i<m_hash.max(); i++){
    LArCellCollection* coll = (*this)[i];
    for(size_t j=0; j<coll->size(); j++) {
      delete (*coll)[j];
    }
    delete coll;
  }
  // Destroy also the vector of vectors to TT maps.
  for(size_t i=0; i<m_vecs.size(); i++) delete m_vecs[i];
 
  m_hashSym.clear();
  return StatusCode::SUCCESS;
}

find() [1/2]

const std::vector< LArCellCollection * >::const_iterator LArCellCont::find

(

const HWIdentifier &

id

)

const

Finds a collection by its LArReadoutModuleID.

Parameters

[in]

ReadOut

Module ID

Returns

const_iterator to a pointer to LArCellCollection.

Definition at line 196 of file LArCellCont.cxx.

                                                {
  const size_t idx = m_hash(m_conv.getRodIDFromROM (rodid));
  return (this->begin()+idx);
}

find() [2/2]

const std::vector< LArCellCollection * >::const_iterator LArCellCont::find

(

unsigned int

id

)

Finds a collection by its ROD ID.

Parameters

[in]

Read

Out ID as provided by RegionSelector.

Returns

const_iterator to a pointer to LArCellCollection.

Definition at line 203 of file LArCellCont.cxx.

                                    {
  const size_t idx = m_hash(rodid);
  if ( m_eventNumber[idx] != m_event ) { // Decoding a new event
    m_eventNumber[idx] = m_event;
    return (this->begin()+idx);
    // Keep track of last decoded number
  } else { // Event already decoded. Return Null
    return this->end();
  }
}

findsec()

HWIdentifier LArCellCont::findsec

(

unsigned int

id

)

const

Each Collection contains data from 2 FEBs.

Returns

for each collection the ID of the second FEB.

Definition at line 229 of file LArCellCont.cxx.

                                            {
  const size_t idx = m_hash(rodid);
  return m_second[idx];
}

initialize()

StatusCode LArCellCont::initialize	(	const LArRoIMap &	roiMap,
		const LArOnOffIdMapping &	onOffMap,
		const LArMCSym &	mcsym,
		const LArFebRodMapping &	febrod,
		const LArBadChannelCont &	badchannel,
		const CaloDetDescrManager &	ddm )

initialize method.

Builds all cells and collections.

Definition at line 31 of file LArCellCont.cxx.

                                                         {
 
  LOG_DEBUG("in initialize");
 
  ServiceHandle<IToolSvc> toolSvc("ToolSvc", "LArCellCont");
  CHECK_WITH_CONTEXT( toolSvc.retrieve(), "LArCellCont");
 
  ServiceHandle<StoreGateSvc> detStore("DetectorStore", "LArCellCont");
  CHECK_WITH_CONTEXT( detStore.retrieve(), "LArCellCont");
 
  const LArOnlineID* onlineId = nullptr;
  CHECK_WITH_CONTEXT( detStore->retrieve(onlineId,"LArOnlineID"), "LArCellCont" );
 
  CHECK_WITH_CONTEXT( m_conv.initialize(febrod), "LArCellCont" );
  m_hash.initialize(0, febrod.getLArRoModIDvec() );
 
  const HWIdentifier larrodid(0);
  for(size_t i=0;i<m_hash.max();i++){
    LOG_DEBUG(i << " " << std::hex << m_hash.identifier(i) << std::dec);
 
    // A collection per ROD/ROB/HashId
    LArCellCollection* mycoll = new LArCellCollection(larrodid);
    mycoll->reserve(256);
    this->push_back(mycoll);
    m_second.emplace_back(0);
    m_eventNumber.push_back(std::numeric_limits<unsigned int>::max());
  } // end of for id
 
  std::vector<const CaloCellCorrection*> LArCellCorrTools;
     
  MakeLArCellFromRaw makeCell;
  makeCell.setThreshold(-100);
  makeCell.initialize( roiMap, onOffMap, man, &LArCellCorrTools, 0 );
 
  const bool toolAvailable = toolSvc->retrieveTool("LArBadFebMasker", m_badFebMasker).isSuccess();
 
  if(!toolAvailable) //not a critical error. LArCellCont can proceed as usual, without masking.
    REPORT_MESSAGE_WITH_CONTEXT(MSG::INFO, "LArCellCont") <<
      "Failed to retrieve LArBadFebMasker - no masking will be done." << endmsg;
 
  std::vector<uint32_t> RobsFromMissingFeb;
 
  size_t count = 0;
  for( const HWIdentifier& id : onlineId->channel_range() ){
    HWIdentifier hwid = mcsym.ZPhiSymOnl(id);
    if ( m_indexset.try_emplace (hwid, count).second ) {
      ++count;
    }
  } // end of loop over online IDs
 
  const size_t indexsetmax = m_indexset.size();
  // the extra indexsetmax is used for invalid cells
  m_corrBCID.resize(indexsetmax+1,0.0);
 
  m_hashSym.clear();
  m_hashSym.resize(onlineId->febHashMax());
 
  for (size_t iFeb=0; iFeb<onlineId->febHashMax(); ++iFeb) {
    const HWIdentifier& febid=onlineId->feb_Id(IdentifierHash(iFeb));
    if( (toolAvailable && (m_badFebMasker->febMissing(febid)) ) || !toolAvailable ){
      RobsFromMissingFeb.push_back( m_conv.getRobID( m_conv.getRodID( febrod, febid ) ) );
    }
    if( (toolAvailable && !(m_badFebMasker->febMissing(febid)) ) || !toolAvailable ){
      // get RodID associated with the collection
      const HWIdentifier& rodId = febrod.getReadoutModuleID(febid);
      const unsigned int rodId32 = m_conv.getRodIDFromROM(rodId);
      // index in the collection vector
      const size_t idx = m_hash(rodId32);
    
      LOG_DEBUG(idx << " " << std::hex << m_hash.identifier(idx) << std::dec);
 
      // get all channels for a FEB
      std::map<LArRoIMap::TT_ID,std::vector<LArCell* > > collMap;
      if ( (*this)[idx]->size() != 0 ) { // This is the second FEB
        m_second[idx] = febid;
      }
      std::vector<int>& hashTab = m_hashSym[idx];
      hashTab.reserve(256);
      unsigned int febidcomp = febid.get_identifier32().get_compact();
      for(int ch=0; ch<128; ch++){
        LArRoIMap::TT_ID ttId;
        LArCell* larcell = makeCell.getLArCell(febidcomp,ch,0,0,0,ttId);
        if ( larcell ) { // if it is a good cell
          // Fixes default value
          larcell->setGain(CaloGain::LARHIGHGAIN);
          (*this)[idx]->push_back(larcell);
          LArBadChannel bc = badchannel.offlineStatus(larcell->ID());
 
          const bool bad = !bc.good() &&
            // cell has some specific problems
            ( bc.deadReadout() ||
              bc.deadPhys() ||
              bc.highNoiseHG() ||
              bc.highNoiseMG() ||
              bc.highNoiseLG() ||
              bc.problematicForUnknownReason() );
 
          if ( !bad ) collMap[ttId].push_back(larcell); // cell masked if not know to be good
 
          HWIdentifier hwsym = mcsym.ZPhiSymOnl(onlineId->channel_Id(febid,ch));
 
          auto itr = m_indexset.find( hwsym );
          if ( itr != m_indexset.end() ){
            const int index = itr->second;
            hashTab.push_back( index );
          } else hashTab.push_back(indexsetmax);
 
          LOG_DEBUG("Cell registered at Collection "
                    << std::hex << febid.get_identifier32().get_compact() << std::dec <<
                    " Channel " << ch << " TTId " << (unsigned int)ttId);
        }
        else {// add a dummy cell
          LOG_DEBUG("Cell not existing");
 
          LArCell* larcell = new LArCell();
          (*this)[idx]->push_back(larcell);
          hashTab.push_back( indexsetmax);
        } // end of if bad cell
      } // end of for ch loop
 
      for (const auto& [ttid, cells] : collMap) {
        // Ones needs to dump the mapped vector to an allocated vector
        auto vec = new DataVector<LArCell>(SG::VIEW_ELEMENTS);
        vec->reserve(cells.size());
        for(LArCell* c : cells) {
          vec->push_back(c);
        }
        (*this)[idx]->setTT(ttid,vec->begin(),vec->end());
        m_vecs.push_back(vec);
      }
 
    } // End of check for missing FEB
  } // end of FEB for
 
  m_MissingROBs.clear();
  for(size_t i = 0 ; i < RobsFromMissingFeb.size() ; i++)
    for(size_t j = i+1 ; j < RobsFromMissingFeb.size() ; j++)
      if ( RobsFromMissingFeb[i] == RobsFromMissingFeb[j] )
        m_MissingROBs.push_back(RobsFromMissingFeb[i]);
 
  return StatusCode::SUCCESS;
}

lumiBCIDCheck()

bool LArCellCont::lumiBCIDCheck

(

const EventContext &

context

)

Definition at line 257 of file LArCellCont.cxx.

                                                             {
  const unsigned int bcid = context.eventID().bunch_crossing_id();
  if ( bcid == m_bcid ) return false;
 
  const EventIDBase::event_number_t evN = context.eventID().event_number();
  if ( evN == m_bcidEvt ) return false;
 
  m_bcid = bcid;
  m_bcidEvt = evN;
  return true;
}

lumiBlock_BCID()

void LArCellCont::lumiBlock_BCID	(	const unsigned int	lumi_block,
		const unsigned int	BCID )

sets LumiBlock and BCID

Definition at line 234 of file LArCellCont.cxx.

                                                                                      {
  if ( m_bcid != BCID  ) {
 
    LOG_DEBUG("Update : CURRENT lumi_block, BCID = " << lumi_block << ", " << BCID <<
              " <--> PREVIOUS lumi_block = " << m_lumi_block << ", " << m_bcid);
 
    m_lumi_block = lumi_block;
    m_bcid = BCID;
    m_BCIDcache = false;
  }    
}

MissingROBs()

const std::vector< uint32_t > & LArCellCont::MissingROBs ( void )

inline

List of Missing ROBs.

Definition at line 90 of file LArCellCont.h.

                                                 {
    return m_MissingROBs;
  }

updateBCID()

void LArCellCont::updateBCID	(	const CaloBCIDAverage &	avg,
		const LArOnOffIdMapping &	onoff )

update BCID dependent correction table for MT case

Definition at line 246 of file LArCellCont.cxx.

                                                                                         {
 
  for (const auto& [hwid, idx] : m_indexset) {
    if ( idx < m_corrBCID.size() ){
      Identifier id = onoff.cnvToIdentifier(hwid);
      float corr = avg.average(id);
      m_corrBCID[idx] = corr;
    }
  }
}

Member Data Documentation

elements

T std::vector< T >::elements

inherited

STL member.

m_badFebMasker

const ILArBadFebMasker* LArCellCont::m_badFebMasker = nullptr

private

A tool to help mask cells.

A tool to help mask febs

Definition at line 117 of file LArCellCont.h.

m_bcid

unsigned int LArCellCont::m_bcid {5000}

private

Definition at line 128 of file LArCellCont.h.

{5000};

m_BCIDcache

bool LArCellCont::m_BCIDcache {false}

private

flag to only update cache when trying to apply corrections

Definition at line 132 of file LArCellCont.h.

{false};

m_bcidEvt

EventIDBase::event_number_t LArCellCont::m_bcidEvt {5000}

private

Definition at line 129 of file LArCellCont.h.

{5000};

m_conv

Hid2RESrcID LArCellCont::m_conv

private

Hardware to Source ID conversion.

Definition at line 103 of file LArCellCont.h.

m_corrBCID

std::vector<float> LArCellCont::m_corrBCID

private

corrections for a given BCID

Definition at line 123 of file LArCellCont.h.

m_event

unsigned int LArCellCont::m_event {0}

private

this event number

Definition at line 110 of file LArCellCont.h.

{0};

m_eventNumber

std::vector<unsigned int> LArCellCont::m_eventNumber

private

eventNumber of a given Collection

Definition at line 108 of file LArCellCont.h.

m_hash

LArRodIdHash LArCellCont::m_hash

private

Hash ID Identifier mapping to collection index.

Definition at line 101 of file LArCellCont.h.

m_hashSym

std::vector< std::vector<int> > LArCellCont::m_hashSym

private

hash references to BCID

Definition at line 121 of file LArCellCont.h.

m_indexset

std::map<HWIdentifier, size_t> LArCellCont::m_indexset

private

index table

Definition at line 125 of file LArCellCont.h.

m_lumi_block

unsigned int LArCellCont::m_lumi_block {0}

private

current lumi_block

Definition at line 127 of file LArCellCont.h.

{0};

m_MissingROBs

std::vector<uint32_t> LArCellCont::m_MissingROBs

private

List of Missing ROBs to be disabled at the RS.

Definition at line 119 of file LArCellCont.h.

m_second

std::vector<HWIdentifier> LArCellCont::m_second

private

FEB Hardware Identifier for second FEBs in a Collection.

Definition at line 106 of file LArCellCont.h.

m_vecs

std::vector<DataVector<LArCell>*> LArCellCont::m_vecs

private

One needs to destroy the TT vectors.

Definition at line 112 of file LArCellCont.h.

---

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

• LArCellCont.h
• LArCellCont.cxx