---

Gridlet.cxx

Go to the documentation of this file.

//implementation for Gridlet
#include "FastShowerUtils/Gridlet.h"
//#include "FastShowerUtils/GridletIterator.h"
#include "FastShowerUtils/Phi.h"
#include <iostream>
#include <iomanip>
#include <numeric>
#include <iterator>
#include <algorithm>
namespace FastShower{
  //
  const double Gridlet::s_etaStep(0.1);
  const double Gridlet::s_phiStep(0.1);
  Gridlet::Gridlet(double eta, double phi):
    m_eta0     ( eta ), 
    m_phi0     ( phi ), 
    m_eDeps    ( DepositsType() ), 
    m_hDeps    ( DepositsType() ),
    m_eDepIters( m_eDeps.begin(), m_eDeps.end() ),
    m_hDepIters( m_hDeps.begin(), m_hDeps.end() )
  {
  }
  double  Gridlet::phi0() const { return m_phi0;}
  double  Gridlet::eta0() const { return m_eta0;}
  double  Gridlet::phi(int index) const {
    int dim = this->dimension();
    return Phi( m_phi0 +((index/dim) - (dim/2) )*s_phiStep);
  }
  double  Gridlet::eta(int index) const {
    int dim = this->dimension();
    return (m_eta0 +((index%dim) - (dim/2) )*s_etaStep);
  }
  class FillGridletElementVector{
  public:
    FillGridletElementVector(const Gridlet* g): m_g(g), m_ind(0){}
    void operator()(double e){
      //do not return if e=0 - need to bump m_ind first!
      if(e > 0.){
        m_elements.push_back(
                             new GridletElement(m_g->phi(m_ind), 
                                                m_g->eta(m_ind), 
                                                e
                                                )
                             );
      }
      ++m_ind;
    }
    std::vector<GridletElement*> elements() const {return m_elements;}
  private:
    const Gridlet* m_g;
    int m_ind;
    std::vector<GridletElement*> m_elements;
  };
                           
  std::vector<GridletElement*> Gridlet::eElements() const {
    
    DepIterPair dip = this->eIters();
    
    FillGridletElementVector fv( this);

    return ( (std::for_each(dip.first, dip.second, fv)).elements() );
  }
  std::vector<GridletElement*>  Gridlet::hElements() const {
    
    DepIterPair dip = this->hIters();
    
    FillGridletElementVector fv( this);

    return ( (std::for_each(dip.first, dip.second, fv)).elements() );
  }
  double Gridlet::eSumE() const{
    double sum = 0.0;
    std::vector<GridletElement*> elements = eElements();
    std::vector<GridletElement*>::const_iterator itr, end;
    itr = elements.begin();
    end = elements.end();
    while (itr != end)
      sum += (*itr++)->e();
    return sum;
  }
  double Gridlet::hSumE() const{
    double sum = 0.0;
    std::vector<GridletElement*> elements = hElements();
    std::vector<GridletElement*>::const_iterator itr, end;
    itr = elements.begin();
    end = elements.end();
    while (itr != end)
      sum += (*itr++)->e();
    return sum;
  }
  
  double Gridlet::eSumEt() const{
    double sum = 0.0;
    std::vector<GridletElement*> elements = eElements();
    std::vector<GridletElement*>::const_iterator itr, end;
    itr = elements.begin();
    end = elements.end();
    while (itr != end)
      sum += (*itr++)->et();
    return sum;
  }
  double Gridlet::hSumEt() const{
    double sum = 0.0;
    std::vector<GridletElement*> elements = hElements();
    std::vector<GridletElement*>::const_iterator itr, end;
    itr = elements.begin();
    end = elements.end();
    while (itr != end)
      sum += (*itr++)->et();
    return sum;
  }
  
  

  std::ostream& operator<<(ostream& out, Gridlet& g){
    int dim = g.dimension();
    
    class PrintLine{
    public:
      std::ostream& operator()(Gridlet::DepositsType::ConstIter iter,
                               int dim,
                               std::ostream& out){
        out<<setiosflags(ios::fixed);
        for(;dim !=0; --dim){ out<<setw(8)<<setprecision(3)<<*iter++<<" ";}
        out<<endl;
        return out;
      }
    };
    
    // sum Ecal deposits
    double sumE = std::accumulate(g.eIters().first, g.eIters().second, 0.0);

    // sum Hcal deposits
    double sumH = std::accumulate(g.hIters().first, g.hIters().second, 0.0);


    int row;
    out<<setw(8);
    out<<setprecision(3);

    PrintLine p;
      
    Gridlet::DepositsType::ConstIter iter;

    out<<" phi"<<endl;
    out<<" ^"<<endl;
    out<<" |"<<endl;
    out<<" |"<<endl;
    out<<" ---> eta "<<endl;

    out<<endl<<"Hit cell:  phi, eta "<<g.phi0()<<" "<<g.eta0()<<" "<<endl;
    out<<endl<<"Ecal: E/Et sum = "<<sumE<<" / "<<g.eSumEt()<<endl<<endl;

    iter = g.eIters().second;
    for(row=dim; row!=0; --row){
      std::advance( iter, -dim);
      p(iter, dim, out);
      //      std::copy(iter, iter+dim, ostream_iterator<double>(out," "); 
    }
    //

    out<<endl<<"Hcal: E/Et sum = "<<sumH<<" / "<<g.hSumEt()<<endl<<endl;

    iter = g.hIters().second;
    for(row=dim; row!=0; --row){
      std::advance( iter, -dim);
      p(iter, dim, out);
      //      std::copy(iter, iter+dim, ostream_iterator<double>(out," ")); 
    }
    //
    out<<"============================================="<<endl;
    out<<endl;
    return out;
  }
  std::ostream& operator<<(ostream& out, Gridlet* g){
    out<<*g;
    return out;
  }
    
      
}//namespace
 

---