TileCellCont Class Reference

This class builds the Tile cells. More...

#include <TileCellCont.h>

Inheritance diagram for TileCellCont:

Collaboration diagram for TileCellCont:

Public Types
typedef TileCellCollection	IDENTIFIABLE

Public Member Functions
	TileCellCont ()
	constructor More...
const std::vector< TileCellCollection * >::const_iterator	find (const unsigned int &id) const
	Finds a collection. More...
unsigned int	find_rod (const unsigned int &id) const
virtual	~TileCellCont ()
	destructor More...
const std::vector< int > &	Rw2CellMap (int section)
const TileCellCollection *	MBTS_collection (void) const
TileCellCollection *	MBTS_collection (void)
std::map< unsigned int, unsigned int > &	MBTS_map (void)
const std::vector< unsigned int > *	MBTS_RODs ()
const std::vector< unsigned int > *	MBTS_IDs ()
int	MBTS_channel (void)
StatusCode	initialize (void)
StatusCode	finalize (void)
void	setHashIdToROD (const TileHid2RESrcID *p)
const TileHid2RESrcID *	getHashIdToROD () const
void	eventNumber (const unsigned int eN)
unsigned int	eventNumber () const
bool	cached (const unsigned int &rodid)
const std::vector< int > &	Rw2PmtMap (int section)

Public Attributes
T	elements
	STL member. More...

Private Attributes
TileRodIdHash	m_hash
std::vector< int >	m_Rw2Cell [4]
std::vector< int >	m_Rw2Pmt [4]
std::vector< unsigned int >	m_eventNumber
	eventNumber of a given Collection More...
unsigned int	m_event
	this event number More...
std::vector< unsigned int >	m_mbts_rods
std::vector< unsigned int >	m_mbts_IDs
TileCellCollection *	m_MBTS
std::map< unsigned int, unsigned int >	m_mapMBTS
int	m_MBTS_channel
const TileHid2RESrcID *	m_src
	map Hash ID to ROD More...

Detailed Description

This class builds the Tile cells.

Author

Denis Oliveira Damazio

Alexander Solodkov

Definition at line 24 of file TileCellCont.h.

Member Typedef Documentation

IDENTIFIABLE

typedef TileCellCollection TileCellCont::IDENTIFIABLE

Definition at line 29 of file TileCellCont.h.

Constructor & Destructor Documentation

TileCellCont()

TileCellCont::TileCellCont

(

)

constructor

Definition at line 32 of file TileCellCont.cxx.

  : m_event(0)
  , m_MBTS(0)
  , m_MBTS_channel(0)
  , m_src(0) {
}

~TileCellCont()

virtual TileCellCont::~TileCellCont ( )

inlinevirtual

destructor

Definition at line 39 of file TileCellCont.h.

{ }

Member Function Documentation

cached()

bool TileCellCont::cached ( const unsigned int &  rodid )

inline

Definition at line 72 of file TileCellCont.h.

                                         {
   if ( m_eventNumber[rodid] != m_event ) { // Decoding a new event
   // Keep track of last decoded number
   m_eventNumber[rodid] = m_event;
   return false;
   } else return true;
  }

eventNumber() [1/2]

unsigned int TileCellCont::eventNumber ( ) const

inline

Definition at line 71 of file TileCellCont.h.

{ return m_event; } ;

eventNumber() [2/2]

void TileCellCont::eventNumber ( const unsigned int  eN )

inline

Definition at line 70 of file TileCellCont.h.

{ m_event=eN; };

finalize()

StatusCode TileCellCont::finalize

(

void

)

Definition at line 198 of file TileCellCont.cxx.

                                  {
 
  // Delete m_RwCells
  for (int i = 0; i < 4; i++)
    m_Rw2Cell[i].clear();
  for (int i = 0; i < 4; i++)
    m_Rw2Pmt[i].clear();
 
  // Delete Collections and cells
  for (unsigned int i = 0; i < this->size(); i++) {
    // Delete collections. Own cells -> also destroyed
    delete ((TileCellCollection*) ((*this)[i]));
  }
  // Destroy also MBTS collection
  delete m_MBTS;
  m_mapMBTS.clear();
  m_mbts_rods.clear();
  m_mbts_IDs.clear();
  this->clear();
  return StatusCode::SUCCESS;
 
}

