HGCalGeometry Class Reference

#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
GlobalPoint	getWaferPosition (const DetId &id) 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 constexpr unsigned int	k_NumberOfParametersPerHex = 3
static constexpr unsigned int	k_NumberOfParametersPerShape = 3
static constexpr unsigned int	k_NumberOfParametersPerTrd = 12
static constexpr unsigned int	k_NumberOfShapes = 100
static constexpr 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
virtual unsigned int	sizeForDenseIndex (const DetId &id) 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 constexpr double	k_fac1 = 0.5
static constexpr double	k_fac2 = 1.0 / 3.0
static constexpr 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

AlignedRecord

typedef HGCalGeometryRecord HGCalGeometry::AlignedRecord

Definition at line 41 of file HGCalGeometry.h.

CCGFloat

typedef CaloCellGeometry::CCGFloat HGCalGeometry::CCGFloat

Definition at line 34 of file HGCalGeometry.h.

CellVec

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

Definition at line 32 of file HGCalGeometry.h.

CellVec2

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

Definition at line 33 of file HGCalGeometry.h.

CornersVec

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

Definition at line 39 of file HGCalGeometry.h.

DetIdSet

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

Definition at line 38 of file HGCalGeometry.h.

PGeometryRecord

typedef PHGCalRcd HGCalGeometry::PGeometryRecord

Definition at line 42 of file HGCalGeometry.h.

Pt3D

typedef CaloCellGeometry::Pt3D HGCalGeometry::Pt3D

Definition at line 35 of file HGCalGeometry.h.

Pt3DVec

typedef CaloCellGeometry::Pt3DVec HGCalGeometry::Pt3DVec

Definition at line 36 of file HGCalGeometry.h.

Constructor & Destructor Documentation

HGCalGeometry()

HGCalGeometry::HGCalGeometry

(

const HGCalTopology &

topology

)

Definition at line 26 of file HGCalGeometry.cc.

    : 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
}

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

~HGCalGeometry()

HGCalGeometry::~HGCalGeometry ( )

override

Definition at line 44 of file HGCalGeometry.cc.

{}

Member Function Documentation

addValidID()

void HGCalGeometry::addValidID ( const DetId &  id )

protected

Definition at line 605 of file HGCalGeometry.cc.

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

cellElement()

std::string HGCalGeometry::cellElement

(

)

const

Definition at line 519 of file HGCalGeometry.cc.

                                           {
  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";
}

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

cellGeomPtr() [1/2]

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

overrideprotectedvirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 560 of file HGCalGeometry.cc.

                                                                                     {
  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;
  }
}

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

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

cellGeomPtr() [2/2]

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

private

Definition at line 578 of file HGCalGeometry.cc.

                                                                                                             {
  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;
  }
}

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

dbString()

static std::string HGCalGeometry::dbString ( )

inlinestatic

Definition at line 50 of file HGCalGeometry.h.

{ return "PHGCalRcd"; }

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

fillNamedParams()

void HGCalGeometry::fillNamedParams ( DDFilteredView  fv )

virtual

Definition at line 46 of file HGCalGeometry.cc.

{}

get8Corners()

HGCalGeometry::CornersVec HGCalGeometry::get8Corners

(

const DetId &

id

)

const

Definition at line 314 of file HGCalGeometry.cc.

                                                                           {
  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;
}

References HGCalDDDConstants::cellSizeTrap(), cms::cuda::co, funct::cos(), HGCalTopology::dddConstants(), HGCalTopology::decode(), flavorHistoryFilter_cfi::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_, alignCSCRings::r, findQualityFiles::rr, funct::sin(), findQualityFiles::v, and geometryCSVtoXML::xy.

getArea()

double HGCalGeometry::getArea

(

const DetId &

detid

)

const

Returns area of a cell.

Definition at line 248 of file HGCalGeometry.cc.

                                                      {
  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);
}

References custom_jme_cff::area, getNewCorners(), mps_fire::i, dqmiolumiharvest::j, dqmiodumpmetadata::n, and y.

getCells()

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 514 of file HGCalGeometry.cc.

                                                                                   {
  HGCalGeometry::DetIdSet dss;
  return dss;
}

