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 ()
	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 (const unsigned int &id)
	Finds a collection by its ROD ID.
HWIdentifier	findsec (const unsigned int &id) const
	Each Collection contains data from 2 FEBs.
void	applyBCIDCorrection (const unsigned int &rodid)
	method to apply correction based on the luminosity to the energy
virtual	~LArCellCont ()
	destructor
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
	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, int >	m_indexset
	index table
float	m_lumi_block
	current lumi_block
unsigned int	m_bcid
EventIDBase::event_number_t	m_bcidEvt
bool	m_BCIDcache
	flag to only update cache when trying to apply corrections

Detailed Description

Class which contains statically allocated LArCellCollections.

Definition at line 39 of file LArCellCont.h.

Member Typedef Documentation

IDENTIFIABLE

typedef LArCellCollection LArCellCont::IDENTIFIABLE

Identifiable definition to be compatible with LArCellIDC.

Definition at line 45 of file LArCellCont.h.

Constructor & Destructor Documentation

LArCellCont()

LArCellCont::LArCellCont

(

)

Constructor.

Does not do anything. Check initialize.

Definition at line 18 of file LArCellCont.cxx.

                         : m_event(0), m_lumi_block(0), m_bcid(5000), m_bcidEvt(5000), m_BCIDcache(false)
{}

~LArCellCont()

virtual LArCellCont::~LArCellCont ( )

inlinevirtual

destructor

Definition at line 72 of file LArCellCont.h.

{ };

Member Function Documentation

applyBCIDCorrection()

void LArCellCont::applyBCIDCorrection

(

const unsigned int &

rodid

)

method to apply correction based on the luminosity to the energy

Definition at line 219 of file LArCellCont.cxx.

                                                              {
  int idx = m_hash(rodid);
  std::vector<LArCellCollection*>::const_iterator it = (std::vector<LArCellCollection*>::const_iterator)((*this).begin()+idx);
  LArCellCollection* col = (*it);
  unsigned int itsize = col->size();
  std::vector<int>& hashTab = m_hashSym[idx];
  for(unsigned int i=0; i< itsize; ++i){
    float cor = m_corrBCID[ hashTab[i] ];
    LArCell* cell = col->operator[](i);
#ifdef TRIGLARCELLDEBUG
    std::cout << "LArCellId= " << cell->ID() << " Ecorr= " << cor << " MeV " << std::endl;
#endif
    float cellenergy = cell->energy();
    cell->setEnergyFast( cellenergy  - cor );
  }
  return;
}

eventNumber()

void LArCellCont::eventNumber ( const unsigned int eN )

inline

sets Event Number

Definition at line 83 of file LArCellCont.h.

{ m_event=eN; };

finalize()

StatusCode LArCellCont::finalize

(

void

)

finalize method.

Destroys all cells and collections.

Definition at line 181 of file LArCellCont.cxx.

                                 {
int number_of_col = m_hash.max();
for(int i=0;i<number_of_col;i++){
    int number_of_cell = ((*this)[i])->size();
    for(int j=0;j<number_of_cell;j++)
        delete ((*((*this)[i]))[j]);
    if ((*this)[i] != NULL)
        delete ((*this)[i]);
} // End of for m_hash.max()
// Destroy also the vector of vectors to TT maps.
for(size_t i=0;i<m_vecs.size();i++){
    delete m_vecs[i];
}
for(unsigned int i=0; i< m_hashSym.size(); ++i) (m_hashSym[i]).clear();
m_hashSym.clear();
return StatusCode::SUCCESS;
} // end of finalize

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 201 of file LArCellCont.cxx.

                                                {
    int idx = m_hash(m_conv.getRodIDFromROM (rodid));
    return (std::vector<LArCellCollection*>::const_iterator)((*this).begin()+idx);
}

find() [2/2]

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

