LArFCalTowerStore Class Reference

Intermediate store for cell/tower maps. More...

#include <LArFCalTowerStore.h>

Collaboration diagram for LArFCalTowerStore:

Public Types
typedef std::vector< std::pair< unsigned int, double > >	tower_data_t
typedef tower_data_t::const_iterator	cell_iterator
typedef std::vector< tower_data_t >	tower_table_t
typedef tower_table_t::const_iterator	tower_iterator
typedef CaloTowerSeg::SubSegIterator< tower_iterator >	tower_subseg_iterator

Public Member Functions
	LArFCalTowerStore ()
	constructor
	~LArFCalTowerStore ()
	destructor
tower_iterator	towers () const
tower_subseg_iterator	towers (const CaloTowerSeg::SubSeg &subseg) const
	Return an iterator for looping over all towers defined by the window subseg.
cell_iterator	firstCellofTower (tower_iterator t) const
	iterators: cells
cell_iterator	lastCellofTower (tower_iterator t) const
unsigned int	towerSize (tower_iterator t) const
bool	buildLookUp (const CaloCell_ID &cellIdHelper, const CaloDetDescrManager &theManager, CaloTowerContainer *theTowers)
	setup trigger
size_t	size () const
	size of internal data store

Private Attributes
std::vector< unsigned int >	m_ndxFCal
std::vector< unsigned int >	m_ndyFCal
size_t	m_indxOffset
size_t	m_indxBound
tower_table_t	m_TTCmatrix

Detailed Description

Intermediate store for cell/tower maps.

      This is NOT to be confused with CaloTowerContainer, even though
      it is a container class for CaloTower objects. In particular, 
      this class is NOT inherited from CaloTowerContainer classes. 
      This class is for exclusive use within LArFCalTowerBuilder.

PACKAGE: offline/LArCalorimeter/LArClusterRec

Author

P. Loch

Date

May 2001

Definition at line 37 of file LArFCalTowerStore.h.

Member Typedef Documentation

cell_iterator

typedef tower_data_t::const_iterator LArFCalTowerStore::cell_iterator

Definition at line 41 of file LArFCalTowerStore.h.

tower_data_t

typedef std::vector<std::pair<unsigned int,double> > LArFCalTowerStore::tower_data_t

Definition at line 40 of file LArFCalTowerStore.h.

tower_iterator

typedef tower_table_t::const_iterator LArFCalTowerStore::tower_iterator

Definition at line 50 of file LArFCalTowerStore.h.

tower_subseg_iterator

typedef CaloTowerSeg::SubSegIterator<tower_iterator> LArFCalTowerStore::tower_subseg_iterator

Definition at line 51 of file LArFCalTowerStore.h.

tower_table_t

typedef std::vector<tower_data_t> LArFCalTowerStore::tower_table_t

Definition at line 42 of file LArFCalTowerStore.h.

Constructor & Destructor Documentation

LArFCalTowerStore()

LArFCalTowerStore::LArFCalTowerStore

(

)

constructor

Definition at line 41 of file LArFCalTowerStore.cxx.

  : m_indxOffset (0),
    m_indxBound (0)
{
  // some parameters
  m_ndxFCal.resize(3);
  m_ndyFCal.resize(3);
  // set default
  m_ndxFCal[0] = 4;
  m_ndxFCal[1] = 4;
  m_ndxFCal[2] = 6;
  m_ndyFCal[0] = 4;
  m_ndyFCal[1] = 6;
  m_ndyFCal[2] = 6;
  
 }

~LArFCalTowerStore()

LArFCalTowerStore::~LArFCalTowerStore

(

)

destructor

Definition at line 59 of file LArFCalTowerStore.cxx.

                                     {
//  m_dataMatrix.clear(); 
    m_TTCmatrix.clear();
}

Member Function Documentation

buildLookUp()

bool LArFCalTowerStore::buildLookUp	(	const CaloCell_ID &	cellIdHelper,
		const CaloDetDescrManager &	theManager,
		CaloTowerContainer *	theTowers )

setup trigger

Definition at line 68 of file LArFCalTowerStore.cxx.