getClosestCell()

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

overridevirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 464 of file HGCalGeometry.cc.

                                                              {
  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();
}

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_, alignCSCRings::r, HGCalGeometryMode::Trapezoid, and HGCalDDDConstants::waferTypeT().

Referenced by neighborZ().

getClosestCellIndex() [1/2]

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

protected

Definition at line 609 of file HGCalGeometry.cc.

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

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

Referenced by getClosestCell().

getClosestCellIndex() [2/2]

template<class T >

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

private

Definition at line 614 of file HGCalGeometry.cc.

                                                                                                   {
  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;
}

References funct::abs(), PVValHelper::dz, getPosition(), dqmdumpme::k, M_PI, alignCSCRings::r, and z.

getCorners()

HGCalGeometry::CornersVec HGCalGeometry::getCorners

(

const DetId &

id

)

const

Returns the corner points of this cell's volume.

Definition at line 262 of file HGCalGeometry.cc.

                                                                          {
  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;
}

References HGCalDDDConstants::cellSizeTrap(), cms::cuda::co, funct::cos(), HGCalTopology::dddConstants(), HGCalTopology::decode(), flavorHistoryFilter_cfi::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_, alignCSCRings::r, findQualityFiles::rr, funct::sin(), findQualityFiles::v, and geometryCSVtoXML::xy.

getGeometry()

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 175 of file HGCalGeometry.cc.

                                                                                         {
  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);
}

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

getGeometryDetId()

DetId HGCalGeometry::getGeometryDetId ( DetId  detId ) const

private

Definition at line 762 of file HGCalGeometry.cc.

                                                       {
  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;
}

References HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, HGCalTopology::isHFNose(), m_topology, mode_, and HGCalGeometryMode::Trapezoid.

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

getGeometryRawPtr()

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

overrideprotectedvirtual

Implements CaloSubdetectorGeometry.

Definition at line 545 of file HGCalGeometry.cc.

                                                                             {
  // 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);
  }
}

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

Referenced by present().

getNewCorners()

HGCalGeometry::CornersVec HGCalGeometry::getNewCorners

(

const DetId &

id

)

const

Definition at line 357 of file HGCalGeometry.cc.

                                                                             {
  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;
}

References HGCalDDDConstants::cellSizeTrap(), cms::cuda::co, funct::cos(), HGCalTopology::dddConstants(), HGCalTopology::decode(), flavorHistoryFilter_cfi::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_, alignCSCRings::r, findQualityFiles::rr, funct::sin(), findQualityFiles::v, and geometryCSVtoXML::xy.

Referenced by getArea().

getPosition()

GlobalPoint HGCalGeometry::getPosition

(

const DetId &

id

)

const

Definition at line 192 of file HGCalGeometry.cc.

                                                               {
  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, true);
      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;
}

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

Referenced by HGCalTBAnalyzer::analyzeDigi(), HGCalTBAnalyzer::analyzeRecHits(), HGCalTriggerGeometryImp1::buildMaps(), HGCalTriggerGeometryHexImp1::buildTriggerCellsAndModules(), HGCDigitizer::checkPosition(), HGCalSciNoiseMap::computeRadius(), HGCalTriggerNtupleHGCDigis::fill(), get8Corners(), getClosestCellIndex(), getCorners(), getGeometry(), HGCalTriggerGeometryHexImp2::getModulePosition(), HGCalTriggerGeometryHexLayerBasedImp1::getModulePosition(), HGCalTriggerGeometryV9Imp1::getModulePosition(), HGCalTriggerGeometryV9Imp2::getModulePosition(), getNewCorners(), hgcal::RecHitTools::getPosition(), HGCalTriggerGeometryHexImp2::getTriggerCellPosition(), HGCalTriggerGeometryHexLayerBasedImp1::getTriggerCellPosition(), HGCalTriggerGeometryV9Imp1::getTriggerCellPosition(), HGCalTriggerGeometryV9Imp2::getTriggerCellPosition(), and neighborZ().

getSummary()

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

overridevirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 660 of file HGCalGeometry.cc.

                                                                              {
  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());
      }
    }
  }
}

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(), HFNoseDetId::layer(), HGCSiliconDetId::layer(), HGCalDDDConstants::layerIndex(), m_det, m_topology, m_validGeomIds, mode_, CaloSubdetectorGeometry::numberOfParametersPerShape(), CaloSubdetectorGeometry::numberOfShapes(), CaloSubdetectorGeometry::numberOfTransformParms(), CalibrationSummaryClient_cfi::params, findQualityFiles::rr, HGCalDDDConstants::sectors(), HGCalParameters::hgtrap::tl, HGCalTopology::totalGeomModules(), HGCalGeometryMode::Trapezoid, groupFilesInBlocks::tt, twoBysqrt3_, and HGCalDDDConstants::waferInLayer().

getValidDetIds()

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 90 of file HGCalGeometry.h.

                                                                                                              {
    return m_validIds;
  }

References CaloSubdetectorGeometry::m_validIds.

getValidGeomDetIds()

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

inline

Definition at line 93 of file HGCalGeometry.h.

{ return m_validGeomIds; }

References m_validGeomIds.

getWaferPosition()

GlobalPoint HGCalGeometry::getWaferPosition

(

const DetId &

id

)

const