find()

const std::vector< TileCellCollection * >::const_iterator TileCellCont::find

(

const unsigned int &

id

)

const

Finds a collection.

Definition at line 194 of file TileCellCont.cxx.

                                                  {
  return this->begin() + rodid;
}

find_rod()

unsigned int TileCellCont::find_rod

(

const unsigned int &

id

)

const

Definition at line 221 of file TileCellCont.cxx.

                                                                   {
  unsigned int rodidx = m_hash.identifier(rodid);
  return rodidx;
}

getHashIdToROD()

const TileHid2RESrcID* TileCellCont::getHashIdToROD ( ) const

inline

Definition at line 67 of file TileCellCont.h.

       { return m_src; }

initialize()

StatusCode TileCellCont::initialize

(

void

)

Definition at line 39 of file TileCellCont.cxx.

                                    {
 
#ifndef NDEBUG
  std::cout << "TileCellCont\t\t DEBUG \t constructor" << std::endl;
#endif
 
  ISvcLocator* svcLoc = Gaudi::svcLocator();
 
  SmartIF<StoreGateSvc> detStore{svcLoc->service("DetectorStore")};
  if (!detStore) {
    std::cout << "Could not locate DetectorStore" << std::endl;
    return StatusCode::FAILURE;
  }
 
  // Get the TileID helper from the detector store
  const TileID* tileID = nullptr;
  if (detStore->retrieve(tileID, "TileID").isFailure()) {
    std::cout << "Could not get TileID helper !" << std::endl;
    return StatusCode::FAILURE;
  }
  // Get the TileHWID helper from the detector store
  const TileHWID* tileHWID = nullptr;
  if (detStore->retrieve(tileHWID, "TileHWID").isFailure()) {
    std::cout << "Could not get TileHWID helper !" << std::endl;
    return StatusCode::FAILURE;
  }
 
  // Get pointer to TileDetDescrManager
  const TileDetDescrManager* tileMgr = nullptr;
  if (detStore->retrieve(tileMgr).isFailure()) {
    std::cout << "Unable to retrieve TileDetDescrManager from DetectorStore" << std::endl;
    return StatusCode::FAILURE;
  }
 
  // Get pointer to MbtsDetDescrManager
  const MbtsDetDescrManager* mbtsMgr = nullptr;
  if (detStore->retrieve(mbtsMgr).isFailure()) {
    std::cout << "Warning: unable to retrieve MbtsDetDescrManager from DetectorStore" << std::endl;
    mbtsMgr = 0;
  }
 
  if ( !m_src ){ // if nothing set, use 2017
       std::cout << "TileCellCont::initialize ERROR : TileHid2RESrc has to be initialized before this" << std::endl;
       return StatusCode::FAILURE;
  }
 
  // Get pointer to TileCablingService
  const TileCablingService* cabling = TileCablingService::getInstance();
  int maxChannels = cabling->getMaxChannels();
 
  //m_hash.initialize(0);
  m_mbts_rods.clear();
  m_mbts_IDs.clear();
  int mbts_count = 0;
  int ID_of_Col = 0;
  std::vector<int> rodids;
  m_MBTS = new TileCellCollection(ID_of_Col, SG::OWN_ELEMENTS);
  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      int frag = tileHWID->frag(ros, drawer);
      int rodid = m_src->getRodID(frag);
      rodids.push_back(rodid);
      m_mapMBTS[frag] = 0xFFFF;
      // One event number per collection
      m_eventNumber.push_back(0xFFFFFFFF);
 
      // Tries to find the TileRawChannel -> TileCell correpondence
      int index, pmt, cell_hash;
      std::vector<int> Rw2Pmt;
      Rw2Pmt.resize(maxChannels, -1);
      std::vector<int> Rw2Cell;
      Rw2Cell.resize(maxChannels, -1);
      std::vector<int_pair> tmp;
 
      for (int channel = 0; channel < maxChannels; ++channel) {
        HWIdentifier channelID = tileHWID->channel_id(ros, drawer, channel);
        Identifier cell_id = cabling->h2s_cell_id_index(channelID, index, pmt);
        if (index == -2) { // MBTS cell, only one per drawer
          m_mbts_rods.push_back(m_src->getRodID(frag));
          m_mbts_IDs.push_back(((ros - 1) * TileCalibUtils::MAX_DRAWER + drawer));
          CaloDetDescrElement * caloDDE = (mbtsMgr) ? mbtsMgr->get_element(cell_id) : NULL;
          TileCell* myMBTSCell = new TileCell(caloDDE, cell_id, 0.0, 0.0, 0, 0, CaloGain::TILEONELOW);
          m_MBTS->push_back(myMBTSCell);
          m_mapMBTS[frag] = mbts_count;
          mbts_count++;
          m_MBTS_channel = channel;
        } else if (index >= 0) { // normal cell
          Rw2Pmt[channel] = pmt;
          if (channel > 0 || ros != 2) { // ignoring D0 (first channel) in negative barrel
            cell_hash = tileID->cell_hash(cell_id);
            tmp.push_back(int_pair(channel, cell_hash));
          }
        }
      } // End of for over TileRawChannel
 
 
      // create new cell collection which will own all elements
      TileCellCollection* newColl = new TileCellCollection(frag, SG::OWN_ELEMENTS);
      this->push_back(newColl);
 
      // sort index according to cell hash and put it in Rw2Cell vector
      // create TileCells in appropriate order and put them in newColl
      if (tmp.size() > 0) {
        std::sort(tmp.begin(), tmp.end(), sort_pred); // sort according to cell hash index
        index = -1;
        cell_hash = -1;
        for (unsigned int i = 0; i < tmp.size(); ++i) {
          if (cell_hash != tmp[i].second) {
            cell_hash = tmp[i].second;
            ++index;
            CaloDetDescrElement * caloDDE = tileMgr->get_cell_element((IdentifierHash) cell_hash);
            TileCell * pCell = new TileCell(caloDDE, 0.0, 0.0, 0, 0, CaloGain::TILELOWLOW);
            newColl->push_back(pCell);
          }
          Rw2Cell[tmp[i].first] = index;
        }
      }
 
      if (drawer == 0 || ros == 3 || ros == 4) {
#ifndef NDEBUG
        int idxraw = 0;
        for (std::vector<int>::iterator i = Rw2Cell.begin(); i != Rw2Cell.end(); ++i) {
          if ((*i) != -1) std::cout << "Channel : " << idxraw++ << " connected to cell " << (*i) << std::endl;
        }
#endif
        // One needs to keep track of Rw2Cell
        for (std::vector<int>::iterator i = Rw2Cell.begin(); i != Rw2Cell.end(); ++i)
          m_Rw2Cell[ros - 1].push_back(*i);
        for (std::vector<int>::iterator i = Rw2Pmt.begin(); i != Rw2Pmt.end(); ++i)
          m_Rw2Pmt[ros - 1].push_back(*i);
      } // End of if first drawer of Barrel or Ext
 
    } // end of drawer for
  } // end of ros for
