#include <HGCalGeometry.h>

Inheritance diagram for HGCalGeometry:

Public Types
typedef HGCalGeometryRecord	AlignedRecord

typedef CaloCellGeometry::CCGFloat	CCGFloat

typedef std::vector< FlatHexagon >	CellVec

typedef std::vector< FlatTrd >	CellVec2

typedef std::vector< GlobalPoint >	CornersVec

typedef std::set< DetId >	DetIdSet

typedef PHGCalRcd	PGeometryRecord

typedef CaloCellGeometry::Pt3D	Pt3D

typedef CaloCellGeometry::Pt3DVec	Pt3DVec

Public Types inherited from CaloSubdetectorGeometry
typedef CaloCellGeometry::CCGFloat	CCGFloat

typedef std::vector< std::shared_ptr< const CaloCellGeometry > >	CellSet

typedef std::set< DetId >	DetIdSet

typedef std::vector< CCGFloat >	DimVec

typedef std::vector< unsigned int >	IVec

typedef CaloCellGeometry::ParMgr	ParMgr

typedef CaloCellGeometry::ParVec	ParVec

typedef CaloCellGeometry::ParVecVec	ParVecVec

typedef std::vector< CCGFloat >	TrVec

Public Member Functions
std::string	cellElement () const

virtual void	fillNamedParams (DDFilteredView fv)

CornersVec	get8Corners (const DetId &id) const

double	getArea (const DetId &detid) const
	Returns area of a cell. More...

DetIdSet	getCells (const GlobalPoint &r, double dR) const override
	Get a list of all cells within a dR of the given cell. More...

DetId	getClosestCell (const GlobalPoint &r) const override

CornersVec	getCorners (const DetId &id) const
	Returns the corner points of this cell's volume. More...

std::shared_ptr< const CaloCellGeometry >	getGeometry (const DetId &id) const override
	Get the cell geometry of a given detector id. Should return false if not found. More...

CornersVec	getNewCorners (const DetId &id) const

GlobalPoint	getPosition (const DetId &id) const

void	getSummary (CaloSubdetectorGeometry::TrVec &trVector, CaloSubdetectorGeometry::IVec &iVector, CaloSubdetectorGeometry::DimVec &dimVector, CaloSubdetectorGeometry::IVec &dinsVector) const override

const std::vector< DetId > &	getValidDetIds (DetId::Detector det=DetId::Detector(0), int subdet=0) const override
	Get a list of valid detector ids (for the given subdetector) More...

const std::vector< DetId > &	getValidGeomDetIds (void) const

	HGCalGeometry (const HGCalTopology &topology)

void	initializeParms () override

void	localCorners (Pt3DVec &lc, const CCGFloat *pv, unsigned int i, Pt3D &ref)

DetId	neighborZ (const DetId &idin, const GlobalVector &p) const

DetId	neighborZ (const DetId &idin, const MagneticField *bField, int charge, const GlobalVector &momentum) const

void	newCell (const GlobalPoint &f1, const GlobalPoint &f2, const GlobalPoint &f3, const CCGFloat *parm, const DetId &detId) override

bool	present (const DetId &id) const override
	is this detid present in the geometry? More...

void	sortDetIds ()

const HGCalTopology &	topology () const

	~HGCalGeometry () override

Public Member Functions inherited from CaloSubdetectorGeometry
void	allocateCorners (CaloCellGeometry::CornersVec::size_type n)

void	allocatePar (ParVec::size_type n, unsigned int m)

	CaloSubdetectorGeometry ()

	CaloSubdetectorGeometry (const CaloSubdetectorGeometry &)=delete
	avoid copies More...

CaloCellGeometry::CornersMgr *	cornersMgr ()

CCGFloat	deltaEta (const DetId &detId) const

CCGFloat	deltaPhi (const DetId &detId) const

virtual void	fillDefaultNamedParameters () const

virtual CellSet	getCellSet (const GlobalPoint &r, double dR) const

virtual unsigned int	numberOfParametersPerShape () const

virtual unsigned int	numberOfShapes () const

virtual unsigned int	numberOfTransformParms () const

CaloSubdetectorGeometry &	operator= (const CaloSubdetectorGeometry &)=delete

ParMgr *	parMgr ()

const ParMgr *	parMgrConst () const

ParVecVec &	parVecVec ()

const ParVecVec &	parVecVec () const

virtual	~CaloSubdetectorGeometry ()
	The base class DOES assume that it owns the CaloCellGeometry objects. More...

Static Public Member Functions
static std::string	dbString ()

static std::string	producerTag ()

Static Public Attributes
static unsigned int	k_NumberOfParametersPerHex = 3

static unsigned int	k_NumberOfParametersPerShape = 3

static unsigned int	k_NumberOfParametersPerTrd = 12

static unsigned int	k_NumberOfShapes = 100

static unsigned int	k_NumberOfShapesTrd = 1000

Protected Member Functions
void	addValidID (const DetId &id)

std::shared_ptr< const CaloCellGeometry >	cellGeomPtr (uint32_t index) const override

unsigned int	getClosestCellIndex (const GlobalPoint &r) const

const CaloCellGeometry *	getGeometryRawPtr (uint32_t index) const override

unsigned int	indexFor (const DetId &id) const override

unsigned int	sizeForDenseIndex () const

Protected Member Functions inherited from CaloSubdetectorGeometry
void	addValidID (const DetId &id)

virtual unsigned int	sizeForDenseIndex (const DetId &id) const

Private Member Functions
std::shared_ptr< const CaloCellGeometry >	cellGeomPtr (uint32_t index, const GlobalPoint &p) const

template<class T >
unsigned int	getClosestCellIndex (const GlobalPoint &r, const std::vector< T > &vec) const

DetId	getGeometryDetId (DetId detId) const

Private Attributes
CellVec	m_cellVec

CellVec2	m_cellVec2

DetId::Detector	m_det

ForwardSubdetector	m_subdet

const HGCalTopology &	m_topology

std::vector< DetId >	m_validGeomIds

HGCalGeometryMode::GeometryMode	mode_

const double	twoBysqrt3_

Static Private Attributes
static double	k_fac1 = 0.5

static double	k_fac2 = 1.0/3.0

static double	k_half = 0.5

Additional Inherited Members
Static Protected Member Functions inherited from CaloSubdetectorGeometry
static CCGFloat	deltaR (const GlobalPoint &p1, const GlobalPoint &p2)

Protected Attributes inherited from CaloSubdetectorGeometry
ParVecVec	m_parVecVec

std::vector< DetId >	m_validIds

Detailed Description

Definition at line 30 of file HGCalGeometry.h.

Member Typedef Documentation

typedef HGCalGeometryRecord HGCalGeometry::AlignedRecord

Definition at line 43 of file HGCalGeometry.h.

typedef CaloCellGeometry::CCGFloat HGCalGeometry::CCGFloat

Definition at line 36 of file HGCalGeometry.h.

typedef std::vector<FlatHexagon> HGCalGeometry::CellVec

Definition at line 34 of file HGCalGeometry.h.

typedef std::vector<FlatTrd> HGCalGeometry::CellVec2

Definition at line 35 of file HGCalGeometry.h.

typedef std::vector<GlobalPoint> HGCalGeometry::CornersVec

Definition at line 41 of file HGCalGeometry.h.

typedef std::set<DetId> HGCalGeometry::DetIdSet

Definition at line 40 of file HGCalGeometry.h.

typedef PHGCalRcd HGCalGeometry::PGeometryRecord

Definition at line 44 of file HGCalGeometry.h.

typedef CaloCellGeometry::Pt3D HGCalGeometry::Pt3D

Definition at line 37 of file HGCalGeometry.h.

typedef CaloCellGeometry::Pt3DVec HGCalGeometry::Pt3DVec

Definition at line 38 of file HGCalGeometry.h.

Constructor & Destructor Documentation

HGCalGeometry::HGCalGeometry ( const HGCalTopology & topology )

Definition at line 26 of file HGCalGeometry.cc.

References DetId::HGCalHSc, m_cellVec, m_cellVec2, m_det, m_topology, CaloSubdetectorGeometry::m_validIds, HGCalTopology::totalGeomModules(), and HGCalTopology::totalModules().