{
  // Store Preparation //
 
  // get cell id helper
  const LArFCAL_ID& fcalIdHelper = *cellIdHelper.fcal_idHelper();
 
  // find numerical ranges
  IdentifierHash firstIndex, lastIndex;
  cellIdHelper.calo_cell_hash_range((int)CaloCell_ID::LARFCAL, firstIndex, lastIndex);
  m_indxOffset = (size_t)firstIndex;
  m_indxBound  = (size_t)lastIndex;
 
  // check
  if ( m_indxBound <= m_indxOffset ){
    REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "LArFCalTowerStore")
      << "cannot initialize internal store properly, index offset = "
      << m_indxOffset << ", index boundary = " << m_indxBound<< " -> module inactivated!"
      << endmsg;
      return false;
    }
 
  // calculate number of rows in store matrix an initialize
//  m_rowsMatrix = m_indxBound - m_indxOffset + 1;
//  for ( size_t iRow=0; iRow < m_rowsMatrix; iRow++ ){
//      m_dataMatrix.push_back(tower_data_store());
//    }
 
  // report data store size
//  msg << MSG::INFO << "internal matrix set up with " << m_dataMatrix.size()
 //     << " rows: Index Offset: " << m_indxOffset << " Index Boundary: "<< m_indxBound << endmsg;
 
//  m_weightInModule.resize(m_rowsMatrix);
//  m_binDescriptor.resize(m_rowsMatrix);
 
  m_TTCmatrix.clear();
  m_TTCmatrix.resize(theTowers->size());

  // Cell Loop //
 
  // consistent phi convention
  CaloPhiRange correctPhi;
  
  // some stats 
/*   unsigned int aveTowers = 0;
  unsigned int maxTowers = 0;
  unsigned int minTowers = size_t(-1); */
 
  for( size_t cellIndex = m_indxOffset;  cellIndex <= m_indxBound; cellIndex++){
      
      
      // get cell geometry
      const CaloDetDescrElement* theElement = theManager.get_element(cellIndex);
      if (!theElement) {
        REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "LArFCalTowerStore")
          << "Can't find element for index " << cellIndex << endmsg;
        return false;
      }
      double xCell  = theElement->x();
      double yCell  = theElement->y();
      double zCell  = theElement->z();
      double dxCell = theElement->dx();
      double dyCell = theElement->dy();
 
      // get cell logical location
      int thisModule = fcalIdHelper.module(theElement->identify());
      // get cell splitting
      thisModule--;
      double theXBin   = dxCell / (double)m_ndxFCal[thisModule];
      double theYBin   = dyCell / (double)m_ndyFCal[thisModule];
      double theWeight = 1. / ((double)  m_ndxFCal[thisModule] * m_ndyFCal[thisModule]);
 
//      std::pair<size_t,double> wMod(thisModule,theWeight);
//      m_weightInModule[anIndex] = wMod;
//      std::pair<size_t,size_t> iBin(m_ndxFCal[thisModule],m_ndyFCal[thisModule]);
//      m_binDescriptor[anIndex]  = iBin;
 
      // loop the cell fragments
      for ( double x = xCell-dxCell/2.;  x < xCell+(dxCell-theXBin/8.)/2.;  x += theXBin ){
      for ( double y = yCell-dyCell/2.;y < yCell+(dyCell-theYBin/8.)/2.;y += theYBin ){
          // eta,phi of fragment
          double r   = sqrt( x * x + y * y + zCell * zCell );
          double eta = -0.5 * log((r-zCell)/(r+zCell));
          double phi = correctPhi.fix(atan2(y,x));
          // get indices
              // cppcheck-suppress duplicateAssignExpression
          CaloTowerContainer::index_t etaIndex = theTowers->flagOutOfRange();
          CaloTowerContainer::index_t phiIndex =theTowers->flagOutOfRange();
          if ( theTowers->getTowerIndices(eta,phi,etaIndex,phiIndex) ){
            
                CaloTowerContainer::index_t towerIndex = theTowers->getTowerIndex(etaIndex,phiIndex);
                std::vector<std::pair<unsigned int,double> >::iterator i = m_TTCmatrix[towerIndex].begin();
                std::vector<std::pair<unsigned int,double> >::iterator e = m_TTCmatrix[towerIndex].end();
                bool found=false;
                for (;i<e;++i){
                    if (i->first==cellIndex){
                        i->second+=theWeight;
                        found=true;
                        break;
                        }
                    }
                if (!found) 
                m_TTCmatrix[towerIndex].push_back(std::make_pair(cellIndex,theWeight));
            
            /*
            // check indices in look-up
            if ( (m_dataMatrix[anIndex]).find(towerIndex) != (m_dataMatrix[anIndex]).end() ){
              (m_dataMatrix[anIndex])[towerIndex] += theWeight;
            }
            else{
              (m_dataMatrix[anIndex])[towerIndex] = theWeight;
            }
            */
                    
            } // index retrieval check
            
        } // cell y loop
    } // cell x loop
    
