//////////////////////////////////////////////////////////////////////////
 //                                                                      //
 // 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 "AtlfastUtils/ISmearer.h"
 #include "AtlfastUtils/DeleteObject.h"
 #include "AtlfastUtils/CheckNull.h"
 
 #include "AtlfastEvent/IKinematic.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,
                            const std::string detEffectsFileName
                            ):m_log(log){ 
     
     m_section[0] =  new CalSection(log,
                                    abs(barrelMaxEta),  abs(MaxEta), 
                                    granForwardEta, granForwardPhi, detEffectsFileName);
     
     m_section[1] =  new CalSection(log,
                                    -abs(barrelMaxEta), abs(barrelMaxEta), 
                                    granBarrelEta,  granBarrelPhi, detEffectsFileName);
 
     m_section[2] =  new CalSection(log,
                                    -abs(MaxEta),       -abs(barrelMaxEta), 
                                    granForwardEta, granForwardPhi, detEffectsFileName);
 
     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(){
       // 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::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));
 
 
     // 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){ 
       m_section[ind]->depositEcal(ei.first, ei.second);
       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. 
       std::vector<const Gridlet*>::iterator b = m_gridlets.begin();
       std::vector<const Gridlet*>::iterator e = m_gridlets.end();
       m_section[ind]->depositEgen(b, e);
 
       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());
   }
   //__________________________________________________________________
   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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.