Referenced by dbString().

   : m_topology( topology_ ),
     m_validGeomIds( topology_.totalGeomModules()),
     mode_( topology_.geomMode()),
     m_det( topology_.detector()),
     m_subdet( topology_.subDetector()),
     twoBysqrt3_(2.0/std::sqrt(3.0)) {
   
   if (m_det == DetId::HGCalHSc) {
     m_cellVec2 = CellVec2(topology_.totalGeomModules());
   } else {
     m_cellVec = CellVec(topology_.totalGeomModules());
   }
   m_validIds.reserve( m_topology.totalModules());
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "Expected total # of Geometry Modules " 
                 << m_topology.totalGeomModules();
 #endif
 }

HGCalGeometry::~HGCalGeometry ( )

override

Definition at line 46 of file HGCalGeometry.cc.

Referenced by dbString().

46 { }

Member Function Documentation

void HGCalGeometry::addValidID ( const DetId & id )

protected

Definition at line 653 of file HGCalGeometry.cc.

Referenced by topology().

                                               {
   edm::LogError("HGCalGeom") << "HGCalGeometry::addValidID is not implemented";
 }

std::string HGCalGeometry::cellElement ( ) const

Definition at line 574 of file HGCalGeometry.cc.

References DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, HGCEE, HGCHEB, HGCHEF, m_det, and m_subdet.

Referenced by producerTag().

                                            {
   if      (m_subdet == HGCEE  || m_det == DetId::HGCalEE)  return "HGCalEE";
   else if (m_subdet == HGCHEF || m_det == DetId::HGCalHSi) return "HGCalHEFront";
   else if (m_subdet == HGCHEB || m_det == DetId::HGCalHSc) return "HGCalHEBack";
   else                                                     return "Unknown";
 }

std::shared_ptr< const CaloCellGeometry > HGCalGeometry::cellGeomPtr ( uint32_t index ) const

overrideprotectedvirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 613 of file HGCalGeometry.cc.

References DetId::HGCalHSc, m_cellVec, m_cellVec2, m_det, and m_validGeomIds.

Referenced by cellGeomPtr(), getGeometry(), getSummary(), and topology().

                                                                                      {
   if ((index >= m_cellVec.size()  && m_det != DetId::HGCalHSc) ||
       (index >= m_cellVec2.size() && m_det == DetId::HGCalHSc) ||
       (m_validGeomIds[index].rawId() == 0)) return nullptr;
   static const auto do_not_delete = [](const void*){};
   if (m_det == DetId::HGCalHSc) {
     auto cell = std::shared_ptr<const CaloCellGeometry>(&m_cellVec2[index],do_not_delete);
     if (nullptr == cell->param()) return nullptr;
     return cell;
   } else {
     auto cell = std::shared_ptr<const CaloCellGeometry>(&m_cellVec[index],do_not_delete);
     if (nullptr == cell->param()) return nullptr;
     return cell;
   }
 }

std::shared_ptr< const CaloCellGeometry > HGCalGeometry::cellGeomPtr	(	uint32_t	index,
		const GlobalPoint &	p
	)		const

private

Definition at line 629 of file HGCalGeometry.cc.

References cellGeomPtr(), DetId::HGCalHSc, m_cellVec, m_cellVec2, m_det, and m_validGeomIds.

                                                                                                              {
   if ((index >= m_cellVec.size()  && m_det != DetId::HGCalHSc) ||
       (index >= m_cellVec2.size() && m_det == DetId::HGCalHSc) ||
       (m_validGeomIds[index].rawId() == 0)) return nullptr;
   if (pos == GlobalPoint()) return cellGeomPtr(index);
   if (m_det == DetId::HGCalHSc) {
     auto cell = std::make_shared<FlatTrd>(m_cellVec2[index]);
     cell->setPosition(pos);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "cellGeomPtr " << index << ":" << cell;
 #endif
     if (nullptr == cell->param()) return nullptr;
     return cell;
   } else {
     auto cell = std::make_shared<FlatHexagon>(m_cellVec[index]);
     cell->setPosition(pos);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "cellGeomPtr " << index << ":" << cell;
 #endif
     if (nullptr == cell->param()) return nullptr;
     return cell;
   }
 }

static std::string HGCalGeometry::dbString ( )

inlinestatic

Definition at line 52 of file HGCalGeometry.h.

References ecalTB2006H4_GenSimDigiReco_cfg::bField, ALCARECOTkAlJpsiMuMu_cff::charge, connectstrParser::f1, connectstrParser::f2, connectstrParser::f3, get8Corners(), getArea(), getCorners(), getGeometry(), getNewCorners(), getPosition(), getSummary(), HGCalGeometry(), mps_fire::i, localCorners(), neighborZ(), newCell(), AlCaHLTBitMon_ParallelJobs::p, present(), MetAnalyzer::pv(), topology(), and ~HGCalGeometry().

Referenced by CaloGeometryDBEP< T, U >::produceAligned().

52 { return "PHGCalRcd" ; }

void HGCalGeometry::fillNamedParams ( DDFilteredView fv )

virtual

Definition at line 48 of file HGCalGeometry.cc.

Referenced by getValidGeomDetIds().

48 {}

HGCalGeometry::CornersVec HGCalGeometry::get8Corners ( const DetId & id ) const

Definition at line 347 of file HGCalGeometry.cc.

References HGCalDDDConstants::cellSizeTrap(), funct::cos(), HGCalTopology::dddConstants(), HGCalTopology::decode(), runTauDisplay::dr, PVValHelper::dx, PVValHelper::dz, getPosition(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, DetId::HGCalHSc, mps_fire::i, indexFor(), FlatTrd::k_Cell, FlatTrd::k_dZ, FlatHexagon::k_dZ, k_fac2, k_half, FlatHexagon::k_r, HGCalDDDConstants::locateCell(), HGCalDDDConstants::locateCellHex(), m_cellVec, m_cellVec2, m_det, m_topology, mode_, FlatTrd::ncorner_, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), alignCSCRings::r, findQualityFiles::rr, funct::sin(), findQualityFiles::v, geometryCSVtoXML::xy, and PV3DBase< T, PVType, FrameType >::z().

Referenced by dbString().

                                                                            {
   
   unsigned int ncorner = FlatTrd::ncorner_;
   HGCalGeometry::CornersVec co (ncorner, GlobalPoint(0,0,0));
   unsigned int cellIndex =  indexFor(detid);
   HGCalTopology::DecodedDetId id = m_topology.decode(detid);
   if      (cellIndex <  m_cellVec2.size() && m_det == DetId::HGCalHSc) {
     GlobalPoint v = getPosition(detid);
     std::pair<double,double> rr = m_topology.dddConstants().cellSizeTrap(id.iType,id.iSec1);
     float dr = k_half*(rr.second-rr.first);
     float dfi= m_cellVec2[cellIndex].param()[FlatTrd::k_Cell];
     float dz = id.zSide*m_cellVec2[cellIndex].param()[FlatTrd::k_dZ];
     float r  = v.perp();
     float fi = v.phi();
     static const int signr[] = {1,1,-1,-1,1,1,-1,-1};
     static const int signf[] = {-1,1,1,-1,-1,1,1,-1};
     static const int signz[] = {-1,-1,-1,-1,1,1,1,1};
     for (unsigned int i = 0; i < ncorner; ++i) {
       co[i] = GlobalPoint((r+signr[i]*dr)*cos(fi+signf[i]*dfi),
               (r+signr[i]*dr)*sin(fi+signf[i]*dfi),
               (v.z()+signz[i]*dz));
     }
   } else if (cellIndex <  m_cellVec.size() && m_det != DetId::HGCalHSc) {
     std::pair<float,float> xy;
     float                  dx(0);
     if ((mode_ == HGCalGeometryMode::Hexagon) ||
     (mode_ == HGCalGeometryMode::HexagonFull)) {
       xy = m_topology.dddConstants().locateCellHex(id.iCell1,id.iSec1,true);
       dx = m_cellVec[cellIndex].param()[FlatHexagon::k_r];
     } else {
       xy = m_topology.dddConstants().locateCell(id.iLay,id.iSec1,id.iSec2,
                         id.iCell1,id.iCell2,true,false);
       dx = k_fac2*m_cellVec[cellIndex].param()[FlatHexagon::k_r];
     }
     static const int signx[] = {-1,-1,1,1,-1,-1,1,1};
     static const int signy[] = {-1,1,1,-1,-1,1,1,-1};
     static const int signz[] = {-1,-1,-1,-1,1,1,1,1};
     float dz = m_cellVec[cellIndex].param()[FlatHexagon::k_dZ];
     for (unsigned int i = 0; i < ncorner; ++i) {
       const HepGeom::Point3D<float> lcoord(xy.first+signx[i]*dx,
                        xy.second+signy[i]*dx,signz[i]*dz);
       co[i] = m_cellVec[cellIndex].getPosition(lcoord);
     }
   }
   return co;
 }