/*       // collect some stats
      if ( (m_dataMatrix[anIndex]).size() < minTowers ) minTowers = (m_dataMatrix[anIndex]).size();
      if ( (m_dataMatrix[anIndex]).size() > maxTowers )maxTowers = (m_dataMatrix[anIndex]).size();
      aveTowers += (m_dataMatrix[anIndex]).size(); */
      
    } // cell index loop
 
/*   // report
  double cellTowers = (double)aveTowers / (double)m_dataMatrix.size();
  msg << MSG::INFO
      << "FCal cell/tower lookup done - min/ave/max towers/cell: "
      << minTowers << "/" << cellTowers << "/" << maxTowers
      << ", total number of cell fragments "
      << aveTowers
      << endmsg; */
  
          
 
  return 1;
 
}

firstCellofTower()

cell_iterator LArFCalTowerStore::firstCellofTower ( tower_iterator t ) const

inline

iterators: cells

Definition at line 70 of file LArFCalTowerStore.h.

{ return t->begin(); }

lastCellofTower()

cell_iterator LArFCalTowerStore::lastCellofTower ( tower_iterator t ) const

inline

Definition at line 71 of file LArFCalTowerStore.h.

{ return t->end();   }

size()

size_t LArFCalTowerStore::size ( ) const

inline

size of internal data store

Definition at line 80 of file LArFCalTowerStore.h.

{ return m_TTCmatrix.size(); }

towers() [1/2]

tower_iterator LArFCalTowerStore::towers ( ) const

inline

Definition at line 53 of file LArFCalTowerStore.h.

{ return m_TTCmatrix.begin(); }

towers() [2/2]

LArFCalTowerStore::tower_subseg_iterator LArFCalTowerStore::towers

(

const CaloTowerSeg::SubSeg &

subseg

)

const

Return an iterator for looping over all towers defined by the window subseg.

xxx

No end iterator is defined; use subseg.size() to tell when to stop the iteration.

The iteration may not be in tower index order. Use the itower() method of the iterator to find the current tower index.

Definition at line 218 of file LArFCalTowerStore.cxx.

{
  return tower_subseg_iterator::make (towers(), subseg);
}

towerSize()

unsigned int LArFCalTowerStore::towerSize ( tower_iterator t ) const

inline

Definition at line 72 of file LArFCalTowerStore.h.

{return t->size();}

Member Data Documentation

m_indxBound

size_t LArFCalTowerStore::m_indxBound

private

Definition at line 88 of file LArFCalTowerStore.h.

m_indxOffset

size_t LArFCalTowerStore::m_indxOffset

private

Definition at line 87 of file LArFCalTowerStore.h.

m_ndxFCal

std::vector<unsigned int> LArFCalTowerStore::m_ndxFCal

private

Definition at line 84 of file LArFCalTowerStore.h.

m_ndyFCal

std::vector<unsigned int> LArFCalTowerStore::m_ndyFCal

private

Definition at line 85 of file LArFCalTowerStore.h.

m_TTCmatrix

tower_table_t LArFCalTowerStore::m_TTCmatrix

private

Definition at line 90 of file LArFCalTowerStore.h.

---

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

• LArFCalTowerStore.h
• LArFCalTowerStore.cxx