#ifndef NDEBUG
  std::cout << "Number of RODs is : " << m_mbts_rods.size() << std::endl;
  for (unsigned int k = 0; k < m_mbts_rods.size(); k++)
    std::cout << " MBTS RODs : " << m_mbts_rods[k] << std::endl;
#endif
  m_hash.initialize(0,rodids);
 
#ifndef NDEBUG
  for (int i = 0; i < m_hash.max(); ++i) {
    TileCellCollection *aa = this->at(i);
    TileCell* bb = aa->at(0);
    std::cout << "TileCellCont\t\t DEBUG \t" << i << " " << std::hex << m_hash.identifier(i) << std::dec << " " << aa->identify() << " " << bb->eta() << " " <<  bb->phi() << std::endl;
    // A collection per ROD/ROB/HashId
  } // end of for id
#endif
 
  return StatusCode::SUCCESS;
}

MBTS_channel()

int TileCellCont::MBTS_channel ( void  )

inline

Definition at line 60 of file TileCellCont.h.

{ return m_MBTS_channel; }

MBTS_collection() [1/2]

TileCellCollection* TileCellCont::MBTS_collection ( void  )

inline

Definition at line 52 of file TileCellCont.h.

        { return m_MBTS; }

MBTS_collection() [2/2]

const TileCellCollection* TileCellCont::MBTS_collection ( void  ) const