(

const 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 208 of file LArCellCont.cxx.

                                           {
    int idx = m_hash(rodid);
    if ( m_eventNumber[idx] != m_event ) { // Decoding a new event
    m_eventNumber[idx] = m_event;
    return (std::vector<LArCellCollection*>::const_iterator)((*this).begin()+idx);
    // Keep track of last decoded number
    } else { // Event already decoded. Return Null
    return (std::vector<LArCellCollection*>::const_iterator)((*this).end());
    }
}

findsec()

HWIdentifier LArCellCont::findsec

(

const unsigned int &

id

)

const

Each Collection contains data from 2 FEBs.

Returns

for each collection the ID of the second FEB.

Definition at line 238 of file LArCellCont.cxx.

                                                   {
    int 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 22 of file LArCellCont.cxx.

                                                         {
 
#ifdef TRIGLARCELLDEBUG
std::cout << "LArCellCont \t\t DEBUG \t in initialize" << std::endl;
#endif
 
 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() );
 
 HWIdentifier larrodid(0);
 for(int i=0;i<m_hash.max();i++){
#ifdef TRIGLARCELLDEBUG
   std::cout << "LArCellCont\t\t DEBUG \t" 
         << i << " " << std::hex << m_hash.identifier(i) << std::dec 
         << std::endl;
#endif
   // A collection per ROD/ROB/HashId
   LArCellCollection* mycoll = new LArCellCollection(larrodid);
   mycoll->reserve(256);
   this->push_back(mycoll);
   m_second.push_back(HWIdentifier(0));
   m_eventNumber.push_back(0xFFFFFFFF);
 } // end of for id
 // Not anymore necessary
 //delete larrodid;
 
std::vector<const CaloCellCorrection*> LArCellCorrTools;
     
MakeLArCellFromRaw makeCell;
makeCell.setThreshold(-100);
makeCell.initialize( roiMap, onOffMap, man, &LArCellCorrTools, 0 );
 
StatusCode sc = toolSvc->retrieveTool("LArBadFebMasker", m_badFebMasker);
bool toolAvailable = sc.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;
 
int count = 0;
std::vector<HWIdentifier>::const_iterator beg = onlineId->channel_begin();
std::vector<HWIdentifier>::const_iterator end = onlineId->channel_end  ();
for(  ;  beg != end;  ++beg ){
    HWIdentifier hwid = mcsym.ZPhiSymOnl(*beg);
        if ( m_indexset.try_emplace (hwid, count).second ) {
          ++count;
        }
} // end of loop over online IDs
int indexsetmax = m_indexset.size();
// the extra indexsetmax is used for invalid cells
m_corrBCID.resize(indexsetmax+1,0.0);
 
for(unsigned int i=0; i< m_hashSym.size(); ++i) (m_hashSym[i]).clear();
m_hashSym.clear();
m_hashSym.resize(onlineId->febHashMax());
 for (unsigned 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); 
    unsigned int rodId32 = m_conv.getRodIDFromROM(rodId);
    // index in the collection vector
    int idx = m_hash(rodId32);
#ifdef TRIGLARCELLDEBUG
    std::cout << "LArCellCont\t\t DEBUG \t" 
    << idx << " " << std::hex << m_hash.identifier(idx) << std::dec 
    << std::endl;
#endif
    // 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());
                bool good(true);
        if (! bc.good() ){
           // cell has some specific problems
           if ( bc.unstable() ) good=false;
           if ( bc.highNoiseHG() ) good=false;
           if ( bc.highNoiseMG() ) good=false;
           if ( bc.highNoiseLG() ) good=false;
           if ( bc.problematicForUnknownReason() ) good=false;
        }
        if ( good ) collMap[ttId].push_back(larcell); // cell masked if not know to be good
        HWIdentifier hwsym = mcsym.ZPhiSymOnl(onlineId->channel_Id(febid,ch));
        if ( m_indexset.find( hwsym ) != m_indexset.end() ){
          int index = (m_indexset.find( hwsym ))->second;
          hashTab.push_back( index );
        } else hashTab.push_back(indexsetmax);
#ifdef TRIGLARCELLDEBUG
        std::cout << "Cell registered at Collection " 
        << std::hex << febid.get_identifier32().get_compact() << std::dec <<
        " Channel " << ch << " TTId " << (unsigned int)ttId
        << std::endl;
#endif
    }
    else {// add a dummy cell
#ifdef TRIGLARCELLDEBUG
        std::cout << "Cell not existing" << std::endl;
#endif
        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
        DataVector<LArCell> *vec = new DataVector<LArCell>(SG::VIEW_ELEMENTS);
        vec->reserve(cells.size());
        for(LArCell* c : cells)
        {
        //  if(doCellMasking && m_masker->cellShouldBeMasked(c->ID()) )
          vec->push_back(c);
        }
        (*this)[idx]->setTT(ttid,vec->begin(),vec->end());
        m_vecs.push_back(vec);
        }//End of loop over the map
   } // 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]);