double HGCalGeometry::getArea ( const DetId & detid ) const

Returns area of a cell.

Definition at line 275 of file HGCalGeometry.cc.

References jets_cff::area, getNewCorners(), mps_fire::i, gen::n, and y.

Referenced by dbString().

                                                       {
 
   HGCalGeometry::CornersVec corners = getNewCorners(detid);
   double area(0);
   if (corners.size() > 1) {
     int n = corners.size()-1;
     int j = n-1;
     for (int i=0; i<n; ++i) {
       area += ((corners[j].x()+corners[i].x())*
            (corners[i].y()-corners[j].y()));
       j     = i;
     }
   }
   return (0.5*area);
 }

HGCalGeometry::DetIdSet HGCalGeometry::getCells	(	const GlobalPoint &	r,
		double	dR
	)		const

overridevirtual

Get a list of all cells within a dR of the given cell.

The default implementation makes a loop over all cell geometries. Cleverer implementations are suggested to use rough conversions between eta/phi and ieta/iphi and test on the boundaries.

Reimplemented from CaloSubdetectorGeometry.

Definition at line 569 of file HGCalGeometry.cc.

Referenced by getValidGeomDetIds().

                                                                                     {
    HGCalGeometry::DetIdSet dss;
    return dss;
 }

DetId HGCalGeometry::getClosestCell ( const GlobalPoint & r ) const

overridevirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 515 of file HGCalGeometry.cc.

