---

CalSection.cxx

Go to the documentation of this file.

//                                                                      //
// PS   CalSection.                                                     //
// 00/09/06                                                             //
//                                                                      //
// build an array of cells spanning the eta and phi ranges passed in the//
// constructor. The granularities used are the closest to the requested //
// values, but which divide exactly into the requested ranges.          //
//                                                                      //
//                                                                      //
//                                                                      //
//                                                                      //
//                                                                      //


#include "AtlfastAlgs/CalSection.h"
#include <iostream>
#include <assert.h>
#include <algorithm>
#include "AtlfastEvent/Cell.h"
#include "AtlfastAlgs/ICellSelector.h"
#include "AtlfastAlgs/ISmearer.h"
#include "AtlfastAlgs/TransportedParticle.h"
#include "GaudiKernel/MsgStream.h"
#include "AtlfastEvent/EPileupDeposit.h"
#include "CLHEP/Vector/LorentzVector.h"
namespace Atlfast {

//____________________________________________________________________
  CalSection::CalSection(
                         MsgStream& log,
                         double minEta,
                         double maxEta,
                         double granEta,
                         double granPhi,
                         double minPhi,
                         double maxPhi
                         ):
  m_minEta(minEta), m_maxEta(maxEta),
  m_minPhi(minPhi), m_maxPhi(maxPhi),
  m_calSectionReject(minEta, maxEta, minPhi, maxPhi)
  {
    log <<MSG::DEBUG<< "CalSection: construction. Eta range: "
        <<minEta<<" - "<<maxEta<<endreq; 
    log <<MSG::DEBUG<< "                          Phi range: "
        <<minPhi<<" - "<<maxPhi<<endreq; 
    log <<MSG::DEBUG<< " starting granularity Eta: "<<granEta
        << " phi: "<<granPhi
        <<endreq;

    log <<MSG::DEBUG<<"CalSectionReject parameters:"<<endreq;
    log <<MSG::DEBUG<<m_calSectionReject<<endreq;

    int nEta    = int(((maxEta-minEta)/granEta)+0.5);
    m_granEta   = (maxEta-minEta)/int(nEta);
    m_nPhi      = 1+int(((m_maxPhi-m_minPhi)/granPhi)+0.5);
    m_granPhi   = (m_maxPhi-m_minPhi)/double(m_nPhi); 
    log <<MSG::DEBUG<< " final granularity Eta: "<<m_granEta
        << " phi: "<<m_granPhi
        <<endreq; 
    log <<MSG::DEBUG<< " final Bins in Eta: "<<nEta
        << " phi: "<<m_nPhi
        <<endreq; 

    for (int ieta=0; ieta<nEta; ieta++){
      for (int iphi=0; iphi<m_nPhi; iphi++){
        
        double eta        = minEta+((double(ieta)+0.5)*double(m_granEta));
        double phi        = m_minPhi + ((double(iphi)+0.5)*double(m_granPhi));
        CellDescriptor id = CellDescriptor(eta,phi);
        Cell* cell        = new Cell(id);
        
        m_cells.push_back(cell);
      }
    } 
  }
  CalSection::~CalSection(){
    std::vector<Cell*>::iterator i=m_cells.begin();
    for(;i<m_cells.end();++i) delete *i;
  }
  CalSection::CalSection(const CalSection& c):
    m_minEta(c.m_minEta),
    m_maxEta(c.m_maxEta),
    m_minPhi(c.m_minPhi),
    m_maxPhi(c.m_maxPhi),
    m_calSectionReject(c.m_calSectionReject){
    std::vector<Cell*>::const_iterator i=c.m_cells.begin();
    for(;i<c.m_cells.end();++i) m_cells.push_back(new Cell(*(*i)));
  }
  //----------------------------------------------------------------
  void CalSection::deposit(TransportedParticleCollectionIter& f, 
                           TransportedParticleCollectionIter& l){
    // remove particles not in acceptance
    TransportedParticleCollectionIter divider;
    divider = std::partition(f, l, m_calSectionReject);

    // fill cells 
    TransportedParticleCollectionCIter i=divider;
    for(; i<l; ++i) newHit(i);

    // assume sections do not overlap: do not reprocess.
    // hits processed here: set last to end of unprocessed hits
    l=divider;
  }
  //----------------------------------------------------------------
  void CalSection::newHit( const TransportedParticleCollectionCIter& tpPtr){
    const HepMC::GenParticle* particle = (*tpPtr)->particle();
    const double eta = particle->momentum().pseudoRapidity();
    const double phi = (*tpPtr)->phi();
    //    if(eta <= m_minEta || eta > m_maxEta) return;   
    //    if(phi <= m_minPhi || phi > m_maxPhi) return false;
    
    int iphi = int((phi-m_minPhi)/m_granPhi);
    int ieta = int((eta-m_minEta)/m_granEta);

    int index = m_nPhi*ieta  + iphi;
    //check cell is reasonable
    Cell* cell = m_cells[index];
    assert(abs(eta-(cell->eta()))<m_granEta);
    assert(abs(phi-(cell->phi()))<m_granPhi);
    cell->newHit(particle);
    //use a map to store pointers to hit cells to avoid
    //duplicate entries if the cell is hit more than once.
    m_hitCells[index] = cell;

    return;
  }

  //----------------------------------------------------------------
  // FOR ENERGY PILEUP METHODS
  //----------------------------------------------------------------
  void CalSection::deposit(std::vector<Atlfast::EPileupDeposit*>::iterator& f, 
                           std::vector<Atlfast::EPileupDeposit*>::iterator& l){
    // remove pileup deposits not in acceptance
    std::vector<Atlfast::EPileupDeposit*>::iterator divider;
    divider = std::partition(f, l, m_calSectionReject);

    // fill cells 
    std::vector<Atlfast::EPileupDeposit*>::iterator  i=divider;
    for(; i<l; ++i) newHit(i);

    // assume sections do not overlap: do not reprocess.
    // hits processed here: set last to end of unprocessed hits
    l=divider;
  }

  //----------------------------------------------------------------
  void CalSection::newHit( const std::vector<Atlfast::EPileupDeposit*>::iterator& tpPtr){
    const double eta = (*tpPtr)->eta();
    const double phi = (*tpPtr)->phi();
    int iphi = int((phi-m_minPhi)/m_granPhi);
    int ieta = int((eta-m_minEta)/m_granEta);
    int index = m_nPhi*ieta  + iphi;
    //check cell is reasonable
    Cell* cell = m_cells[index];
    assert(abs(eta-(cell->eta()))<m_granEta);
    assert(abs(phi-(cell->phi()))<m_granPhi);
    cell->newHit(*tpPtr);
     //use a map to store pointers to hit cells to avoid
    //duplicate entries if the cell is hit more than once.
    m_hitCells[index] = cell;
    return;
  }
  //=============================================================================
  void CalSection::giveHits
    (const ICellSelector* p_cellselect, CellCollection* cells) const{
    std::map<int, Cell*, std::less<int> >::const_iterator i;
    for(i=m_hitCells.begin(); i!=m_hitCells.end(); ++i){
      //test cell before newing and filling vector
      if( (*p_cellselect) (((*i).second))){ 
        Cell* cell = new Cell(*((*i).second));
      //Need to copy cells because Athena deletes container AND POINTERS
      // AND POINTEES
        cells->push_back(cell);
      }
    }

  }
  //=============================================================================
  void CalSection::smearCells
    (ISmearer* p_smearer) {
    std::map<int, Cell*, std::less<int> >::const_iterator i;
    for(i=m_hitCells.begin(); i!=m_hitCells.end(); ++i){
      if((*((*i).second)).momentum().e() > 0){
        HepLorentzVector temp = p_smearer->smear((*((*i).second)).momentum());
          (*((*i).second)).setPt(temp);
      }
    }
  }



  void CalSection::reset(){
    //reset the cells of this CalSection

    std::map<int, Cell*>::const_iterator i = m_hitCells.begin();
    for(;i!=m_hitCells.end();++i) (*i).second->resetCell();
    m_hitCells.erase(m_hitCells.begin(), m_hitCells.end());
  }
}

    
    
  

---