RobsFromMissingFeb.clear();
 
return StatusCode::SUCCESS;
}

lumiBCIDCheck()

bool LArCellCont::lumiBCIDCheck

(

const EventContext &

context

)

Definition at line 270 of file LArCellCont.cxx.

                                                             {
     uint32_t bcid = context.eventID().bunch_crossing_id();
     if ( bcid == m_bcid ) return false;
     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 243 of file LArCellCont.cxx.

                                                                                      {
  if ( m_bcid != BCID  ) {
#ifdef TRIGLARCELLDEBUG
    std::cout << "Update : CURRENT lumi_block, BCID = " << lumi_block << ", " << BCID << " <--> PREVIOUS lumi_block = " << m_lumi_block << ", " << m_bcid << std::endl;
#endif
    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 88 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 253 of file LArCellCont.cxx.

                                                                                          {
 
  std::map<HWIdentifier,int>::const_iterator end = m_indexset.end  ();
 
  std::map<HWIdentifier,int>::const_iterator beg = m_indexset.begin();
  for( ; beg != end ; ++beg ) {
      HWIdentifier hwid = (*beg).first;
      int idx = (*beg).second;
      if ( idx < (int)m_corrBCID.size() ){
        Identifier id = onoff.cnvToIdentifier(hwid);
    float corr = avg.average(id);
    m_corrBCID[idx] = corr;
      }
  } // end of HWID
  return; 
}

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 115 of file LArCellCont.h.

m_bcid

unsigned int LArCellCont::m_bcid

private

Definition at line 126 of file LArCellCont.h.

m_BCIDcache

bool LArCellCont::m_BCIDcache

private

flag to only update cache when trying to apply corrections

Definition at line 130 of file LArCellCont.h.

m_bcidEvt

EventIDBase::event_number_t LArCellCont::m_bcidEvt

private

Definition at line 127 of file LArCellCont.h.

m_conv

Hid2RESrcID LArCellCont::m_conv

private

Hardware to Source ID conversion.

Definition at line 101 of file LArCellCont.h.

m_corrBCID

std::vector<float> LArCellCont::m_corrBCID

private

corrections for a given BCID

Definition at line 121 of file LArCellCont.h.

m_event

unsigned int LArCellCont::m_event

private

this event number

Definition at line 108 of file LArCellCont.h.

m_eventNumber

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

private

eventNumber of a given Collection

Definition at line 106 of file LArCellCont.h.

m_hash

LArRodIdHash LArCellCont::m_hash

private

Hash ID Identifier mapping to collection index.

Definition at line 99 of file LArCellCont.h.

m_hashSym

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

private

hash references to BCID

Definition at line 119 of file LArCellCont.h.

m_indexset

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

private

index table

Definition at line 123 of file LArCellCont.h.

m_lumi_block

float LArCellCont::m_lumi_block

private

current lumi_block

Definition at line 125 of file LArCellCont.h.

m_MissingROBs

std::vector<uint32_t> LArCellCont::m_MissingROBs

private

List of Missing ROBs to be disabled at the RS.

Definition at line 117 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 104 of file LArCellCont.h.

m_vecs

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

private

One needs to destroy the TT vectors.

Definition at line 110 of file LArCellCont.h.

---

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

• LArCellCont.h
• LArCellCont.cxx