References HGCalDDDConstants::assignCell(), HGCalDDDConstants::assignCellHex(), HGCalDDDConstants::assignCellTrap(), HGCalTopology::dddConstants(), HGCalTopology::decode(), HGCalTopology::encode(), getClosestCellIndex(), HGCalDDDConstants::getLayer(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, DetId::HGCalHSc, DTRecHitClients_cfi::local, m_cellVec, m_cellVec2, m_det, m_topology, m_validGeomIds, mode_, HGCalGeometryMode::Trapezoid, HGCalDDDConstants::waferTypeT(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by getValidGeomDetIds(), and neighborZ().

                                                               {
   unsigned int cellIndex = getClosestCellIndex(r);
   if ((cellIndex <  m_cellVec.size() && m_det != DetId::HGCalHSc) ||
       (cellIndex <  m_cellVec2.size() && m_det == DetId::HGCalHSc)) {
     HGCalTopology::DecodedDetId id = m_topology.decode(m_validGeomIds[cellIndex]);
     HepGeom::Point3D<float> local;
     if (r.z() > 0) {
       local    = HepGeom::Point3D<float>(r.x(),r.y(),0);
       id.zSide = 1;
     } else {
       local = HepGeom::Point3D<float>(-r.x(),r.y(),0);
       id.zSide =-1;
     }
     if ((mode_ == HGCalGeometryMode::Hexagon) ||
     (mode_ == HGCalGeometryMode::HexagonFull)) {
       const auto & kxy = 
     m_topology.dddConstants().assignCell(local.x(),local.y(),id.iLay,
                          id.iType,true);
       id.iCell1  = kxy.second;
       id.iSec1   = kxy.first;
       id.iType   = m_topology.dddConstants().waferTypeT(kxy.first);
       if (id.iType != 1) id.iType = -1;
     } else if (mode_ == HGCalGeometryMode::Trapezoid) {
       id.iLay = m_topology.dddConstants().getLayer(r.z(),true);
       const auto & kxy = 
     m_topology.dddConstants().assignCellTrap(r.x(),r.y(),r.z(),
                          id.iLay,true);
       id.iSec1  = kxy[0];
       id.iCell1 = kxy[1];
       id.iType  = kxy[2];
     } else {
       id.iLay = m_topology.dddConstants().getLayer(r.z(),true);
       const auto & kxy = 
     m_topology.dddConstants().assignCellHex(local.x(),local.y(),id.iLay,
                         true);
       id.iSec1  = kxy[0]; id.iSec2  = kxy[1]; id.iType = kxy[2];
       id.iCell1 = kxy[3]; id.iCell2 = kxy[4];
     }
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "getClosestCell: local " << local 
                   << " Id " << id.zSide << ":" << id.iLay 
                   << ":" << id.iSec1 << ":" << id.iSec2
                   << ":" << id.iType << ":" << id.iCell1
                   << ":" << id.iCell2;
 #endif
 
     //check if returned cell is valid
     if (id.iCell1>=0) return m_topology.encode(id);
   }
 
   //if not valid or out of bounds return a null DetId
   return DetId();
 }

unsigned int HGCalGeometry::getClosestCellIndex ( const GlobalPoint & r ) const

protected

Definition at line 657 of file HGCalGeometry.cc.

References DetId::HGCalHSc, m_cellVec, m_cellVec2, and m_det.

Referenced by getClosestCell(), and topology().

                                                                            {
 
   return ((m_det == DetId::HGCalHSc) ? getClosestCellIndex(r,m_cellVec2) : getClosestCellIndex(r,m_cellVec));
 }

template<class T >

unsigned int HGCalGeometry::getClosestCellIndex	(	const GlobalPoint &	r,
		const std::vector< T > &	vec
	)		const

private

Definition at line 663 of file HGCalGeometry.cc.

References a, funct::abs(), b, PVValHelper::dz, getPosition(), gen::k, M_PI, PV3DBase< T, PVType, FrameType >::phi(), DetId::rawId(), z, and PV3DBase< T, PVType, FrameType >::z().

                                                         {
 
   float phip = r.phi();
   float zp   = r.z();
   float dzmin(9999), dphimin(9999), dphi10(0.175);
   unsigned int cellIndex =  vec.size();
   for (unsigned int k=0; k<vec.size(); ++k) {
     float dphi = phip-vec[k].phiPos();
     while (dphi >   M_PI) dphi -= 2*M_PI;
     while (dphi <= -M_PI) dphi += 2*M_PI;
     if (std::abs(dphi) < dphi10) {
       float dz = std::abs(zp - vec[k].getPosition().z());
       if (dz < (dzmin+0.001)) {
     dzmin     = dz;
     if (std::abs(dphi) < (dphimin+0.01)) {
       cellIndex = k;
       dphimin   = std::abs(dphi);
     } else {
       if (cellIndex >= vec.size()) cellIndex = k;
     }
       }
     }
   }
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "getClosestCellIndex::Input " << zp << ":" 
                 << phip << " Index " << cellIndex;
   if (cellIndex < vec.size()) 
     edm::LogVerbatim("HGCalGeom") << " Cell z " 
                   << vec[cellIndex].getPosition().z() 
                   << ":" << dzmin << " phi " 
                   << vec[cellIndex].phiPos() << ":" << dphimin;
 #endif
   return cellIndex;
 }

HGCalGeometry::CornersVec HGCalGeometry::getCorners ( const DetId & id ) const

Returns the corner points of this cell's volume.

Definition at line 291 of file HGCalGeometry.cc.

References HGCalDDDConstants::cellSizeTrap(), funct::cos(), HGCalTopology::dddConstants(), HGCalTopology::decode(), runTauDisplay::dr, PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, getPosition(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, DetId::HGCalHSc, mps_fire::i, indexFor(), FlatTrd::k_Cell, FlatTrd::k_dZ, FlatHexagon::k_dZ, k_fac1, k_fac2, k_half, FlatHexagon::k_r, FlatHexagon::k_R, HGCalDDDConstants::locateCell(), HGCalDDDConstants::locateCellHex(), m_cellVec, m_cellVec2, m_det, m_topology, mode_, FlatHexagon::ncorner_, FlatTrd::ncorner_, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), alignCSCRings::r, findQualityFiles::rr, funct::sin(), findQualityFiles::v, geometryCSVtoXML::xy, and PV3DBase< T, PVType, FrameType >::z().

Referenced by dbString().

                                                                           {
 
   unsigned int ncorner = ((m_det == DetId::HGCalHSc) ? FlatTrd::ncorner_ :
               FlatHexagon::ncorner_);
   HGCalGeometry::CornersVec co (ncorner, GlobalPoint(0,0,0));
   unsigned int cellIndex =  indexFor(detid);
   HGCalTopology::DecodedDetId id = m_topology.decode(detid);
   if      (cellIndex <  m_cellVec2.size() && m_det == DetId::HGCalHSc) {
     GlobalPoint v = getPosition(detid);
     std::pair<double,double> rr = m_topology.dddConstants().cellSizeTrap(id.iType,id.iSec1);
     float dr = k_half*(rr.second-rr.first);
     float dfi= m_cellVec2[cellIndex].param()[FlatTrd::k_Cell];
     float dz = id.zSide*m_cellVec2[cellIndex].param()[FlatTrd::k_dZ];
     float r  = v.perp();
     float fi = v.phi();
     static const int signr[] = {1,1,-1,-1,1,1,-1,-1};
     static const int signf[] = {-1,1,1,-1,-1,1,1,-1};
     static const int signz[] = {-1,-1,-1,-1,1,1,1,1};
     for (unsigned int i = 0; i < ncorner; ++i) {
       co[i] = GlobalPoint((r+signr[i]*dr)*cos(fi+signf[i]*dfi),
               (r+signr[i]*dr)*sin(fi+signf[i]*dfi),
               (v.z()+signz[i]*dz));
     }
   } else if (cellIndex <  m_cellVec.size() && m_det != DetId::HGCalHSc) {
     std::pair<float,float> xy;
     if ((mode_ == HGCalGeometryMode::Hexagon) ||
     (mode_ == HGCalGeometryMode::HexagonFull)) {
       xy = m_topology.dddConstants().locateCellHex(id.iCell1,id.iSec1,true);
       float dx = m_cellVec[cellIndex].param()[FlatHexagon::k_r];
       float dy = k_half*m_cellVec[cellIndex].param()[FlatHexagon::k_R];
       float dz = m_cellVec[cellIndex].param()[FlatHexagon::k_dZ];
       static const int signx[] = {0,-1,-1,0,1,1,0,-1,-1,0,1,1};
       static const int signy[] = {-2,-1,1,2,1,-1,-2,-1,1,2,1,-1};
       static const int signz[] = {-1,-1,-1,-1,-1,-1,1,1,1,1,1,1};
       for (unsigned int i = 0; i < ncorner; ++i) {
     const HepGeom::Point3D<float> lcoord(xy.first+signx[i]*dx,xy.second+signy[i]*dy,signz[i]*dz);
     co[i] = m_cellVec[cellIndex].getPosition(lcoord);
       }
     } else {
       xy = m_topology.dddConstants().locateCell(id.iLay,id.iSec1,id.iSec2,
                         id.iCell1,id.iCell2,true,false);
       float dx = k_fac2*m_cellVec[cellIndex].param()[FlatHexagon::k_r];
       float dy = k_fac1*m_cellVec[cellIndex].param()[FlatHexagon::k_R];
       float dz =-id.zSide*m_cellVec[cellIndex].param()[FlatHexagon::k_dZ];
       static const int signx[] = {1,-1,-2,-1, 1,2,1,-1,-2,-1, 1,2};
       static const int signy[] = {1, 1, 0,-1,-1,0,1, 1, 0,-1,-1,0};
       static const int signz[] = {-1,-1,-1,-1,-1,-1,1,1,1,1,1,1};
       for (unsigned int i = 0; i < ncorner; ++i) {
     const HepGeom::Point3D<float> lcoord(xy.first+signx[i]*dx,xy.second+signy[i]*dy,signz[i]*dz);
     co[i] = m_cellVec[cellIndex].getPosition(lcoord);
       }
     }
   }
   return co;
 }

std::shared_ptr< const CaloCellGeometry > HGCalGeometry::getGeometry ( const DetId & id ) const

overridevirtual

Get the cell geometry of a given detector id. Should return false if not found.

Reimplemented from CaloSubdetectorGeometry.

Definition at line 211 of file HGCalGeometry.cc.

References cellGeomPtr(), HGCalTopology::detId2denseGeomId(), getGeometryDetId(), getPosition(), and m_topology.

Referenced by dbString().

                                                                                          {
   if (detId == DetId()) return nullptr; // nothing to get
   DetId geomId = getGeometryDetId(detId);
   const uint32_t cellIndex (m_topology.detId2denseGeomId(geomId));
   const GlobalPoint pos = (detId != geomId) ? getPosition(detId) : GlobalPoint();
   return cellGeomPtr (cellIndex, pos);
 
 }

DetId HGCalGeometry::getGeometryDetId ( DetId detId ) const

private

Definition at line 821 of file HGCalGeometry.cc.

References HGCalDetId::geometryCell(), HGCScintillatorDetId::geometryCell(), HGCSiliconDetId::geometryCell(), HFNoseDetId::geometryCell(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, HGCalTopology::isHFNose(), m_topology, mode_, and HGCalGeometryMode::Trapezoid.

Referenced by getGeometry(), indexFor(), newCell(), present(), and topology().

                                                        {
   DetId geomId;
   if ((mode_ == HGCalGeometryMode::Hexagon) || 
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     geomId = static_cast<DetId>(HGCalDetId(detId).geometryCell());
   } else if (mode_ == HGCalGeometryMode::Trapezoid) {
     geomId = static_cast<DetId>(HGCScintillatorDetId(detId).geometryCell());
   } else if (m_topology.isHFNose()) {
     geomId = static_cast<DetId>(HFNoseDetId(detId).geometryCell());
   } else {
     geomId = static_cast<DetId>(HGCSiliconDetId(detId).geometryCell());
   }
   return geomId;
 }

const CaloCellGeometry * HGCalGeometry::getGeometryRawPtr ( uint32_t index ) const

overrideprotectedvirtual

Implements CaloSubdetectorGeometry.

Definition at line 600 of file HGCalGeometry.cc.

References DetId::HGCalHSc, m_cellVec, m_cellVec2, m_det, and CaloCellGeometry::param().

Referenced by present(), and topology().

                                                                              {
   // Modify the RawPtr class
   if (m_det == DetId::HGCalHSc) {
     if (m_cellVec2.size() < index) return nullptr;
     const CaloCellGeometry* cell(&m_cellVec2[index]);
     return (nullptr == cell->param() ? nullptr : cell);
   } else {
     if (m_cellVec2.size() < index) return nullptr;
     const CaloCellGeometry* cell(&m_cellVec[index]);
     return (nullptr == cell->param() ? nullptr : cell);
   }
 }

HGCalGeometry::CornersVec HGCalGeometry::getNewCorners ( const DetId & id ) const

Definition at line 394 of file HGCalGeometry.cc.

References HGCalDDDConstants::cellSizeTrap(), funct::cos(), HGCalTopology::dddConstants(), HGCalTopology::decode(), runTauDisplay::dr, PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, getPosition(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, DetId::HGCalHSc, mps_fire::i, indexFor(), FlatTrd::k_Cell, FlatTrd::k_dZ, FlatHexagon::k_dZ, k_fac1, k_fac2, k_half, FlatHexagon::k_r, FlatHexagon::k_R, HGCalDDDConstants::locateCell(), HGCalDDDConstants::locateCellHex(), m_cellVec, m_cellVec2, m_det, m_topology, mode_, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), alignCSCRings::r, findQualityFiles::rr, funct::sin(), findQualityFiles::v, geometryCSVtoXML::xy, and PV3DBase< T, PVType, FrameType >::z().

Referenced by FWRecoGeometryESProducer::addCaloGeometry(), dbString(), and getArea().

                                                                              {
 
   unsigned int ncorner = (m_det == DetId::HGCalHSc) ? 5 : 7;
   HGCalGeometry::CornersVec co (ncorner, GlobalPoint(0,0,0));
   unsigned int cellIndex =  indexFor(detid);
   HGCalTopology::DecodedDetId id = m_topology.decode(detid);
   if (cellIndex <  m_cellVec2.size() && m_det == DetId::HGCalHSc) {
     GlobalPoint v = getPosition(detid);
     std::pair<double,double> rr = m_topology.dddConstants().cellSizeTrap(id.iType,id.iSec1);
     float dr = k_half*(rr.second-rr.first);
     float dfi= m_cellVec2[cellIndex].param()[FlatTrd::k_Cell];
     float dz =-id.zSide*m_cellVec2[cellIndex].param()[FlatTrd::k_dZ];
     float r  = v.perp();
     float fi = v.phi();
     static const int signr[] = {1,1,-1,-1};
     static const int signf[] = {-1,1,1,-1};
     for (unsigned int i = 0; i < ncorner-1; ++i) {
       co[i] = GlobalPoint((r+signr[i]*dr)*cos(fi+signf[i]*dfi),
               (r+signr[i]*dr)*sin(fi+signf[i]*dfi),
               (v.z()+dz));
     }
     co[ncorner-1] = GlobalPoint(0,0,-2*dz);
   }  else if (cellIndex <  m_cellVec.size() && m_det != DetId::HGCalHSc) {
     std::pair<float,float> xy;
     if ((mode_ == HGCalGeometryMode::Hexagon) ||
     (mode_ == HGCalGeometryMode::HexagonFull)) {
       xy = m_topology.dddConstants().locateCellHex(id.iCell1,id.iSec1,true);
     } else {
       xy = m_topology.dddConstants().locateCell(id.iLay,id.iSec1,id.iSec2,
                         id.iCell1,id.iCell2,true,false);
     }
     float dx = k_fac2*m_cellVec[cellIndex].param()[FlatHexagon::k_r];
     float dy = k_fac1*m_cellVec[cellIndex].param()[FlatHexagon::k_R];
     float dz =-id.zSide*m_cellVec[cellIndex].param()[FlatHexagon::k_dZ];
     static const int signx[] = {1,-1,-2,-1, 1,2};
     static const int signy[] = {1, 1, 0,-1,-1,0};
     for (unsigned int i = 0; i < ncorner-1; ++i) {
       const HepGeom::Point3D<float> lcoord(xy.first+signx[i]*dx,xy.second+signy[i]*dy,dz);
       co[i] = m_cellVec[cellIndex].getPosition(lcoord);
     }
     co[ncorner-1] = GlobalPoint(0,0,-2*dz);
   }
   return co;
 }

GlobalPoint HGCalGeometry::getPosition ( const DetId & id ) const

Definition at line 227 of file HGCalGeometry.cc.

References HGCalTopology::dddConstants(), HGCalTopology::decode(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, indexFor(), HGCalDDDConstants::locateCell(), HGCalDDDConstants::locateCellHex(), m_cellVec, m_cellVec2, m_topology, copyPickMerge_cfg::maxSize, mode_, HGCalGeometryMode::Trapezoid, and geometryCSVtoXML::xy.

                                                                {
 
   unsigned int cellIndex =  indexFor(detid);
   GlobalPoint glob;
   unsigned int maxSize = ((mode_ == HGCalGeometryMode::Trapezoid) ? 
               m_cellVec2.size() : m_cellVec.size());
   if (cellIndex <  maxSize) {
     HGCalTopology::DecodedDetId id = m_topology.decode(detid);
     std::pair<float,float> xy;
     if ((mode_ == HGCalGeometryMode::Hexagon) ||
     (mode_ == HGCalGeometryMode::HexagonFull)) {
       xy = m_topology.dddConstants().locateCellHex(id.iCell1,id.iSec1,true);
       const HepGeom::Point3D<float> lcoord(xy.first,xy.second,0);
       glob = m_cellVec[cellIndex].getPosition(lcoord);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "getPosition:: index " << cellIndex 
                     << " Local " << lcoord.x() << ":" 
                     << lcoord.y() << " ID " << id.iCell1 
                     << ":" << id.iSec1 << " Global " << glob;
 #endif
     } else if (mode_ == HGCalGeometryMode::Trapezoid) {
       const HepGeom::Point3D<float> lcoord(0,0,0);
       glob = m_cellVec2[cellIndex].getPosition(lcoord);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "getPositionTrap:: index " << cellIndex 
                     << " Local " << lcoord.x() << ":" 
                     << lcoord.y() << " ID " << id.iLay << ":"
                     << id.iSec1 << ":" << id.iCell1 
                     << " Global " << glob;
 #endif
     } else {
       xy = m_topology.dddConstants().locateCell(id.iLay,id.iSec1,id.iSec2,
                         id.iCell1,id.iCell2,true,false);
       const HepGeom::Point3D<float> lcoord(xy.first,xy.second,0);
       glob = m_cellVec[cellIndex].getPosition(lcoord);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "getPositionWafer:: index " << cellIndex
                     << " Local " << lcoord.x() << ":" 
                     << lcoord.y() << " ID " << id.iLay << ":"
                     << id.iSec1 << ":" << id.iSec2 << ":"
                     << id.iCell1 << ":" << id.iCell2 
                     << " Global " << glob;
 #endif
     }
   } 
   return glob;
 }

void HGCalGeometry::getSummary	(	CaloSubdetectorGeometry::TrVec &	trVector,
		CaloSubdetectorGeometry::IVec &	iVector,
		CaloSubdetectorGeometry::DimVec &	dimVector,
		CaloSubdetectorGeometry::IVec &	dinsVector
	)		const

overridevirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 714 of file HGCalGeometry.cc.

References HGCalParameters::hgtrap::alpha, HGCalParameters::hgtrap::bl, cellGeomPtr(), HGCalParameters::hgtrap::cellSize, HGCalTopology::dddConstants(), HGCalTopology::detId2denseGeomId(), HGCalParameters::hgtrap::dz, HGCalParameters::firstModule_, HGCalDDDConstants::getModule(), HGCalDDDConstants::getParameter(), HGCalDDDConstants::getTrForm(), HGCalDDDConstants::getTrFormN(), runTauDisplay::gp, HGCalParameters::hgtrap::h, HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, DetId::HGCalHSc, mps_fire::i, HGCalTopology::isHFNose(), FlatTrd::k_Alp1, FlatTrd::k_Alp2, FlatTrd::k_Cell, FlatTrd::k_dX1, FlatTrd::k_dX2, FlatTrd::k_dX3, FlatTrd::k_dX4, FlatTrd::k_dY1, FlatTrd::k_dY2, FlatTrd::k_dZ, FlatHexagon::k_dZ, k_NumberOfParametersPerHex, k_NumberOfParametersPerTrd, k_NumberOfShapes, FlatTrd::k_Phi, FlatHexagon::k_r, FlatHexagon::k_R, FlatTrd::k_Theta, HGCalParameters::lastModule_, HGCalParameters::hgtrform::lay, HGCalDetId::layer(), HGCScintillatorDetId::layer(), HGCSiliconDetId::layer(), HFNoseDetId::layer(), HGCalDDDConstants::layerIndex(), m_det, m_topology, m_validGeomIds, mode_, CaloSubdetectorGeometry::numberOfParametersPerShape(), CaloSubdetectorGeometry::numberOfShapes(), CaloSubdetectorGeometry::numberOfTransformParms(), findQualityFiles::rr, HGCalDDDConstants::sectors(), HGCalParameters::hgtrap::tl, HGCalTopology::totalGeomModules(), HGCalGeometryMode::Trapezoid, groupFilesInBlocks::tt, twoBysqrt3_, and HGCalDDDConstants::waferInLayer().

Referenced by dbString(), and CaloGeometryDBEP< T, U >::produceAligned().

                                                                    {
 
   unsigned int numberOfCells = m_topology.totalGeomModules(); // total Geom Modules both sides
   unsigned int numberOfShapes = k_NumberOfShapes;
   unsigned int numberOfParametersPerShape = 
     ((m_det == DetId::HGCalHSc) ? (unsigned int)(k_NumberOfParametersPerTrd) :
      (unsigned int)(k_NumberOfParametersPerHex));
 
   trVector.reserve( numberOfCells * numberOfTransformParms());
   iVector.reserve( numberOfCells );
   dimVector.reserve( numberOfShapes * numberOfParametersPerShape );
   dinsVector.reserve( numberOfCells );
   
   for (unsigned itr=0; itr<m_topology.dddConstants().getTrFormN(); ++itr) {
     HGCalParameters::hgtrform mytr = m_topology.dddConstants().getTrForm(itr);
     int layer  = mytr.lay;
 
     if ((mode_ == HGCalGeometryMode::Hexagon) ||
     (mode_ == HGCalGeometryMode::HexagonFull)) {
       for (int wafer=0; wafer<m_topology.dddConstants().sectors(); ++wafer) {
         if (m_topology.dddConstants().waferInLayer(wafer,layer,true)) {
       HGCalParameters::hgtrap vol = m_topology.dddConstants().getModule(wafer, true, true);
       ParmVec params( numberOfParametersPerShape, 0 );
       params[FlatHexagon::k_dZ] = vol.dz;
       params[FlatHexagon::k_r]  = vol.cellSize;
       params[FlatHexagon::k_R]  = twoBysqrt3_*params[FlatHexagon::k_r];
       dimVector.insert( dimVector.end(), params.begin(), params.end());
     }
       }
     } else if (mode_ == HGCalGeometryMode::Trapezoid) {
       int indx = m_topology.dddConstants().layerIndex(layer,true);
       for (int md=m_topology.dddConstants().getParameter()->firstModule_[indx];
        md<=m_topology.dddConstants().getParameter()->lastModule_[indx];
        ++md) {
     HGCalParameters::hgtrap vol = m_topology.dddConstants().getModule(md, true, true);
     ParmVec params( numberOfParametersPerShape, 0 );
     params[FlatTrd::k_dZ]    = vol.dz;
     params[FlatTrd::k_Theta] = params[FlatTrd::k_Phi] = 0;
     params[FlatTrd::k_dY1]   = params[FlatTrd::k_dY2] = vol.h;
     params[FlatTrd::k_dX1]   = params[FlatTrd::k_dX3] = vol.bl;
     params[FlatTrd::k_dX2]   = params[FlatTrd::k_dX4] = vol.tl;
     params[FlatTrd::k_Alp1]  = params[FlatTrd::k_Alp2]= vol.alpha;
     params[FlatTrd::k_Cell]  = vol.cellSize;
     dimVector.insert( dimVector.end(), params.begin(), params.end());
       }
     } else {
       for (int wafer=0; wafer<m_topology.dddConstants().sectors(); ++wafer) {
         if (m_topology.dddConstants().waferInLayer(wafer,layer,true)) {
       HGCalParameters::hgtrap vol = m_topology.dddConstants().getModule(wafer, true, true);
       ParmVec params( numberOfParametersPerShape, 0 );
       params[FlatHexagon::k_dZ] = vol.dz;
       params[FlatHexagon::k_r]  = vol.cellSize;
       params[FlatHexagon::k_R]  = twoBysqrt3_*params[FlatHexagon::k_r];
       dimVector.insert( dimVector.end(), params.begin(), params.end());
     }
       }
     }
   }
   
   for (unsigned int i( 0 ); i < numberOfCells; ++i) {
     DetId detId = m_validGeomIds[i];
     int layer(0);
     if ((mode_ == HGCalGeometryMode::Hexagon) ||
     (mode_ == HGCalGeometryMode::HexagonFull)) {
       layer     = HGCalDetId(detId).layer();
     } else if (mode_ == HGCalGeometryMode::Trapezoid) {
       layer     = HGCScintillatorDetId(detId).layer();
     } else if (m_topology.isHFNose()) {
       layer     = HFNoseDetId(detId).layer();
     } else {
       layer     = HGCSiliconDetId(detId).layer();
     }
     dinsVector.emplace_back(m_topology.detId2denseGeomId( detId ));
     iVector.emplace_back( layer );
     
     Tr3D tr;
     auto ptr =  cellGeomPtr( i );
     if ( nullptr != ptr ) {
       ptr->getTransform( tr, ( Pt3DVec* ) nullptr );
 
       if( Tr3D() == tr ) { // there is no rotation
     const GlobalPoint& gp( ptr->getPosition()); 
     tr = HepGeom::Translate3D( gp.x(), gp.y(), gp.z());
       }
 
       const CLHEP::Hep3Vector tt( tr.getTranslation());
       trVector.emplace_back( tt.x());
       trVector.emplace_back( tt.y());
       trVector.emplace_back( tt.z());
       if (6 == numberOfTransformParms()) {
     const CLHEP::HepRotation rr( tr.getRotation());
     const ROOT::Math::Transform3D rtr( rr.xx(), rr.xy(), rr.xz(), tt.x(),
                        rr.yx(), rr.yy(), rr.yz(), tt.y(),
                        rr.zx(), rr.zy(), rr.zz(), tt.z());
     ROOT::Math::EulerAngles ea;
     rtr.GetRotation( ea );
     trVector.emplace_back( ea.Phi());
     trVector.emplace_back( ea.Theta());
     trVector.emplace_back( ea.Psi());
       }
     }
   }
 }

const std::vector<DetId>& HGCalGeometry::getValidDetIds	(	DetId::Detector	det = `DetId::Detector(0)`,
		int	subdet = `0`
	)		const

inlineoverridevirtual

Get a list of valid detector ids (for the given subdetector)

Note: The implementation in this class is relevant for SubdetectorGeometries which handle only a single subdetector at a time. It does not look at the det and subdet arguments.

Reimplemented from CaloSubdetectorGeometry.

Definition at line 95 of file HGCalGeometry.h.

References CaloSubdetectorGeometry::m_validIds.

95 { return m_validIds; }

CaloSubdetectorGeometry::m_validIds

std::vector< DetId > m_validIds

Definition: CaloSubdetectorGeometry.h:126

const std::vector<DetId>& HGCalGeometry::getValidGeomDetIds ( void ) const

inline

Definition at line 96 of file HGCalGeometry.h.

References PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, fillNamedParams(), getCells(), getClosestCell(), initializeParms(), m_validGeomIds, and alignCSCRings::r.

96 { return m_validGeomIds; }

HGCalGeometry::m_validGeomIds

std::vector< DetId > m_validGeomIds

Definition: HGCalGeometry.h:146

unsigned int HGCalGeometry::indexFor ( const DetId & id ) const

overrideprotectedvirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 581 of file HGCalGeometry.cc.

References TauDecayModes::dec, HGCalTopology::detId2denseGeomId(), getGeometryDetId(), DetId::HGCalHSc, m_cellVec, m_cellVec2, m_det, m_topology, and DetId::rawId().

Referenced by get8Corners(), getCorners(), getNewCorners(), getPosition(), and topology().

                                                              {
   unsigned int cellIndex = ((m_det == DetId::HGCalHSc) ? m_cellVec2.size() :
                 m_cellVec.size());
   if (detId != DetId()) {
     DetId geomId = getGeometryDetId(detId);
     cellIndex = m_topology.detId2denseGeomId(geomId);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "indexFor " << std::hex << detId.rawId() 
                   << ":" << geomId.rawId() << std::dec 
                   << " index " << cellIndex;
 #endif
   }
   return cellIndex;
 }

void HGCalGeometry::initializeParms ( )

overridevirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 50 of file HGCalGeometry.cc.

Referenced by getValidGeomDetIds().

50 {

51 }

void HGCalGeometry::localCorners	(	Pt3DVec &	lc,
		const CCGFloat *	pv,
		unsigned int	i,
		Pt3D &	ref
	)

Definition at line 53 of file HGCalGeometry.cc.

References DetId::HGCalHSc, FlatHexagon::localCorners(), FlatTrd::localCorners(), and m_det.

Referenced by dbString().

                                       {
   if (m_det == DetId::HGCalHSc) {
     FlatTrd::localCorners( lc, pv, ref ) ;
   } else {
     FlatHexagon::localCorners( lc, pv, ref ) ;
   }
 }

DetId HGCalGeometry::neighborZ	(	const DetId &	idin,
		const GlobalVector &	p
	)		const

Definition at line 439 of file HGCalGeometry.cc.

References HGCalTopology::dddConstants(), HGCalTopology::decode(), HGCalDDDConstants::firstLayer(), getClosestCell(), getPosition(), HGCalDDDConstants::lastLayer(), m_topology, AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::r, HGCalDDDConstants::rangeR(), topology(), findQualityFiles::v, HGCalDDDConstants::waferZ(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by dbString().

                                                        {
   DetId idnew;
   HGCalTopology::DecodedDetId id = m_topology.decode(idin);
   int lay = ((momentum.z()*id.zSide > 0) ? (id.iLay+1) : (id.iLay-1));
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "neighborz1:: ID " << id.iLay << ":"
                 << id.iSec1 << ":" << id.iSec2 << ":"
                 << id.iCell1 << ":" << id.iCell2 
                 << " New Layer " << lay << " Range "
                 << m_topology.dddConstants().firstLayer() <<":"
                 << m_topology.dddConstants().lastLayer(true)
                 << " pz " << momentum.z();
 #endif
   if ((lay >= m_topology.dddConstants().firstLayer()) && 
       (lay <= m_topology.dddConstants().lastLayer(true)) && 
       (momentum.z() != 0.0)) {
     GlobalPoint v = getPosition(idin);
     double      z = id.zSide*m_topology.dddConstants().waferZ(lay,true); 
     double   grad = (z - v.z())/momentum.z();
     GlobalPoint p(v.x()+grad*momentum.x(),v.y()+grad*momentum.y(),z);
     double      r = p.perp();
     auto rlimit   = topology().dddConstants().rangeR(z,true);
     if (r >= rlimit.first && r <= rlimit.second) idnew = getClosestCell(p);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "neighborz1:: Position " << v << " New Z "
                 << z << ":" << grad << " new position " << p
                 << " r-limit " << rlimit.first << ":" 
                 << rlimit.second;
 #endif
   }
   return idnew;
 }

DetId HGCalGeometry::neighborZ	(	const DetId &	idin,
		const MagneticField *	bField,
		int	charge,
		const GlobalVector &	momentum
	)		const

Definition at line 473 of file HGCalGeometry.cc.

References alongMomentum, Plane::build(), HGCalTopology::dddConstants(), HGCalTopology::decode(), HGCalDDDConstants::firstLayer(), getClosestCell(), getPosition(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), HGCalDDDConstants::lastLayer(), M_PI, m_topology, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp(), Propagator::propagate(), alignCSCRings::r, HGCalDDDConstants::rangeR(), topology(), findQualityFiles::v, HGCalDDDConstants::waferZ(), z, and PV3DBase< T, PVType, FrameType >::z().

                                                        {
   DetId idnew;
   HGCalTopology::DecodedDetId id = m_topology.decode(idin);
   int lay = ((momentum.z()*id.zSide > 0) ? (id.iLay+1) : (id.iLay-1));
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "neighborz2:: ID " << id.iLay << ":"
                 << id.iSec1 << ":" << id.iSec2 << ":"
                 << id.iCell1 << ":" << id.iCell2 
                 << " New Layer " << lay << " Range "
                 << m_topology.dddConstants().firstLayer() <<":"
                 << m_topology.dddConstants().lastLayer(true)
                 << " pz " << momentum.z();
 #endif
   if ((lay >= m_topology.dddConstants().firstLayer()) && 
       (lay <= m_topology.dddConstants().lastLayer(true)) && 
       (momentum.z() != 0.0)) {
     GlobalPoint v = getPosition(idin);
     double      z = id.zSide*m_topology.dddConstants().waferZ(lay,true);
     FreeTrajectoryState fts (v, momentum, charge, bField);
     Plane::PlanePointer nPlane = Plane::build(Plane::PositionType (0, 0, z), 
                           Plane::RotationType());
     AnalyticalPropagator myAP (bField, alongMomentum, 2*M_PI);
     TrajectoryStateOnSurface tsos = myAP.propagate(fts, *nPlane);
     GlobalPoint p;
     auto rlimit   = topology().dddConstants().rangeR(z,true);
     if (tsos.isValid()) {
       p      = tsos.globalPosition();
       double      r = p.perp();
       if (r >= rlimit.first && r <= rlimit.second) idnew = getClosestCell(p);
     }
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "neighborz2:: Position " << v << " New Z "
                 << z << ":" << charge << ":" << tsos.isValid()
                 << " new position " << p << " r limits "
                 << rlimit.first << ":" << rlimit.second;
 #endif
   }
   return idnew;
 }

void HGCalGeometry::newCell	(	const GlobalPoint &	f1,
		const GlobalPoint &	f2,
		const GlobalPoint &	f3,
		const CCGFloat *	parm,
		const DetId &	detId
	)

overridevirtual

Implements CaloSubdetectorGeometry.

Definition at line 64 of file HGCalGeometry.cc.

References HGCalDDDConstants::cellInLayer(), postprocess-scan-build::cells, CaloSubdetectorGeometry::cornersMgr(), HGCalTopology::dddConstants(), TauDecayModes::dec, HGCalTopology::decode(), HGCalTopology::detId2denseGeomId(), HGCalTopology::encode(), getGeometryDetId(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, DetId::HGCalHSc, HGCalTopology::isHFNose(), m_cellVec, m_cellVec2, m_det, m_topology, m_validGeomIds, CaloSubdetectorGeometry::m_validIds, mode_, HGCalDDDConstants::numberCellsHexagon(), DetId::rawId(), HGCalGeometryMode::Trapezoid, findQualityFiles::v, HGCalTopology::valid(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by HGCalGeometryLoader::buildGeom(), and dbString().

                                             {
 
   DetId geomId = getGeometryDetId(detId);
   int   cells (0);
   HGCalTopology::DecodedDetId id = m_topology.decode(detId);
   if ((mode_ == HGCalGeometryMode::Hexagon) || 
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     cells = m_topology.dddConstants().numberCellsHexagon(id.iSec1);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "NewCell " << HGCalDetId(detId) 
                   << " GEOM " << HGCalDetId(geomId);
 #endif
   } else if (mode_ == HGCalGeometryMode::Trapezoid) {
     cells  = 1;
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "NewCell " << HGCScintillatorDetId(detId) 
                   << " GEOM " << HGCScintillatorDetId(geomId);
 #endif
   } else {
     cells  = m_topology.dddConstants().numberCellsHexagon(id.iLay,id.iSec1,
                               id.iSec2,false);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "NewCell " << HGCSiliconDetId(detId) 
                   << " GEOM " << HGCSiliconDetId(geomId);
 #endif
   }
   const uint32_t cellIndex (m_topology.detId2denseGeomId(geomId));
 
   if (m_det == DetId::HGCalHSc) {
     m_cellVec2.at( cellIndex ) = FlatTrd( cornersMgr(), f1, f2, f3, parm ) ;
   } else {
     m_cellVec.at( cellIndex ) = FlatHexagon( cornersMgr(), f1, f2, f3, parm ) ;
   }
   m_validGeomIds.at( cellIndex ) = geomId ;
   
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "Store for DetId " << std::hex 
                 << detId.rawId() << " GeomId " 
                 << geomId.rawId() << std::dec << " Index " 
                 << cellIndex << " cells " << cells;
   unsigned int nOld = m_validIds.size();
 #endif
   if ((mode_ == HGCalGeometryMode::Hexagon) || 
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     for (int cell = 0; cell < cells; ++cell) {
       id.iCell1 = cell;
       DetId idc = m_topology.encode(id);
       if (m_topology.valid(idc)) {
     m_validIds.emplace_back(idc);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "Valid Id [" << cell << "] "
                       << HGCalDetId(idc);
 #endif
       }
     }
   } else if (mode_ == HGCalGeometryMode::Trapezoid) {
     DetId idc = m_topology.encode(id);
     if (m_topology.valid(idc)) {
       m_validIds.emplace_back(idc);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "Valid Id [0] " 
                     << HGCScintillatorDetId(idc);
 #endif
     } else {
       edm::LogWarning("HGCalGeom") << "Check " << HGCScintillatorDetId(idc) 
                    << " from " << HGCScintillatorDetId(detId)
                    << " ERROR ???";
     }
   } else {
 #ifdef EDM_ML_DEBUG
     unsigned int cellAll(0), cellSelect(0);
 #endif
     for (int u=0; u<2*cells; ++u) {
       for (int v=0; v<2*cells; ++v) {
     if (((v-u) < cells) && (u-v) <= cells) {
       id.iCell1 = u; id.iCell2 = v;
       DetId idc = m_topology.encode(id);
 #ifdef EDM_ML_DEBUG
       ++cellAll;
 #endif
       if (m_topology.dddConstants().cellInLayer(id.iSec1,id.iSec2,u,v,
                             id.iLay,true)) {
         m_validIds.emplace_back(idc);
 #ifdef EDM_ML_DEBUG
         ++cellSelect;
         edm::LogVerbatim("HGCalGeom") << "Valid Id [" << u << ", " << v
                       << "] " << HGCSiliconDetId(idc);
 #endif
       }
     }
       }
     }
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "HGCalGeometry keeps " << cellSelect
                   << " out of " << cellAll << " for wafer "
                   << id.iSec1 << ":" << id.iSec2 << " in "
                   << " layer " << id.iLay;
 #endif
   }
 #ifdef EDM_ML_DEBUG
   if (m_det == DetId::HGCalHSc) {
     edm::LogVerbatim("HGCalGeom") << "HGCalGeometry::newCell-> [" << cellIndex 
                   << "]" << " front:" << f1.x() << '/' 
                   << f1.y() << '/' << f1.z() << " back:" 
                   << f2.x() << '/' << f2.y() << '/' << f2.z() 
                   << " eta|phi " 
                   << m_cellVec2[cellIndex].etaPos() << ":"
                   << m_cellVec2[cellIndex].phiPos();
   } else {
     edm::LogVerbatim("HGCalGeom") << "HGCalGeometry::newCell-> [" << cellIndex 
                   << "]" << " front:" << f1.x() << '/' 
                   << f1.y() << '/' << f1.z() << " back:" 
                   << f2.x() << '/' << f2.y() << '/' << f2.z() 
                   << " eta|phi " 
                   << m_cellVec[cellIndex].etaPos() << ":"
                   << m_cellVec[cellIndex].phiPos();
   }
   unsigned int nNew = m_validIds.size();
   if ((mode_ == HGCalGeometryMode::Hexagon) || 
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     edm::LogVerbatim("HGCalGeom") << "ID: " << HGCalDetId(detId) 
                   << " with valid DetId from " << nOld 
                   << " to " << nNew;
   } else if (mode_ == HGCalGeometryMode::Trapezoid) {
     edm::LogVerbatim("HGCalGeom") << "ID: " << HGCScintillatorDetId(detId) 
                   << " with valid DetId from " << nOld 
                   << " to " << nNew;
   } else if (m_topology.isHFNose()) {
     edm::LogVerbatim("HGCalGeom") << "ID: " << HFNoseDetId(detId) 
                   << " with valid DetId from " << nOld 
                   << " to " << nNew;
   } else {
     edm::LogVerbatim("HGCalGeom") << "ID: " << HGCSiliconDetId(detId) 
                   << " with valid DetId from " << nOld 
                   << " to " << nNew;
   }
   edm::LogVerbatim("HGCalGeom") << "Cell[" << cellIndex << "] " << std::hex 
                 << geomId.rawId() << ":"  
                 << m_validGeomIds[cellIndex].rawId() 
                 << std::dec;
 #endif
 }

bool HGCalGeometry::present ( const DetId & id ) const

overridevirtual

is this detid present in the geometry?

Reimplemented from CaloSubdetectorGeometry.

Definition at line 220 of file HGCalGeometry.cc.

References HGCalTopology::detId2denseGeomId(), getGeometryDetId(), getGeometryRawPtr(), and m_topology.

Referenced by dbString().

                                                     {
   if (detId == DetId()) return false;
   DetId geomId = getGeometryDetId(detId);
   const uint32_t index (m_topology.detId2denseGeomId(geomId));
   return (nullptr != getGeometryRawPtr(index)) ;
 }

static std::string HGCalGeometry::producerTag ( )

inlinestatic

Definition at line 112 of file HGCalGeometry.h.

References cellElement(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PCaloGeometryBuilder::beginRun(), and CaloGeometryBuilder::produceAligned().

112 { return "HGCal" ; }

unsigned int HGCalGeometry::sizeForDenseIndex ( ) const

protected

Definition at line 596 of file HGCalGeometry.cc.

References m_topology, and HGCalTopology::totalGeomModules().

Referenced by topology().

                                                     {
   return m_topology.totalGeomModules();
 }

void HGCalGeometry::sortDetIds ( void )

Definition at line 709 of file HGCalGeometry.cc.

References CaloSubdetectorGeometry::m_validIds.

Referenced by HGCalGeometryLoader::build(), and topology().

                                       {
   m_validIds.shrink_to_fit();
   std::sort( m_validIds.begin(), m_validIds.end(), rawIdSort());
 }

const HGCalTopology& HGCalGeometry::topology ( ) const

inline

Definition at line 115 of file HGCalGeometry.h.

References addValidID(), cellGeomPtr(), getClosestCellIndex(), getGeometryDetId(), getGeometryRawPtr(), indexFor(), m_topology, CaloSubdetectorGeometry::sizeForDenseIndex(), sizeForDenseIndex(), and sortDetIds().

Referenced by hgc_digi_utils::addCellMetadata(), HGCalRecHitValidation::analyze(), HGCalDigiValidation::analyze(), PFRecHitQTestThresholdInThicknessNormalizedMIPs::beginEvent(), CaloTruthAccumulator::beginLuminosityBlock(), HGCDigitizer::checkPosition(), dbString(), HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhTopology(), CaloParticleDebugger::fillSimHits(), HGCalTriggerGeometryBase::hscTopology(), HGCalTriggerGeometryBase::hsiTopology(), hgcal::RecHitTools::maskCell(), neighborZ(), CaloGeometryBuilder::produceAligned(), HGCalRecHitWorkerSimple::set(), and HGCalUncalibRecHitRecWeightsAlgo< HGCDataFrame >::setGeometry().

115 {return m_topology;}

HGCalGeometry::m_topology

const HGCalTopology & m_topology

Definition: HGCalGeometry.h:143

Member Data Documentation

double HGCalGeometry::k_fac1 = 0.5

staticprivate

Definition at line 140 of file HGCalGeometry.h.

Referenced by getCorners(), and getNewCorners().

double HGCalGeometry::k_fac2 = 1.0/3.0

staticprivate

Definition at line 141 of file HGCalGeometry.h.

Referenced by get8Corners(), getCorners(), and getNewCorners().

double HGCalGeometry::k_half = 0.5

staticprivate

Definition at line 139 of file HGCalGeometry.h.

Referenced by get8Corners(), getCorners(), and getNewCorners().

unsigned int HGCalGeometry::k_NumberOfParametersPerHex = 3

static

Definition at line 47 of file HGCalGeometry.h.

Referenced by HGCalGeometryLoader::build(), and getSummary().

unsigned int HGCalGeometry::k_NumberOfParametersPerShape = 3

static

Definition at line 48 of file HGCalGeometry.h.

Referenced by CaloGeometryDBEP< T, U >::produceAligned().

unsigned int HGCalGeometry::k_NumberOfParametersPerTrd = 12

static

Definition at line 46 of file HGCalGeometry.h.

Referenced by HGCalGeometryLoader::build(), and getSummary().

unsigned int HGCalGeometry::k_NumberOfShapes = 100

static

Definition at line 49 of file HGCalGeometry.h.

Referenced by HGCalGeometryLoader::build(), getSummary(), and CaloGeometryDBEP< T, U >::produceAligned().

unsigned int HGCalGeometry::k_NumberOfShapesTrd = 1000

static

Definition at line 50 of file HGCalGeometry.h.

Referenced by HGCalGeometryLoader::build().

CellVec HGCalGeometry::m_cellVec

private

Definition at line 144 of file HGCalGeometry.h.

Referenced by cellGeomPtr(), get8Corners(), getClosestCell(), getClosestCellIndex(), getCorners(), getGeometryRawPtr(), getNewCorners(), getPosition(), HGCalGeometry(), indexFor(), and newCell().

CellVec2 HGCalGeometry::m_cellVec2

private

Definition at line 145 of file HGCalGeometry.h.

Referenced by cellGeomPtr(), get8Corners(), getClosestCell(), getClosestCellIndex(), getCorners(), getGeometryRawPtr(), getNewCorners(), getPosition(), HGCalGeometry(), indexFor(), and newCell().

DetId::Detector HGCalGeometry::m_det

private

Definition at line 148 of file HGCalGeometry.h.

Referenced by cellElement(), cellGeomPtr(), get8Corners(), getClosestCell(), getClosestCellIndex(), getCorners(), getGeometryRawPtr(), getNewCorners(), getSummary(), HGCalGeometry(), indexFor(), localCorners(), and newCell().

ForwardSubdetector HGCalGeometry::m_subdet

private

Definition at line 149 of file HGCalGeometry.h.

Referenced by cellElement().

const HGCalTopology& HGCalGeometry::m_topology

private

Definition at line 143 of file HGCalGeometry.h.

Referenced by get8Corners(), getClosestCell(), getCorners(), getGeometry(), getGeometryDetId(), getNewCorners(), getPosition(), getSummary(), HGCalGeometry(), indexFor(), neighborZ(), newCell(), present(), sizeForDenseIndex(), and topology().

std::vector<DetId> HGCalGeometry::m_validGeomIds

private

Definition at line 146 of file HGCalGeometry.h.

Referenced by cellGeomPtr(), getClosestCell(), getSummary(), getValidGeomDetIds(), and newCell().

HGCalGeometryMode::GeometryMode HGCalGeometry::mode_

private

Definition at line 147 of file HGCalGeometry.h.

Referenced by get8Corners(), getClosestCell(), getCorners(), getGeometryDetId(), getNewCorners(), getPosition(), getSummary(), and newCell().

const double HGCalGeometry::twoBysqrt3_

private

Definition at line 150 of file HGCalGeometry.h.

Referenced by getSummary().

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation