CaloCellGeometry.h

Go to the documentation of this file.

#ifndef GEOMETRY_CALOGEOMETRY_CALOCELLGEOMETRY_H
#define GEOMETRY_CALOGEOMETRY_CALOCELLGEOMETRY_H 1

#include "Geometry/CaloGeometry/interface/EZArrayFL.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include <CLHEP/Geometry/Point3D.h>
#include <CLHEP/Geometry/Transform3D.h>
#include "DataFormats/Math/interface/PtEtaPhiMass.h"

#include <vector>
#include <array>
#include <string>
#include <cassert>


class CaloCellGeometry 
{
public:

  typedef float                      CCGFloat ;
  typedef HepGeom::Transform3D       Tr3D     ;
  typedef HepGeom::Point3D<CCGFloat> Pt3D     ;
  typedef std::vector<Pt3D>          Pt3DVec  ;

  typedef EZArrayFL< GlobalPoint > CornersVec ;
  typedef EZMgrFL< GlobalPoint >   CornersMgr ;

  typedef EZArrayFL<CCGFloat> ParVec ;
  typedef std::vector<ParVec> ParVecVec ;
  typedef EZMgrFL< CCGFloat > ParMgr ;

  static constexpr unsigned int k_cornerSize = 8;

  using RepCorners = std::array<RhoEtaPhi,k_cornerSize>;
  

  static const CCGFloat k_ScaleFromDDDtoGeant ;

  virtual ~CaloCellGeometry() ;
      
  CornersVec const& getCorners() const { assert(not m_corners.uninitialized()); return m_corners; }
  RepCorners const& getCornersREP() const {  return m_repCorners;}

  
  virtual const GlobalPoint& getPosition()             const {return m_refPoint;}
  virtual GlobalPoint getPosition( CCGFloat)    const {return m_refPoint;}
  virtual GlobalPoint getPosition( const Pt3D&) const {return m_refPoint;}

  GlobalPoint const& getBackPoint() const {return m_backPoint;} 

  RhoEtaPhi const& repPos() const { return m_rep;}
  float rhoPos() const { return m_rep.rho();}
  float etaPos() const { return m_rep.eta();}
  float phiPos() const { return m_rep.phi();}

  float etaSpan() const { return m_dEta;}
  float phiSpan() const { return m_dPhi;}


  bool inside( const GlobalPoint & point ) const ;  

  bool emptyCorners() const { return m_corners.empty() ;}

  const CCGFloat* param() const { return m_parms ;}

  static const CCGFloat* checkParmPtr( const std::vector<CCGFloat>& vd  ,
                       ParVecVec&                   pvv   ) ;

  static const CCGFloat* getParmPtr( const std::vector<CCGFloat>& vd  ,
                     ParMgr*                      mgr ,
                     ParVecVec&                   pvv   ) ;


  virtual void getTransform( Tr3D& tr, Pt3DVec* lptr ) const ;
  //------------------------------------------------------------------------
  void setBackPoint (const GlobalPoint& pos) {m_backPoint = pos;}

  virtual void vocalCorners( Pt3DVec&        vec ,
                 const CCGFloat* pv  ,
                 Pt3D&           ref  ) const = 0 ;

protected:

  CaloCellGeometry( CornersVec::const_reference gp ,
            CornersMgr*                 mgr,
            const CCGFloat*             par ) ;

  CaloCellGeometry( const CornersVec& cv,
            const CCGFloat*   par ) ;

  CaloCellGeometry( void );

  // MUST be called by children constructors
  void initSpan() {
     initCorners(m_corners);
     m_dEta = std::abs(getCorners()[0].eta()-
                      getCorners()[2].eta());
     m_dPhi = std::abs(getCorners()[0].phi() -
                      getCorners()[2].phi());
     initBack();
     initReps();
  }

  virtual void initCorners(CornersVec&) = 0;

  void setRefPoint  (const GlobalPoint& pos) {m_refPoint  = pos;}
  void setCornerVec (const std::vector<GlobalPoint>&  cor) {
    for (unsigned int k=0; k<cor.size(); ++k) 
      m_corners[k] = cor[k];
  }

private:

 void initBack() {
   // from CaloTower code
   CornersVec const & cv = getCorners();
    m_backPoint = GlobalPoint(0.25 * (cv[4].x() + cv[5].x() + cv[6].x() + cv[7].x()),
                              0.25 * (cv[4].y() + cv[5].y() + cv[6].y() + cv[7].y()),
                              0.25 * (cv[4].z() + cv[5].z() + cv[6].z() + cv[7].z()));   
  }
  void initReps() {
    for (auto i=0U;i<k_cornerSize; ++i) m_repCorners[i]= {getCorners()[i].perp(), getCorners()[i].eta(), getCorners()[i].barePhi()}; 
      
  }
  

  GlobalPoint         m_refPoint ;
  GlobalPoint         m_backPoint ;
  CornersVec          m_corners  ;
  const CCGFloat*     m_parms    ;
  RhoEtaPhi m_rep;
  float m_dEta;
  float m_dPhi;
  std::array<RhoEtaPhi,k_cornerSize> m_repCorners;
};

std::ostream& operator<<( std::ostream& s, const CaloCellGeometry& cell ) ;


#endif