Definition at line 229 of file HGCalGeometry.cc.

                                                                    {
  unsigned int cellIndex = indexFor(detid);
  GlobalPoint glob;
  unsigned int maxSize = ((mode_ == HGCalGeometryMode::Trapezoid) ? m_cellVec2.size() : m_cellVec.size());
  if (cellIndex < maxSize) {
    const HepGeom::Point3D<float> lcoord(0, 0, 0);
    if (mode_ == HGCalGeometryMode::Trapezoid) {
      glob = m_cellVec2[cellIndex].getPosition(lcoord);
    } else {
      glob = m_cellVec[cellIndex].getPosition(lcoord);
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "getPositionTrap:: ID " << std::hex << detid.rawId() << std::dec << " index " 
                  << cellIndex << " Global " << glob;
#endif
  }
  return glob;
}

References TauDecayModes::dec, indexFor(), m_cellVec, m_cellVec2, reco_skim_cfg_mod::maxSize, mode_, DetId::rawId(), and HGCalGeometryMode::Trapezoid.

indexFor()

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

overrideprotectedvirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 530 of file HGCalGeometry.cc.

                                                             {
  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;
}

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 getWaferPosition().

initializeParms()

void HGCalGeometry::initializeParms ( )

overridevirtual

Reimplemented from CaloSubdetectorGeometry.

Definition at line 48 of file HGCalGeometry.cc.

{}

localCorners()

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

Definition at line 50 of file HGCalGeometry.cc.

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

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

neighborZ() [1/2]

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

Definition at line 398 of file HGCalGeometry.cc.

                                                                                    {
  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;
}

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().

neighborZ() [2/2]

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

Definition at line 426 of file HGCalGeometry.cc.

                                                                   {
  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;
}

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

newCell()

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

overridevirtual

Implements CaloSubdetectorGeometry.

Definition at line 58 of file HGCalGeometry.cc.

                                                                                                                   {
  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
}

References HGCalDDDConstants::cellInLayer(), postprocess-scan-build::cells, CaloSubdetectorGeometry::cornersMgr(), HGCalTopology::dddConstants(), TauDecayModes::dec, HGCalTopology::decode(), HGCalTopology::detId2denseGeomId(), HGCalTopology::encode(), DeadROC_duringRun::f1, DeadROC_duringRun::f2, 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, and HGCalTopology::valid().

present()

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

overridevirtual

is this detid present in the geometry?

Reimplemented from CaloSubdetectorGeometry.

Definition at line 184 of file HGCalGeometry.cc.

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

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

producerTag()

static std::string HGCalGeometry::producerTag ( )

inlinestatic

Definition at line 109 of file HGCalGeometry.h.

{ return "HGCal"; }

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

sizeForDenseIndex() [1/2]

unsigned int HGCalGeometry::sizeForDenseIndex ( ) const

protected

Definition at line 543 of file HGCalGeometry.cc.

{ return m_topology.totalGeomModules(); }

References m_topology, and HGCalTopology::totalGeomModules().

sizeForDenseIndex() [2/2]

unsigned int CaloSubdetectorGeometry::sizeForDenseIndex

protected

Definition at line 256 of file CaloSubdetectorGeometry.cc.

                                                                             {
  return CaloGenericDetId(id).sizeForDenseIndexing();
}

sortDetIds()

void HGCalGeometry::sortDetIds

(

void

)

Definition at line 655 of file HGCalGeometry.cc.

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

References CaloSubdetectorGeometry::m_validIds.

topology()

const HGCalTopology& HGCalGeometry::topology ( ) const

inline

Definition at line 112 of file HGCalGeometry.h.

{ return m_topology; }

References m_topology.

Referenced by PFRecHitQTestThresholdInThicknessNormalizedMIPs::beginEvent(), HGCDigitizer::checkPosition(), HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhTopology(), HGCalTriggerGeometryBase::hscTopology(), HGCalTriggerGeometryBase::hsiTopology(), hgcal::RecHitTools::maskCell(), neighborZ(), HGCalTriggerGeometryBase::noseTopology(), HGCalRecHitWorkerSimple::set(), and HGCalRadiationMap::setGeometry().

Member Data Documentation

k_fac1

constexpr double HGCalGeometry::k_fac1 = 0.5

staticconstexprprivate

Definition at line 135 of file HGCalGeometry.h.

Referenced by getCorners(), and getNewCorners().

k_fac2

constexpr double HGCalGeometry::k_fac2 = 1.0 / 3.0

staticconstexprprivate

Definition at line 136 of file HGCalGeometry.h.

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

k_half

constexpr double HGCalGeometry::k_half = 0.5

staticconstexprprivate

Definition at line 134 of file HGCalGeometry.h.

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

k_NumberOfParametersPerHex

constexpr unsigned int HGCalGeometry::k_NumberOfParametersPerHex = 3

staticconstexpr

Definition at line 45 of file HGCalGeometry.h.

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

k_NumberOfParametersPerShape

constexpr unsigned int HGCalGeometry::k_NumberOfParametersPerShape = 3

staticconstexpr

Definition at line 46 of file HGCalGeometry.h.

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

k_NumberOfParametersPerTrd

constexpr unsigned int HGCalGeometry::k_NumberOfParametersPerTrd = 12

staticconstexpr

Definition at line 44 of file HGCalGeometry.h.

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

k_NumberOfShapes

constexpr unsigned int HGCalGeometry::k_NumberOfShapes = 100

staticconstexpr

Definition at line 47 of file HGCalGeometry.h.

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

k_NumberOfShapesTrd

constexpr unsigned int HGCalGeometry::k_NumberOfShapesTrd = 1000

staticconstexpr

Definition at line 48 of file HGCalGeometry.h.

Referenced by HGCalGeometryLoader::build().

m_cellVec

CellVec HGCalGeometry::m_cellVec

private

Definition at line 139 of file HGCalGeometry.h.

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

m_cellVec2

CellVec2 HGCalGeometry::m_cellVec2

private

Definition at line 140 of file HGCalGeometry.h.

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

m_det

DetId::Detector HGCalGeometry::m_det

private

Definition at line 143 of file HGCalGeometry.h.

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

m_subdet

ForwardSubdetector HGCalGeometry::m_subdet

private

Definition at line 144 of file HGCalGeometry.h.

Referenced by cellElement().

m_topology

const HGCalTopology& HGCalGeometry::m_topology

private

Definition at line 138 of file HGCalGeometry.h.

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

m_validGeomIds

std::vector<DetId> HGCalGeometry::m_validGeomIds

private

Definition at line 141 of file HGCalGeometry.h.

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

mode_

HGCalGeometryMode::GeometryMode HGCalGeometry::mode_

private

Definition at line 142 of file HGCalGeometry.h.

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

twoBysqrt3_

const double HGCalGeometry::twoBysqrt3_

private

Definition at line 145 of file HGCalGeometry.h.

Referenced by getSummary().