Calorimeter.cxx

Go to the documentation of this file.

//                                                                      //
// RMS  calorimeter class implementation.                               //
//                                                                      //
// HTP  put into namespace & a little tidying up                        //
//                                                                      //
// PS   radically changed.                                              //


#include "AtlfastAlgs/Calorimeter.h"
#include "AtlfastAlgs/ICellSelector.h"
#include "AtlfastAlgs/CalSection.h"
#include "AtlfastEvent/IKinematic.h"
#include "AtlfastEvent/EPileupDeposit.h"
#include "AtlfastAlgs/ISmearer.h"
#include "AtlfastUtils/DeleteObject.h"
#include "AtlfastUtils/CheckNull.h"
#include "FastShowerUtils/GridletForger.h"
#include "FastShowerUtils/Gridlet.h"
#include "GaudiKernel/MsgStream.h"
#include <cmath> 
#include <vector>
#include <iostream>


namespace Atlfast {
  using std::abs;
  using FastShower::GridletForger;
  using FastShower::Gridlet;
  using FastShower::GridletElement;

  //____________________________________________________________________
  // create calorimeter as a number of CalSections
  Calorimeter::Calorimeter(
                           MsgStream& log,
                           bool  fastShower,
                           const double MaxEta,
                           const double barrelMaxEta, 
                           const double granBarrelEta,
                           const double granBarrelPhi,
                           const double granForwardEta,
                           const double granForwardPhi
                           ):m_log(log){ 
    
    m_section[0] =  new CalSection(log,
                                   abs(barrelMaxEta),  abs(MaxEta), 
                                   granForwardEta, granForwardPhi);
    
    m_section[1] =  new CalSection(log,
                                   -abs(barrelMaxEta), abs(barrelMaxEta), 
                                   granBarrelEta,  granBarrelPhi);

    m_section[2] =  new CalSection(log,
                                   -abs(MaxEta),       -abs(barrelMaxEta), 
                                   granForwardEta, granForwardPhi);

    if(fastShower) {
      m_gridletForger   = new GridletForger;
    }else{
      m_gridletForger   = 0;
    }

  }
  Calorimeter::~Calorimeter(){
    m_log<<MSG::DEBUG<<"Calorimeter destructor starts "<<endreq;
    delete m_section[0];
    delete m_section[1];
    delete m_section[2];
    delete m_gridletForger;
    m_log<<MSG::DEBUG<<"Calorimeter destructor ends "<<endreq;
  }
  Calorimeter::Calorimeter(const Calorimeter& c):m_log(c.m_log){
    //make m_sections point to different instances
    // of the CalSections, with the same value as those
    //owned by c.
    m_section[0]   = new CalSection(*(c.m_section[0]));
    m_section[1]   = new CalSection(*(c.m_section[1]));
    m_section[2]   = new CalSection(*(c.m_section[2]));
    m_gridletForger= new GridletForger(*(c.m_gridletForger));
  }
  //_____________________________________________________________________
  class Elements{
  public:
    typedef vector<const GridletElement*>    Vector;
    typedef Vector::iterator                   Iter;
    //    Elements():m_eElements(5000),m_hElements(5000){
    //    }
    ~Elements(){
      // do NOT delete the element vector pointees - they are used by the
      // clients!
    }
    void operator()(const Gridlet* g){
      std::vector<const GridletElement*> eEl = g->eElements();
      std::vector<const GridletElement*> hEl = g->hElements();

      m_eElements.insert(m_eElements.end(), eEl.begin(), eEl.end());
      m_hElements.insert(m_hElements.end(), hEl.begin(), hEl.end());
      //std::copy(eEl.begin(), eEl.end(), back_inserter(m_eElements));
      //std::copy(hEl.begin(), hEl.end(), back_inserter(m_hElements));

    }
    std::pair<Iter, Iter>  eIters(){
      return std::pair<Iter,Iter>(m_eElements.begin(),m_eElements.end());
    }
    std::pair<Iter, Iter> hIters(){
      return std::pair<Iter,Iter>(m_hElements.begin(), m_hElements.end());
    }
  private:
    Vector m_eElements;
    Vector m_hElements;
  };
  //_____________________________________________________________________
  void Calorimeter::addGridlet(Gridlet* g){m_gridlets.push_back(g);} 
  //_____________________________________________________________________
  void Calorimeter::deposit(ITransportedParticleCollectionIter& f, 
                            ITransportedParticleCollectionIter& l){
    
    ITransportedParticleCollectionIter divider = 
      std::partition(f, l, TryToShower(this));

    //    std::for_each(m_gridlets.begin(), m_gridlets.end(), CheckNull());

    // put all the elements from all gridlets into a containers    
    Elements els;
    els = std::for_each(m_gridlets.begin(), m_gridlets.end(), els);
    std::pair<Elements::Iter, Elements::Iter> ei = els.eIters();
    std::pair<Elements::Iter, Elements::Iter> hi = els.hIters();
    std::for_each(ei.first, ei.second, CheckNull());
    std::for_each(hi.first, hi.second, CheckNull());

    //    cerr<<"Calorimeter: no  of e elements "<<ei.second - ei.first<<endl;
    //    cerr<<"Calorimeter: no  of h elements "<<hi.second - hi.first<<endl;

    //Deposit Elements, generated particle energies for showered particles
    //(needed for calibration) and unshowered particles.
    for(int ind =0 ;ind<=2; ++ind){ 
      //      cerr<<"Calsection "<<ind<<endl;
      //      cerr<<" E deposits "<<endl;
      //      cerr<<" E deposits "<<endl;
      m_section[ind]->depositEcal(ei.first, ei.second);
      //      cerr<<" H deposits "<<endl;
      m_section[ind]->depositHcal(hi.first, hi.second);

      //need to make the iterators because the call is to references,
      //and so we need an object to reference. The following commented
      //out line does not work because there is nothing to reference!
      std::vector<const Gridlet*>::iterator b = m_gridlets.begin();
      std::vector<const Gridlet*>::iterator e = m_gridlets.end();
      //      cerr<<" Egen deposits "<<endl;
      m_section[ind]->depositEgen(b, e);

      //m_section[ind]->depositEgen(m_gridlets.begin(), m_gridlets.end());
      //      cerr<<" Particle deposits "<<endl;
      m_section[ind]->deposit(divider, l);
    }
    // the iterators have been messed around with , so get a fresh set before
    // deleting the elements
    ei = els.eIters();
    hi = els.hIters();
    std::for_each(ei.first, ei.second, DeleteObject());
    std::for_each(hi.first, hi.second, DeleteObject());
  }
  //_____________________________________________________________________
    // deposit energy pileup
  void 
  Calorimeter::deposit(std::vector<Atlfast::EPileupDeposit*>::iterator& f, 
                       std::vector<Atlfast::EPileupDeposit*>::iterator& l)
    const{
    //send energy pileup to calorimeter sections
    for(int ind =0 ;ind<=2; ++ind){
      m_section[ind]->deposit(f, l);
    }

    }
  //__________________________________________________________________
  const GridletForger*  Calorimeter::gridletForger() const {
    return m_gridletForger;
  }
  //__________________________________________________________________
  MsgStream&  Calorimeter::msgStream() const {return m_log;}
  //__________________________________________________________________
  void Calorimeter::giveHitCells(const ICellSelector* p_cellSelector, 
                                 ITwoCptCellCollection* cells)  {
    
    // return cells in calorimeter passed by cellSelector
    // could make type change from Calorimeter cells to TES cells here 
    
    for(int ind=0; ind<=2; ++ind) {
      m_section[ind]->giveHits(p_cellSelector, cells);
    }
  }
    
  //_______________________________________________________________________
  void Calorimeter::reset(){

    for(int ind=0; ind<=2; ++ind) {m_section[ind]->reset();}

    std::for_each(m_gridlets.begin(), m_gridlets.end(), DeleteObject());
    m_gridlets.clear();

  }
  //_______________________________________________________________________
  void Calorimeter::smearCells(ISmearer* p_smearer)
  {
    for(int ind=0; ind<=2; ++ind) {
      m_section[ind]->smearCells(p_smearer);
    }
  }
} // end of namespace bracket

---