inline

Definition at line 50 of file TileCellCont.h.

        { return m_MBTS; }

MBTS_IDs()

const std::vector<unsigned int>* TileCellCont::MBTS_IDs ( )

inline

Definition at line 58 of file TileCellCont.h.

        { return &m_mbts_IDs; }

MBTS_map()

std::map<unsigned int, unsigned int>& TileCellCont::MBTS_map ( void  )

inline

Definition at line 54 of file TileCellCont.h.

        { return m_mapMBTS; }

MBTS_RODs()

const std::vector<unsigned int>* TileCellCont::MBTS_RODs ( )

inline

Definition at line 56 of file TileCellCont.h.

        { return &m_mbts_rods; }

Rw2CellMap()

const std::vector<int>& TileCellCont::Rw2CellMap ( int  section )

inline

• section = 0 for barrel positive
• section = 1 for barrel negative
• section = 2 for extended barrel positive
• section = 3 for extended barrel negative

Definition at line 47 of file TileCellCont.h.

                                                   {
    return m_Rw2Cell[section];
  }

Rw2PmtMap()

const std::vector<int>& TileCellCont::Rw2PmtMap ( int  section )

inline

Definition at line 79 of file TileCellCont.h.

                                                  {
    return m_Rw2Pmt[section];
  }

setHashIdToROD()

void TileCellCont::setHashIdToROD ( const TileHid2RESrcID *  p )

inline

Definition at line 64 of file TileCellCont.h.

       { m_src = p; }

Member Data Documentation

elements

T std::vector< T >::elements

inherited

STL member.

m_event

unsigned int TileCellCont::m_event

private

this event number

Definition at line 93 of file TileCellCont.h.

m_eventNumber

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

private

eventNumber of a given Collection

Definition at line 91 of file TileCellCont.h.

m_hash

TileRodIdHash TileCellCont::m_hash

private

Definition at line 85 of file TileCellCont.h.

m_mapMBTS

std::map<unsigned int, unsigned int> TileCellCont::m_mapMBTS

private

Definition at line 98 of file TileCellCont.h.

m_MBTS

TileCellCollection* TileCellCont::m_MBTS

private

Definition at line 97 of file TileCellCont.h.

m_MBTS_channel

int TileCellCont::m_MBTS_channel

private

Definition at line 99 of file TileCellCont.h.

m_mbts_IDs

std::vector<unsigned int> TileCellCont::m_mbts_IDs

private

Definition at line 96 of file TileCellCont.h.

m_mbts_rods

std::vector<unsigned int> TileCellCont::m_mbts_rods

private

Definition at line 95 of file TileCellCont.h.

m_Rw2Cell

std::vector<int> TileCellCont::m_Rw2Cell[4]

private

Definition at line 87 of file TileCellCont.h.

m_Rw2Pmt

std::vector<int> TileCellCont::m_Rw2Pmt[4]

private

Definition at line 89 of file TileCellCont.h.

m_src

const TileHid2RESrcID* TileCellCont::m_src

private

map Hash ID to ROD

Definition at line 101 of file TileCellCont.h.

---

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

• TileCellCont.h
• TileCellCont.cxx