CaloLayerCalculator.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: CaloLayerCalculator.h,v 1.1 2006-03-20 17:42:26 ssnyder Exp $
 
#ifndef CALOUTILS_CALOLAYERCALCULATOR_H
#define CALOUTILS_CALOLAYERCALCULATOR_H
 
#include "CaloDetDescr/CaloDetDescrManager.h"
#include "CaloGeoHelpers/CaloSampling.h"
#include "CaloGeoHelpers/CaloPhiRange.h"
#include "CaloEvent/CaloClusterCellLink.h"
#include "Navigation/NavigableIterator.h"
 
#include "GaudiKernel/StatusCode.h"
#include <string>
 
#include "xAODCaloEvent/CaloCluster.h"
#include "xAODCaloEvent/CaloClusterKineHelper.h"
 
class CaloCellContainer;
class CaloCell;
 
class CaloLayerCalculator
{
public:

  CaloLayerCalculator();
 

  template <typename Iterator>
  void fill (Iterator beg,
             Iterator end,
             double eta,
             double phi,
             double deta,
             double dphi,
             CaloSampling::CaloSample sampling,
             xAOD::CaloCluster* tofill = 0);
 

  StatusCode fill (const CaloDetDescrManager& mgr,
                   const CaloCellContainer* cell_container,
                   double eta,
                   double phi,
                   double deta,
                   double dphi,
                   CaloSampling::CaloSample sampling,
                   xAOD::CaloCluster* tofill = 0);
 



  double etam()   const;
 

  double phim()   const;
 

  double etas()   const;
 

  double phis()   const;
 

  double em()     const;
 

  double etamax() const;
 

  double phimax() const;
 

  double emax()   const;

  double phimr() const { return m_phimr; }
  double etamr() const { return m_etamr; }
  double phirmax() const { return m_phirmax; }
  double etarmax() const { return m_etarmax; }

private:

  void reset();

  void resetOnNegativeEnergy();

  void resetOnNegativeEnergy(double eta, double phi);
 

  template <typename Iterator>
  static double get_weight (Iterator it);

  double get_weight(CaloClusterCellLink::const_iterator it);

  double get_weight(CaloClusterCellLink::iterator it);

  template <typename CONT, typename RPAR, typename COLL>
  double get_weight (NavigableIterator<CONT,RPAR,COLL> it);
 

  double   m_etam = 0.0;    // Mean @f$\eta@f$.
  double   m_phim = 0.0;    // Mean @f$\phi@f$.
  double   m_etas = 0.0;    // RMS @f$\eta@f$.
  double   m_phis = 0.0;    // RMS @f$\phi@f$.
  double   m_em = 0.0;      // Total energy.
  double   m_etamax = 0.0;  // @f$\eta@f$ center of maximum-energy cell.
  double   m_phimax = 0.0;  // @f$\phi@f$ center of maximum-energy cell.
  double   m_emax = 0.0;    // Energy of maximum-energy cell.
 
  // Added to cluster in the calorimeter frame
  double   m_etamr = 0.0;  // Mean @f$\eta@f$ with raw quantity
  double   m_phimr = 0.0;  // Mean @f$\phi@f$ with raw quantity
  double   m_etarmax = 0.0;  // @f$\eta_raw@f$ center of maximum-energy cell.
  double   m_phirmax = 0.0;  // @f$\phi_raw@f$ center of maximum-energy cell.
 

  struct Helper
  {
    Helper (CaloLayerCalculator& calc,
            double eta,
            double phi,
            double deta,
            double dphi,
            CaloSampling::CaloSample sampling,
            xAOD::CaloCluster* tofill,
            const CaloCellContainer* cell_container);
 

    void cell (const CaloCell* cell, double weight);
 

    ~Helper();
 

    CaloLayerCalculator& m_calc;
    double m_eta;
    double m_phi;
    double m_deta;
    double m_dphi;
    CaloSampling::CaloSample m_sampling;
    xAOD::CaloCluster* m_tofill;
    const CaloCellContainer* m_cell_container;

    double m_s00; // energy sum.
    double m_s10; // eta-weighted energy sum.
    double m_s20; // eta^2-weighted energy sum.
    double m_s01; // phi-weighted energy sum.
    double m_s02; // phi^2-weighted energy sum.
 
    // Added to cluster in the calorimeter frame
    double m_s10r; // eta_raw-weighted energy sum.
    double m_s01r; // phi_raw-weighted energy sum.
  };
  friend struct Helper;
};
 

template <typename Iterator>
void CaloLayerCalculator::fill (Iterator beg,
                                Iterator end,
                                double eta,
                                double phi,
                                double deta,
                                double dphi,
                                CaloSampling::CaloSample sampling,
                                xAOD::CaloCluster* tofill /*= 0*/)
{
  reset();
  const CaloCellContainer* cell_container=0;
  if (tofill) cell_container=tofill->getCellLinks()->getCellContainer();
  if (beg != end) {
    Helper h (*this, eta, phi, deta, dphi, sampling, tofill, cell_container);
    for (; beg != end; ++beg)
      h.cell (*beg, get_weight (beg));
  }
}
 

inline
double CaloLayerCalculator::etam()   const
{
  return m_etam;
}
 

inline
double CaloLayerCalculator::phim()   const
{
  return m_phim;
}
 

inline
double CaloLayerCalculator::etas()   const
{
  return m_etas;
}
 

inline
double CaloLayerCalculator::phis()   const
{
  return m_phis;
}
 

inline
double CaloLayerCalculator::em()     const
{
  return m_em;
}
 

inline
double CaloLayerCalculator::etamax() const
{
  return m_etamax;
}
 

inline
double CaloLayerCalculator::phimax() const
{
  return m_phimax;
}
 

inline
double CaloLayerCalculator::emax()   const
{
  return m_emax;
}
 

template <typename Iterator>
inline
double CaloLayerCalculator::get_weight (Iterator /*it*/)
{
  return 1;
}
 

template <typename CONT, typename RPAR, typename COLL>
inline
double CaloLayerCalculator::get_weight (NavigableIterator<CONT,RPAR,COLL> it)
{
  return it.getParameter();
}
 
inline
double CaloLayerCalculator::get_weight(CaloClusterCellLink::const_iterator it)
{
  return it.weight();
}
 
 
inline
double CaloLayerCalculator::get_weight(CaloClusterCellLink::iterator it)
{
  return it.weight();
}
 
 
#endif // not CALOUTILS_CALOLAYERCALCULATOR_H