HGCalDDDConstants Class Reference

#include <HGCalDDDConstants.h>

Public Member Functions
std::pair< int, int >	assignCell (float x, float y, int lay, int subSec, bool reco) const
std::array< int, 5 >	assignCellHex (float x, float y, int zside, int lay, bool reco, bool extend, bool debug) const
std::array< int, 3 >	assignCellTrap (float x, float y, float z, int lay, bool reco) const
double	calibCellRad (bool hd) const
std::vector< int >	calibCells (bool hd, bool full) const
bool	cassetteMode () const
bool	cassetteShiftScintillator (int zside, int layer, int iphi) const
bool	cassetteShiftSilicon (int zside, int layer, int waferU, int waferV) const
int	cassetteTile (int iphi) const
std::pair< double, double >	cellEtaPhiTrap (int type, int irad) const
bool	cellInLayer (int waferU, int waferV, int cellU, int cellV, int lay, int zside, bool reco) const
const HGCalCellOffset *	cellOffset () const
double	cellSizeHex (int type) const
std::pair< double, double >	cellSizeTrap (int type, int irad) const
double	cellThickness (int layer, int waferU, int waferV) const
int32_t	cellType (int type, int waferU, int waferV, int iz, int fwdBack, int orient) const
double	distFromEdgeHex (double x, double y, double z) const
double	distFromEdgeTrap (double x, double y, double z) const
void	etaPhiFromPosition (const double x, const double y, const double z, const int layer, int &ieta, int &iphi, int &type, double &wt) const
int	firstLayer () const
HGCalGeometryMode::GeometryMode	geomMode () const
int	getLayer (double z, bool reco) const
int	getLayerOffset () const
HGCalParameters::hgtrap	getModule (unsigned int k, bool hexType, bool reco) const
std::vector< HGCalParameters::hgtrap >	getModules () const
const HGCalParameters *	getParameter () const
int	getPhiBins (int lay) const
const std::vector< double > &	getRadiusLayer (int layer) const
std::pair< double, double >	getRangeR (int, bool reco) const
std::pair< int, int >	getREtaRange (int lay) const
HGCalParameters::hgtrform	getTrForm (unsigned int k) const
unsigned int	getTrFormN () const
std::vector< HGCalParameters::hgtrform >	getTrForms () const
int	getTypeHex (int layer, int waferU, int waferV) const
int	getTypeTrap (int layer) const
int	getUVMax (int type) const
std::pair< double, double >	getXY (int layer, double x, double y, bool forwd) const
double	guardRingOffset (bool reco) const
	HGCalDDDConstants (const HGCalParameters *hp, const std::string &name)
bool	isHalfCell (int waferType, int cell) const
bool	isValidHex (int lay, int mod, int cell, bool reco) const
bool	isValidHex8 (int lay, int waferU, int waferV, bool fullAndPart) const
bool	isValidHex8 (int lay, int modU, int modV, int cellU, int cellV, bool fullAndPart) const
bool	isValidTrap (int zside, int lay, int ieta, int iphi) const
int	lastLayer (bool reco) const
int	layerIndex (int lay, bool reco) const
unsigned int	layers (bool reco) const
unsigned int	layersInit (bool reco) const
int	layerType (int lay) const
int	levelTop (int ind=0) const
std::pair< float, float >	localToGlobal8 (int zside, int lay, int waferU, int waferV, double localX, double localY, bool reco, bool debug) const
std::pair< float, float >	locateCell (int cell, int lay, int type, bool reco) const
std::pair< float, float >	locateCell (int zside, int lay, int waferU, int waferV, int cellU, int cellV, bool reco, bool all, bool norot, bool cog, bool debug) const
std::pair< float, float >	locateCell (const HGCSiliconDetId &, bool cog, bool debug) const
std::pair< float, float >	locateCell (const HGCScintillatorDetId &, bool debug) const
std::pair< float, float >	locateCellHex (int cell, int wafer, bool reco) const
std::pair< float, float >	locateCellTrap (int zside, int lay, int ieta, int iphi, bool reco, bool debug) const
bool	maskCell (const DetId &id, int corners) const
int	maxCells (bool reco) const
int	maxCells (int lay, bool reco) const
int	maxCellUV () const
int	maxModules () const
int	maxModulesPerLayer () const
int	maxRows (int lay, bool reco) const
double	minSlope () const
int	modifyUV (int uv, int type1, int type2) const
int	modules (int lay, bool reco) const
int	modulesInit (int lay, bool reco) const
double	mouseBite (bool reco) const
int	numberCells (bool reco) const
std::vector< int >	numberCells (int lay, bool reco) const
int	numberCellsHexagon (int wafer) const
int	numberCellsHexagon (int lay, int waferU, int waferV, bool flag) const
int	partialWaferType (int lay, int waferU, int waferV) const
std::pair< double, double >	rangeR (double z, bool reco) const
std::pair< double, double >	rangeRLayer (int lay, bool reco) const
std::pair< double, double >	rangeZ (bool reco) const
std::pair< int, int >	rowColumnWafer (const int wafer) const
int	sectors () const
double	sensorSizeOffset (bool reco) const
std::pair< int, int >	simToReco (int cell, int layer, int mod, bool half) const
int	tileCount (int layer, int ring) const
bool	tileExist (int zside, int layer, int ring, int phi) const
HGCalParameters::tileInfo	tileInfo (int zside, int layer, int ring) const
bool	tilePhiEdge (double phi, int layer, int iphi) const
bool	tileRingEdge (double rho, int layer, int ring) const
std::pair< int, int >	tileRings (int layer) const
int	tileSiPM (int sipm) const
bool	tileTrapezoid () const
std::pair< int, int >	tileType (int layer, int ring, int phi) const
bool	trapezoidFile () const
bool	v17OrLess () const
unsigned int	volumes () const
int	waferCount (const int type) const
int	waferFileIndex (unsigned int kk) const
std::tuple< int, int, int, int >	waferFileInfo (unsigned int kk) const
bool	waferFileInfoExist (int kk) const
std::tuple< int, int, int, int >	waferFileInfoFromIndex (int kk) const
unsigned int	waferFileSize () const
int	waferFromCopy (int copy) const
void	waferFromPosition (const double x, const double y, int &wafer, int &icell, int &celltyp) const
void	waferFromPosition (const double x, const double y, const int zside, const int layer, int &waferU, int &waferV, int &cellU, int &cellV, int &celltype, double &wt, bool extend, bool debug) const
bool	waferFullInLayer (int wafer, int lay, bool reco) const
bool	waferHexagon6 () const
bool	waferHexagon8 () const
bool	waferHexagon8File () const
bool	waferHexagon8Fine () const
bool	waferHexagon8Module () const
HGCalParameters::waferInfo	waferInfo (int lay, int waferU, int waferV) const
bool	waferInLayer (int wafer, int lay, bool reco) const
GlobalPoint	waferLocal2Global (HepGeom::Point3D< float > &loc, const DetId &id, bool useWafer, bool reco, bool debug) const
int	waferMax () const
int	waferMin () const
std::pair< double, double >	waferParameters (bool reco) const
std::pair< double, double >	waferPosition (int wafer, bool reco) const
std::pair< double, double >	waferPosition (int lay, int waferU, int waferV, bool reco, bool debug) const
int	wafers () const
int	wafers (int layer, int type) const
double	waferSepar (bool reco) const
double	waferSize (bool reco) const
int	waferToCopy (int wafer) const
int	waferType (DetId const &id, bool fromFile) const
int	waferType (int layer, int waferU, int waferV, bool fromFile) const
std::tuple< int, int, int >	waferType (HGCSiliconDetId const &id, bool fromFile) const
int	waferTypeL (int wafer) const
std::pair< int, int >	waferTypeRotation (int layer, int waferU, int waferV, bool fromFile, bool debug) const
int	waferTypeT (int wafer) const
int	waferUVMax () const
bool	waferVirtual (int layer, int waferU, int waferV) const
double	waferZ (int layer, bool reco) const
	~HGCalDDDConstants ()=default

Private Types
typedef std::array< int, 3 >	HGCWaferParam
typedef std::array< std::vector< int32_t >, 2 >	Simrecovecs

Private Member Functions
int	cellHex (double xx, double yy, const double &cellR, const std::vector< double > &posX, const std::vector< double > &posY) const
void	cellHex (double xloc, double yloc, int cellType, int place, int part, int &cellU, int &cellV, bool extend, bool debug) const
std::pair< int, float >	getIndex (int lay, bool reco) const
bool	isValidCell (int layindex, int wafer, int cell) const
bool	isValidCell8 (int lay, int waferU, int waferV, int cellU, int cellV, int type) const
int	layerFromIndex (int index, bool reco) const
int32_t	waferIndex (int wafer, int index) const
bool	waferInLayerTest (int wafer, int lay, bool full) const
std::pair< double, double >	waferPosition (int waferU, int waferV, bool reco) const
std::pair< double, double >	waferPositionNoRot (int lay, int waferU, int waferV, bool reco, bool debug) const

Private Attributes
std::unique_ptr< HGCalCellOffset >	cellOffset_
const bool	fullAndPart_
HGCalGeomTools	geomTools_
double	hexside_
double	hexsideT_
HGCalCassette	hgcassette_
std::unique_ptr< HGCalCell >	hgcell_
std::unique_ptr< HGCalCellUV >	hgcellUV_
const HGCalParameters *	hgpar_
Simrecovecs	max_modules_layer_
int32_t	maxWafersPerLayer_
const HGCalGeometryMode::GeometryMode	mode_
int32_t	modHalf_
double	rmax_
double	rmaxT_
const double	sqrt3_
std::array< uint32_t, 2 >	tot_layers_
int32_t	tot_wafers_
std::unordered_map< int32_t, bool >	waferIn_
std::map< int, HGCWaferParam >	waferLayer_
std::array< int, 4 >	waferMax_

Static Private Attributes
static constexpr float	dPhiMin = 0.02
static constexpr double	k_horizontalShift = 1.0
static constexpr double	tan30deg_ = 0.5773502693
static constexpr double	tol_ = 0.001

Detailed Description

this class reads the constant section of the numbering xml-files of the high granulairy calorimeter

Date

2014/03/20 00:06:50

Author

Sunanda Banerjee, SINP sunan.nosp@m.da.b.nosp@m.anerj.nosp@m.ee@c.nosp@m.ern.c.nosp@m.h

Definition at line 36 of file HGCalDDDConstants.h.

Member Typedef Documentation

HGCWaferParam

typedef std::array<int, 3> HGCalDDDConstants::HGCWaferParam

private

Definition at line 287 of file HGCalDDDConstants.h.

Simrecovecs

typedef std::array<std::vector<int32_t>, 2> HGCalDDDConstants::Simrecovecs

private

Definition at line 286 of file HGCalDDDConstants.h.

Constructor & Destructor Documentation

HGCalDDDConstants()

HGCalDDDConstants::HGCalDDDConstants	(	const HGCalParameters *	hp,
		const std::string &	name
	)

Definition at line 25 of file HGCalDDDConstants.cc.

References cassetteMode(), HGCalParameters::cassettes_, HGCalParameters::cassetteShift_, cellOffset_, HGCalParameters::cellSize_, funct::cos(), fullAndPart_, getIndex(), getTrForm(), getTrFormN(), HGCalParameters::guardRingOffset_, hexside_, hexsideT_, hgcassette_, hgcell_, hgcellUV_, hgpar_, mps_fire::i, HGCalParameters::k_ScaleFromDDD, HGCalParameters::hgtrform::lay, nano_mu_digi_cff::layer, layers(), layersInit(), SiStripPI::max, max_modules_layer_, maxCells(), maxWafersPerLayer_, mode_, modHalf_, modulesInit(), HGCalParameters::mouseBite_, Skims_PA_cff::name, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, rmax_, rmaxT_, sectors(), HGCalParameters::sensorSeparation_, HGCalParameters::sensorSizeOffset_, HGCalCassette::setParameter(), tan30deg_, tot_layers_, tot_wafers_, HGCalParameters::waferCopy_, waferHexagon6(), waferHexagon8(), waferIn_, HGCalWaferIndex::waferIndex(), waferInLayer(), waferLayer_, waferMax_, HGCalParameters::waferR_, wafers(), HGCalParameters::waferSize_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), cms::cuda::wmax, and cms::cuda::wmin.

    : hgpar_(hp), sqrt3_(std::sqrt(3.0)), mode_(hgpar_->mode_), fullAndPart_(waferHexagon8File()) {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::Mode " << mode_ << " FullAndPart " << fullAndPart_;
#endif
  if (waferHexagon6() || waferHexagon8()) {
    rmax_ = (HGCalParameters::k_ScaleFromDDD * (hgpar_->waferR_) * std::cos(30._deg));
    rmaxT_ = rmax_ + 0.5 * hgpar_->sensorSeparation_;
    hexside_ = 2.0 * rmax_ * tan30deg_;
    hexsideT_ = 2.0 * rmaxT_ * tan30deg_;
    hgcell_ = std::make_unique<HGCalCell>(2.0 * rmaxT_, hgpar_->nCellsFine_, hgpar_->nCellsCoarse_);
    hgcellUV_ = std::make_unique<HGCalCellUV>(
        2.0 * rmax_, hgpar_->sensorSeparation_, hgpar_->nCellsFine_, hgpar_->nCellsCoarse_);
    cellOffset_ = std::make_unique<HGCalCellOffset>(hgpar_->waferSize_,
                                                    hgpar_->nCellsFine_,
                                                    hgpar_->nCellsCoarse_,
                                                    hgpar_->guardRingOffset_,
                                                    hgpar_->mouseBite_,
                                                    hgpar_->sensorSizeOffset_);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::rmax_ " << rmax_ << ":" << rmaxT_ << ":" << hexside_ << ":"
                                  << hexsideT_ << " CellSize "
                                  << 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[0] << ":"
                                  << 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[1];
#endif
  } else {
    hgcell_.reset();
    hgcellUV_.reset();
    cellOffset_.reset();
  }
  if (cassetteMode()) {
    hgcassette_.setParameter(hgpar_->cassettes_, hgpar_->cassetteShift_);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::Setup HGCalCassette for " << hgpar_->cassettes_
                                  << " cassettes";
#endif
  }
  // init maps and constants
  modHalf_ = 0;
  maxWafersPerLayer_ = 0;
  for (int simreco = 0; simreco < 2; ++simreco) {
    tot_layers_[simreco] = layersInit((bool)simreco);
    max_modules_layer_[simreco].resize(tot_layers_[simreco] + 1);
    for (unsigned int layer = 1; layer <= tot_layers_[simreco]; ++layer) {
      max_modules_layer_[simreco][layer] = modulesInit(layer, (bool)simreco);
      if (simreco == 1) {
        modHalf_ += max_modules_layer_[simreco][layer];
        maxWafersPerLayer_ = std::max(maxWafersPerLayer_, max_modules_layer_[simreco][layer]);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::Layer " << layer << " with "
                                      << max_modules_layer_[simreco][layer] << ":" << modHalf_ << " modules in RECO";
      } else {
        edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::Layer " << layer << " with "
                                      << max_modules_layer_[simreco][layer] << " modules in SIM";
#endif
      }
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::SimReco " << simreco << " with " << tot_layers_[simreco]
                                  << " Layers";
#endif
  }
  tot_wafers_ = wafers();

#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants initialized for " << name << " with " << layers(false) << ":"
                                << layers(true) << " layers, " << wafers() << ":" << 2 * modHalf_
                                << " wafers with maximum " << maxWafersPerLayer_ << " per layer and "
                                << "maximum of " << maxCells(false) << ":" << maxCells(true) << " cells";
#endif
  if (waferHexagon6() || waferHexagon8()) {
    int wminT(9999999), wmaxT(-9999999), kount1(0), kount2(0);
    for (unsigned int i = 0; i < getTrFormN(); ++i) {
      int lay0 = getTrForm(i).lay;
      int wmin(9999999), wmax(-9999999), kount(0);
      for (int wafer = 0; wafer < sectors(); ++wafer) {
        bool waferIn = waferInLayer(wafer, lay0, true);
        if (waferHexagon8()) {
          int kndx = HGCalWaferIndex::waferIndex(lay0,
                                                 HGCalWaferIndex::waferU(hgpar_->waferCopy_[wafer]),
                                                 HGCalWaferIndex::waferV(hgpar_->waferCopy_[wafer]));
          waferIn_[kndx] = waferIn;
        }
        if (waferIn) {
          int waferU = ((waferHexagon6()) ? wafer : HGCalWaferIndex::waferU(hgpar_->waferCopy_[wafer]));
          if (waferU < wmin)
            wmin = waferU;
          if (waferU > wmax)
            wmax = waferU;
          ++kount;
        }
      }
      if (wminT > wmin)
        wminT = wmin;
      if (wmaxT < wmax)
        wmaxT = wmax;
      if (kount1 < kount)
        kount1 = kount;
      kount2 += kount;
#ifdef EDM_ML_DEBUG
      int lay1 = getIndex(lay0, true).first;
      edm::LogVerbatim("HGCalGeom") << "Index " << i << " Layer " << lay0 << ":" << lay1 << " Wafer " << wmin << ":"
                                    << wmax << ":" << kount;
#endif
      HGCWaferParam a1{{wmin, wmax, kount}};
      waferLayer_[lay0] = a1;
    }
    waferMax_ = std::array<int, 4>{{wminT, wmaxT, kount1, kount2}};
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "Overall wafer statistics: " << wminT << ":" << wmaxT << ":" << kount1 << ":"
                                  << kount2;
#endif
  }
}

~HGCalDDDConstants()

HGCalDDDConstants::~HGCalDDDConstants ( )

default

Member Function Documentation

assignCell()

std::pair< int, int > HGCalDDDConstants::assignCell	(	float	x,
		float	y,
		int	lay,
		int	subSec,
		bool	reco
	)		const

Definition at line 140 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellHex(), HGCalParameters::cellSize_, getIndex(), hgpar_, HGCalParameters::k_ScaleFromDDD, dt_dqm_sourceclient_common_cff::reco, rmax_, findQualityFiles::size, waferHexagon6(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, x, geometryCSVtoXML::xx, y, and geometryCSVtoXML::yy.

Referenced by HGCalGeometry::getClosestCell().

                                                                                                      {
  const auto& index = getIndex(lay, reco);
  if (index.first < 0)
    return std::make_pair(-1, -1);
  if (waferHexagon6()) {
    float xx = (reco) ? x : HGCalParameters::k_ScaleFromDDD * x;
    float yy = (reco) ? y : HGCalParameters::k_ScaleFromDDD * y;

    // First the wafer
    int wafer = cellHex(xx, yy, rmax_, hgpar_->waferPosX_, hgpar_->waferPosY_);
    if (wafer < 0 || wafer >= static_cast<int>(hgpar_->waferTypeT_.size())) {
      edm::LogWarning("HGCalGeom") << "Wafer no. out of bound for " << wafer << ":" << (hgpar_->waferTypeT_).size()
                                   << ":" << (hgpar_->waferPosX_).size() << ":" << (hgpar_->waferPosY_).size()
                                   << " ***** ERROR *****";
      return std::make_pair(-1, -1);
    } else {
      // Now the cell
      xx -= hgpar_->waferPosX_[wafer];
      yy -= hgpar_->waferPosY_[wafer];
      if (hgpar_->waferTypeT_[wafer] == 1)
        return std::make_pair(wafer,
                              cellHex(xx,
                                      yy,
                                      0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[0],
                                      hgpar_->cellFineX_,
                                      hgpar_->cellFineY_));
      else
        return std::make_pair(wafer,
                              cellHex(xx,
                                      yy,
                                      0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[1],
                                      hgpar_->cellCoarseX_,
                                      hgpar_->cellCoarseY_));
    }
  } else {
    return std::make_pair(-1, -1);
  }
}

assignCellHex()

std::array< int, 5 > HGCalDDDConstants::assignCellHex	(	float	x,
		float	y,
		int	zside,
		int	lay,
		bool	reco,
		bool	extend,
		bool	debug
	)		const

Definition at line 179 of file HGCalDDDConstants.cc.

References debug, HGCalParameters::k_ScaleToDDD, dt_dqm_sourceclient_common_cff::reco, waferFromPosition(), waferHexagon8(), waferType(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), x, geometryCSVtoXML::xx, y, geometryCSVtoXML::yy, and ecaldqm::zside().

Referenced by HGCalGeometry::getClosestCell(), and HGCalGeometry::getClosestCellHex().

                                                                                    {
  int waferU(0), waferV(0), waferType(-1), cellU(0), cellV(0);
  if (waferHexagon8()) {
    double xx = (reco) ? HGCalParameters::k_ScaleToDDD * x : x;
    double yy = (reco) ? HGCalParameters::k_ScaleToDDD * y : y;
    double wt(1.0);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "assignCellHex x " << x << ":" << xx << " y " << y << ":" << yy << " Lay " << lay;
#endif
    waferFromPosition(xx, yy, zside, lay, waferU, waferV, cellU, cellV, waferType, wt, extend, debug);
  }
  return std::array<int, 5>{{waferU, waferV, waferType, cellU, cellV}};
}

assignCellTrap()

std::array< int, 3 > HGCalDDDConstants::assignCellTrap	(	float	x,
		float	y,
		float	z,
		int	lay,
		bool	reco
	)		const

Definition at line 194 of file HGCalDDDConstants.cc.

References funct::abs(), cassetteMode(), HGCalParameters::cassettes_, angle_units::operators::convertRadToDeg(), HGCalParameters::firstLayer_, getIndex(), HGCalCassette::getShift(), hgcassette_, hgpar_, hcalRecHitTable_cff::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, nano_mu_digi_cff::layer, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, M_PI, HGCalParameters::nphiCassette_, phi, HGCalParameters::phiOffset_, alignCSCRings::r, HGCalParameters::radiusLayer_, dt_dqm_sourceclient_common_cff::reco, HGCalParameters::scintCells(), HGCalParameters::scintCellSize(), HGCalParameters::scintType(), mathSSE::sqrt(), HGCalTileIndex::tileCassette(), tileExist(), tilePhiEdge(), tileRingEdge(), tol_, x, HGCalParameters::xLayerHex_, geometryCSVtoXML::xx, y, HGCalParameters::yLayerHex_, geometryCSVtoXML::yy, z, and ecaldqm::zside().

Referenced by HGCalGeometry::getClosestCell(), and HGCalNumberingScheme::getUnitID().

                                                                                                        {
  int irad(-1), iphi(-1), type(-1);
  const auto& indx = getIndex(layer, reco);
  if (indx.first < 0)
    return std::array<int, 3>{{irad, iphi, type}};
  int zside = (z > 0) ? 1 : -1;
  double xx = (reco) ? (zside * x) : (zside * HGCalParameters::k_ScaleFromDDD * x);
  double yy = (reco) ? y : HGCalParameters::k_ScaleFromDDD * y;
  int ll = layer - hgpar_->firstLayer_;
  xx -= hgpar_->xLayerHex_[ll];
  yy -= hgpar_->yLayerHex_[ll];
  double phi = (((yy == 0.0) && (xx == 0.0)) ? 0. : std::atan2(yy, xx));
  if (phi < 0)
    phi += (2.0 * M_PI);
  if (indx.second != 0)
    iphi = (1 + static_cast<int>(phi / indx.second)) % hgpar_->scintCells(layer);
  if (iphi == 0)
    iphi = hgpar_->scintCells(layer);
  if (cassetteMode()) {
    int cassette = HGCalTileIndex::tileCassette(iphi, hgpar_->phiOffset_, hgpar_->nphiCassette_, hgpar_->cassettes_);
    auto cshift = hgcassette_.getShift(layer, -1, cassette);
#ifdef EDM_ML_DEBUG
    std::ostringstream st1;
    st1 << "Cassette " << cassette << " Shift " << cshift.first << ":" << cshift.second << " Original " << xx << ":"
        << yy;
#endif
    xx += (zside * cshift.first);
    yy -= cshift.second;
#ifdef EDM_ML_DEBUG
    st1 << " Shifted " << xx << ":" << yy;
    edm::LogVerbatim("HGCalGeomT") << st1.str();
#endif
  }
  type = hgpar_->scintType(layer);
  double r = std::sqrt(xx * xx + yy * yy);
  auto ir = std::lower_bound(hgpar_->radiusLayer_[type].begin(), hgpar_->radiusLayer_[type].end(), r);
  irad = static_cast<int>(ir - hgpar_->radiusLayer_[type].begin());
  irad = std::clamp(irad, hgpar_->iradMinBH_[indx.first], hgpar_->iradMaxBH_[indx.first]);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeomT") << "assignCellTrap Input " << x << ":" << y << ":" << z << ":" << layer << ":" << reco
                                 << " x|y|r " << xx << ":" << yy << ":" << r << " phi " << phi << ":"
                                 << convertRadToDeg(phi) << " o/p " << irad << ":" << iphi << ":" << type;
#endif
  if (!tileExist(zside, layer, irad, iphi)) {
    if (tileRingEdge(r, layer, irad)) {
      if (std::abs(r - hgpar_->radiusLayer_[type][irad - 1]) < tol_) {
        --irad;
        if (irad <= hgpar_->iradMinBH_[indx.first])
          irad = hgpar_->iradMinBH_[indx.first];
      } else {
        ++irad;
        if (irad > hgpar_->iradMaxBH_[indx.first])
          irad = hgpar_->iradMaxBH_[indx.first];
      }
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeomT") << "assignCellTrap: ring # modified to " << irad << ":"
                                     << hgpar_->iradMinBH_[indx.first] << ":" << hgpar_->iradMaxBH_[indx.first];
      ;
#endif
    } else if (tilePhiEdge(phi, layer, iphi)) {
      if (std::abs(phi - hgpar_->scintCellSize(layer) * (iphi - 1)) < tol_) {
        --iphi;
        if (iphi <= 0)
          iphi = 1;
      } else {
        ++iphi;
        if (iphi > hgpar_->scintCells(layer))
          iphi = 1;
      }
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeomT") << "assignCellTrap: iphi # modified to " << iphi << ":"
                                     << hgpar_->scintCells(layer);
#endif
    }
  }
  return std::array<int, 3>{{irad, iphi, type}};
}

calibCellRad()

double HGCalDDDConstants::calibCellRad ( bool  hd ) const

inline

Definition at line 51 of file HGCalDDDConstants.h.

References HGCalParameters::calibCellRHD_, HGCalParameters::calibCellRLD_, and hgpar_.

Referenced by HGCalSD::update().

{ return (hd ? hgpar_->calibCellRHD_ : hgpar_->calibCellRLD_); }

calibCells()

std::vector<int> HGCalDDDConstants::calibCells ( bool  hd, bool  full  ) const

inline

Definition at line 44 of file HGCalDDDConstants.h.

References HGCalParameters::calibCellFullHD_, HGCalParameters::calibCellFullLD_, HGCalParameters::calibCellPartHD_, HGCalParameters::calibCellPartLD_, full, and hgpar_.

Referenced by HGCalSD::update().

                                                      {
    if (hd) {
      return (full ? hgpar_->calibCellFullHD_ : hgpar_->calibCellPartHD_);
    } else {
      return (full ? hgpar_->calibCellFullLD_ : hgpar_->calibCellPartLD_);
    }
  }

cassetteMode()

bool HGCalDDDConstants::cassetteMode ( ) const

inline

Definition at line 52 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8CalibCell, HGCalGeometryMode::Hexagon8Cassette, HGCalGeometryMode::Hexagon8FineCell, mode_, HGCalGeometryMode::TrapezoidCassette, and HGCalGeometryMode::TrapezoidFineCell.

Referenced by assignCellTrap(), cassetteShiftScintillator(), cassetteShiftSilicon(), cellHex(), cellInLayer(), HGCalDDDConstants(), isValidCell8(), localToGlobal8(), locateCell(), locateCellTrap(), maskCell(), and waferFromPosition().

                            {
    return ((mode_ == HGCalGeometryMode::Hexagon8Cassette) || (mode_ == HGCalGeometryMode::TrapezoidCassette) ||
            (mode_ == HGCalGeometryMode::Hexagon8CalibCell) || (mode_ == HGCalGeometryMode::Hexagon8FineCell) ||
            (mode_ == HGCalGeometryMode::TrapezoidFineCell));
  }

cassetteShiftScintillator()

bool HGCalDDDConstants::cassetteShiftScintillator	(	int	zside,
		int	layer,
		int	iphi
	)		const

Definition at line 286 of file HGCalDDDConstants.cc.

References cassetteMode(), cassetteTile(), HGCalCassette::getShift(), hgcassette_, hcalRecHitTable_cff::iphi, nano_mu_digi_cff::layer, edm::shift, and ecaldqm::zside().

Referenced by HGCScintSD::setDetUnitId().

                                                                                      {
  bool shift(false);
  if (cassetteMode()) {
    auto cshift = hgcassette_.getShift(layer, zside, cassetteTile(iphi));
    if ((cshift.first != 0) || (cshift.second != 0))
      shift = true;
  }
  return shift;
}

cassetteShiftSilicon()

bool HGCalDDDConstants::cassetteShiftSilicon	(	int	zside,
		int	layer,
		int	waferU,
		int	waferV
	)		const

Definition at line 272 of file HGCalDDDConstants.cc.

References cassetteMode(), HGCalCassette::getShift(), hgcassette_, hgpar_, nano_mu_digi_cff::layer, edm::shift, HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), and ecaldqm::zside().

Referenced by HGCalSD::setDetUnitId().

                                                                                               {
  bool shift(false);
  if (cassetteMode()) {
    int indx = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
    auto ktr = hgpar_->waferInfoMap_.find(indx);
    if (ktr != hgpar_->waferInfoMap_.end()) {
      auto cshift = hgcassette_.getShift(layer, zside, (ktr->second).cassette);
      if ((cshift.first != 0) || (cshift.second != 0))
        shift = true;
    }
  }
  return shift;
}

cassetteTile()

int HGCalDDDConstants::cassetteTile ( int  iphi ) const

inline

Definition at line 59 of file HGCalDDDConstants.h.

References HGCalParameters::cassettes_, hgpar_, hcalRecHitTable_cff::iphi, HGCalParameters::nphiCassette_, HGCalParameters::phiOffset_, and HGCalTileIndex::tileCassette().

Referenced by cassetteShiftScintillator().

                                   {
    return (HGCalTileIndex::tileCassette(iphi, hgpar_->phiOffset_, hgpar_->nphiCassette_, hgpar_->cassettes_));
  }

cellEtaPhiTrap()

std::pair< double, double > HGCalDDDConstants::cellEtaPhiTrap	(	int	type,
		int	irad
	)		const

Definition at line 296 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, das-up-to-nevents::df, l1ctLayer1_cff::dr, hgpar_, alignCSCRings::r, HGCalParameters::radiusLayer_, and tileTrapezoid().

                                                                                  {
  double dr(0), df(0);
  if (tileTrapezoid()) {
    double r = 0.5 * ((hgpar_->radiusLayer_[type][irad - 1] + hgpar_->radiusLayer_[type][irad]));
    dr = (hgpar_->radiusLayer_[type][irad] - hgpar_->radiusLayer_[type][irad - 1]);
    df = r * hgpar_->cellSize_[type];
  }
  return std::make_pair(dr, df);
}

cellHex() [1/2]

int HGCalDDDConstants::cellHex ( double  xx, double  yy, const double &  cellR, const std::vector< double > &  posX, const std::vector< double > &  posY  ) const

private

Definition at line 1959 of file HGCalDDDConstants.cc.

References funct::abs(), PVValHelper::dx, PVValHelper::dy, dqmdumpme::k, EgammaValidation_cff::num, RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, tan30deg_, TrackerOfflineValidation_Dqm_cff::xmax, geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

Referenced by assignCell(), and waferFromPosition().

                                                                                                                   {
  int num(0);
  const double tol(0.00001);
  double cellY = 2.0 * cellR * tan30deg_;
  for (unsigned int k = 0; k < posX.size(); ++k) {
    double dx = std::abs(xx - posX[k]);
    double dy = std::abs(yy - posY[k]);
    if (dx <= (cellR + tol) && dy <= (cellY + tol)) {
      double xmax = (dy <= 0.5 * cellY) ? cellR : (cellR - (dy - 0.5 * cellY) / tan30deg_);
      if (dx <= (xmax + tol)) {
        num = k;
        break;
      }
    }
  }
  return num;
}

cellHex() [2/2]

void HGCalDDDConstants::cellHex ( double  xloc, double  yloc, int  cellType, int  place, int  part, int &  cellU, int &  cellV, bool  extend, bool  debug  ) const

private

Definition at line 1978 of file HGCalDDDConstants.cc.

References funct::abs(), cassetteMode(), cellType(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), debug, newFWLiteAna::found, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgcellUV_, hgpar_, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, SiStripPI::max, SiStripPI::min, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, rmax_, rmaxT_, edm::shift, sqrt3_, V0Monitor_cff::v0, HGCalTypes::WaferFull, and waferHexagon8File().

                                                                                                                        {
  if (cassetteMode()) {
    auto uv = (part == HGCalTypes::WaferFull)
                  ? hgcellUV_->cellUVFromXY3(xloc, yloc, place, cellType, true, debug)
                  : hgcellUV_->cellUVFromXY1(xloc, yloc, place, cellType, part, true, debug);
    cellU = uv.first;
    cellV = uv.second;
  } else if (waferHexagon8File()) {
    auto uv = hgcellUV_->cellUVFromXY3(xloc, yloc, place, cellType, extend, debug);
    cellU = uv.first;
    cellV = uv.second;
  } else {
    int ncell = ((cellType == HGCSiliconDetId::HGCalHD120) || (cellType == HGCSiliconDetId::HGCalHD200))
                    ? hgpar_->nCellsFine_
                    : hgpar_->nCellsCoarse_;
    double delY = 2 * rmax_ / (3 * ncell);
    double delX = 0.5 * delY * sqrt3_;
    double delYT = (extend) ? (2 * rmaxT_ / (3 * ncell)) : delY;
    double delXT = 0.5 * delYT * sqrt3_;
    double v0 = ((xloc / delY - 1.0) / 1.5);
    int cv0 = (v0 > 0) ? (ncell + static_cast<int>(v0 + 0.5)) : (ncell - static_cast<int>(-v0 + 0.5));
    double u0 = (0.5 * yloc / delX + 0.5 * cv0);
    int cu0 = (u0 > 0) ? (ncell / 2 + static_cast<int>(u0 + 0.5)) : (ncell / 2 - static_cast<int>(-u0 + 0.5));
    cu0 = std::max(0, std::min(cu0, 2 * ncell - 1));
    cv0 = std::max(0, std::min(cv0, 2 * ncell - 1));
    if (cv0 - cu0 >= ncell)
      cv0 = cu0 + ncell - 1;
    if (debug)
      edm::LogVerbatim("HGCalGeom") << "cellHex: input " << xloc << ":" << yloc << ":" << cellType << " parameter "
                                    << delX << ":" << delY << " u0 " << u0 << ":" << cu0 << " v0 " << v0 << ":" << cv0;
    bool found(false);
    static constexpr int shift[3] = {0, 1, -1};
    for (int i1 = 0; i1 < 3; ++i1) {
      cellU = cu0 + shift[i1];
      for (int i2 = 0; i2 < 3; ++i2) {
        cellV = cv0 + shift[i2];
        if (((cellV - cellU) < ncell) && ((cellU - cellV) <= ncell) && (cellU >= 0) && (cellV >= 0) &&
            (cellU < 2 * ncell) && (cellV < 2 * ncell)) {
          double xc = (1.5 * (cellV - ncell) + 1.0) * delY;
          double yc = (2 * cellU - cellV - ncell) * delX;
          if ((std::abs(yloc - yc) <= delXT) && (std::abs(xloc - xc) <= delYT) &&
              ((std::abs(xloc - xc) <= 0.5 * delYT) ||
               (std::abs(yloc - yc) <= sqrt3_ * (delYT - std::abs(xloc - xc))))) {
            if (debug)
              edm::LogVerbatim("HGCalGeom")
                  << "cellHex: local " << xc << ":" << yc << " difference " << std::abs(xloc - xc) << ":"
                  << std::abs(yloc - yc) << ":" << sqrt3_ * (delY - std::abs(yloc - yc)) << " comparator " << delX
                  << ":" << delY << " (u,v) = (" << cellU << "," << cellV << ")";
            found = true;
            break;
          }
        }
      }
      if (found)
        break;
    }
    if (!found) {
      cellU = cu0;
      cellV = cv0;
    }
  }
}

cellInLayer()

bool HGCalDDDConstants::cellInLayer	(	int	waferU,
		int	waferV,
		int	cellU,
		int	cellV,
		int	lay,
		int	zside,
		bool	reco
	)		const

Definition at line 306 of file HGCalDDDConstants.cc.

References cassetteMode(), getIndex(), HGCalWaferMask::goodCell(), HGCalGeometryMode::Hexagon8Module, hgpar_, locateCell(), mode_, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, hgcalPerformanceValidation::orient, HGCalParameters::rMinLayHex_, mathSSE::sqrt(), HGCalTypes::WaferFull, HGCalTypes::WaferHD120, HGCalTypes::WaferHD200, waferHexagon6(), waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalTypes::WaferOrient0, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), geometryCSVtoXML::xy, and ecaldqm::zside().

Referenced by HGCalGeometry::newCell().

                                                                                                                     {
  const auto& indx = getIndex(lay, true);
  if (indx.first >= 0) {
    if (cassetteMode()) {
      int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
      auto ktr = hgpar_->waferInfoMap_.find(indx);
      int part = (ktr != hgpar_->waferInfoMap_.end()) ? (ktr->second).part : HGCalTypes::WaferFull;
      return HGCalWaferMask::goodCell(cellU, cellV, part);
    } else if (mode_ == HGCalGeometryMode::Hexagon8Module) {
      int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
      auto ktr = hgpar_->waferInfoMap_.find(indx);
      int thck(HGCalTypes::WaferHD120), part(HGCalTypes::WaferFull), rotn(HGCalTypes::WaferOrient0);
      if (ktr != hgpar_->waferInfoMap_.end()) {
        thck = (ktr->second).type;
        part = (ktr->second).part;
        rotn = (ktr->second).orient;
      }
      int ncell = ((thck == HGCalTypes::WaferHD120) || (thck == HGCalTypes::WaferHD200)) ? hgpar_->nCellsFine_
                                                                                         : hgpar_->nCellsCoarse_;
      return HGCalWaferMask::goodCell(cellU, cellV, ncell, part, rotn);
    } else if (waferHexagon8() || waferHexagon6()) {
      const auto& xy =
          ((waferHexagon8()) ? locateCell(zside, lay, waferU, waferV, cellU, cellV, reco, true, false, false, false)
                             : locateCell(cellU, lay, waferU, reco));
      double rpos = sqrt(xy.first * xy.first + xy.second * xy.second);
      return ((rpos >= hgpar_->rMinLayHex_[indx.first]) && (rpos <= hgpar_->rMaxLayHex_[indx.first]));
    } else {
      return true;
    }
  } else {
    return false;
  }
}

cellOffset()

const HGCalCellOffset* HGCalDDDConstants::cellOffset ( ) const

inline

Definition at line 64 of file HGCalDDDConstants.h.

References cellOffset_.

{ return cellOffset_.get(); }

cellSizeHex()

double HGCalDDDConstants::cellSizeHex

(

int

type

)

const

Definition at line 353 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, hgpar_, HGCalParameters::k_ScaleFromDDD, tileTrapezoid(), and waferHexagon8().

Referenced by hgcal::RecHitTools::getRadiusToSide().

                                                    {
  int indx = ((waferHexagon8()) ? ((type >= 1) ? 1 : 0) : ((type == 1) ? 1 : 0));
  double cell = (tileTrapezoid() ? 0.5 * hgpar_->cellSize_[indx]
                                 : 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[indx]);
  return cell;
}

cellSizeTrap()

std::pair<double, double> HGCalDDDConstants::cellSizeTrap ( int  type, int  irad  ) const

inline

Definition at line 66 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::radiusLayer_.

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

                                                                        {
    return std::make_pair(hgpar_->radiusLayer_[type][irad - 1], hgpar_->radiusLayer_[type][irad]);
  }

cellThickness()

double HGCalDDDConstants::cellThickness	(	int	layer,
		int	waferU,
		int	waferV
	)		const

Definition at line 340 of file HGCalDDDConstants.cc.

References HGCalParameters::cellThickness_, hgpar_, nano_mu_digi_cff::layer, waferHexagon6(), waferHexagon8(), waferType(), HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

Referenced by HGCalTB23Analyzer::analyzeSimHits(), and hgcal::RecHitTools::getSiThickness().

                                                                               {
  double thick(-1);
  int type = waferType(layer, waferU, waferV, false);
  if (type >= 0) {
    if (waferHexagon8()) {
      thick = 10000.0 * hgpar_->cellThickness_[type];  // cm to micron
    } else if (waferHexagon6()) {
      thick = 100.0 * (type + 1);  // type = 1,2,3 for 100,200,300 micron
    }
  }
  return thick;
}

cellType()

int32_t HGCalDDDConstants::cellType	(	int	type,
		int	waferU,
		int	waferV,
		int	iz,
		int	fwdBack,
		int	orient
	)		const

Definition at line 360 of file HGCalDDDConstants.cc.

References HGCalCell::cellPlacementIndex(), HGCalCell::cellPlacementOld, HGCalCell::cellType(), HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, and hgcalPerformanceValidation::orient.

Referenced by cellHex(), and HGCalTopology::neighbors().

                                                                                                         {
  int placement = (orient < 0) ? HGCalCell::cellPlacementOld : HGCalCell::cellPlacementIndex(iz, fwdBack, orient);
  int ncell = ((type == HGCSiliconDetId::HGCalHD120) || (type == HGCSiliconDetId::HGCalHD200)) ? hgpar_->nCellsFine_
                                                                                               : hgpar_->nCellsCoarse_;
  auto cellType = HGCalCell::cellType(cellU, cellV, ncell, placement);
  return cellType.first;
}

distFromEdgeHex()

double HGCalDDDConstants::distFromEdgeHex	(	double	x,
		double	y,
		double	z
	)		const

Definition at line 368 of file HGCalDDDConstants.cc.

References funct::abs(), PVValHelper::dx, PVValHelper::dy, getLayer(), hexside_, hgpar_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, layerIndex(), rmax_, sqrt3_, tan30deg_, waferHexagon8(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, x, HGCalParameters::xLayerHex_, geometryCSVtoXML::xx, y, HGCalParameters::yLayerHex_, geometryCSVtoXML::yy, and z.

Referenced by HFNoseSD::isItinFidVolume().

                                                                            {
  // Assming the point is within a hexagonal plane of the wafer, calculate
  // the shortest distance from the edge
  if (z < 0)
    x = -x;
  double dist(0);
  // Input x, y in Geant4 unit and transformed to CMSSW standard
  double xx = HGCalParameters::k_ScaleFromDDD * x;
  double yy = HGCalParameters::k_ScaleFromDDD * y;
  if (waferHexagon8()) {
    int ll = layerIndex(getLayer(z, false), false);
    xx -= hgpar_->xLayerHex_[ll];
    yy -= hgpar_->yLayerHex_[ll];
  }
  int sizew = static_cast<int>(hgpar_->waferPosX_.size());
  int wafer = sizew;
  // Transform to the local coordinate frame of the wafer first
  for (int k = 0; k < sizew; ++k) {
    double dx = std::abs(xx - hgpar_->waferPosX_[k]);
    double dy = std::abs(yy - hgpar_->waferPosY_[k]);
    if ((dx <= rmax_) && (dy <= hexside_) && ((dy <= 0.5 * hexside_) || (dx * tan30deg_ <= (hexside_ - dy)))) {
      wafer = k;
      xx -= hgpar_->waferPosX_[k];
      yy -= hgpar_->waferPosY_[k];
      break;
    }
  }
  // Look at only one quarter (both x,y are positive)
  if (wafer < sizew) {
    if (std::abs(yy) < 0.5 * hexside_) {
      dist = rmax_ - std::abs(xx);
    } else {
      dist = 0.5 * ((rmax_ - std::abs(xx)) - sqrt3_ * (std::abs(yy) - 0.5 * hexside_));
    }
  } else {
    dist = 0;
  }
  dist *= HGCalParameters::k_ScaleToDDD;
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DistFromEdgeHex: Local " << xx << ":" << yy << " wafer " << wafer << " flag "
                                << (wafer < sizew) << " Distance " << rmax_ << ":" << (rmax_ - std::abs(xx)) << ":"
                                << (std::abs(yy) - 0.5 * hexside_) << ":" << 0.5 * hexside_ << ":" << dist;
#endif
  return dist;
}

distFromEdgeTrap()

double HGCalDDDConstants::distFromEdgeTrap	(	double	x,
		double	y,
		double	z
	)		const

Definition at line 414 of file HGCalDDDConstants.cc.

References funct::abs(), getLayer(), hgpar_, hcalRecHitTable_cff::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, layerIndex(), pfDeepBoostedJetPreprocessParams_cfi::lower_bound, M_PI, SiStripPI::max, SiStripPI::min, phi, alignCSCRings::r, HGCalParameters::radiusLayer_, HGCalParameters::scintCellSize(), HGCalParameters::scintType(), mathSSE::sqrt(), x, geometryCSVtoXML::xx, y, and z.

Referenced by HGCScintSD::isItinFidVolume().

                                                                             {
  // Assming the point is within the eta-phi plane of the scintillator tile,
  // calculate the shortest distance from the edge
  int lay = getLayer(z, false);
  double xx = (z < 0) ? -x : x;
  int indx = layerIndex(lay, false);
  double r = HGCalParameters::k_ScaleFromDDD * std::sqrt(x * x + y * y);
  double phi = (r == 0. ? 0. : std::atan2(y, xx));
  if (phi < 0)
    phi += (2.0 * M_PI);
  int type = hgpar_->scintType(lay);
  double cell = hgpar_->scintCellSize(lay);
  // Compare with the center of the tile find distances along R and also phi
  // Take the smaller value
  auto ir = std::lower_bound(hgpar_->radiusLayer_[type].begin(), hgpar_->radiusLayer_[type].end(), r);
  int irad = static_cast<int>(ir - hgpar_->radiusLayer_[type].begin());
  irad = std::clamp(irad, hgpar_->iradMinBH_[indx], hgpar_->iradMaxBH_[indx]);
  int iphi = 1 + static_cast<int>(phi / cell);
  double dphi = std::max(0.0, (0.5 * cell - std::abs(phi - (iphi - 0.5) * cell)));
  double dist = std::min((r - hgpar_->radiusLayer_[type][irad - 1]), (hgpar_->radiusLayer_[type][irad] - r));
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DistFromEdgeTrap: Global " << x << ":" << y << ":" << z << " Layer " << lay
                                << " Index " << indx << ":" << type << " xx " << xx << " R " << r << ":" << irad << ":"
                                << hgpar_->radiusLayer_[type][irad - 1] << ":" << hgpar_->radiusLayer_[type][irad]
                                << " Phi " << phi << ":" << iphi << ":" << (iphi - 0.5) * cell << " cell " << cell
                                << " Dphi " << dphi << " Dist " << dist << ":" << r * dphi;
#endif
  return HGCalParameters::k_ScaleToDDD * std::min(r * dphi, dist);
}

etaPhiFromPosition()

void HGCalDDDConstants::etaPhiFromPosition	(	const double	x,
		const double	y,
		const double	z,
		const int	layer,
		int &	ieta,
		int &	iphi,
		int &	type,
		double &	wt
	)		const

firstLayer()

int HGCalDDDConstants::firstLayer ( ) const

inline

Definition at line 81 of file HGCalDDDConstants.h.

References HGCalParameters::firstLayer_, and hgpar_.

Referenced by HGCalDigiValidation::dqmBeginRun(), HGCalRecHitValidation::dqmBeginRun(), HGCalSimHitValidation::dqmBeginRun(), HGCalTopology::HGCalTopology(), HGCalGeometry::neighborZ(), HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_(), and HGCScintSD::update().

{ return hgpar_->firstLayer_; }

geomMode()

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

Definition at line 82 of file HGCalDDDConstants.h.

References mode_.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTopology::HGCalTopology(), HGCScintSD::update(), HFNoseSD::update(), and HGCalSD::update().

{ return mode_; }

getIndex()

std::pair< int, float > HGCalDDDConstants::getIndex ( int  lay, bool  reco  ) const

private

Definition at line 2042 of file HGCalDDDConstants.cc.

References hgpar_, layerIndex(), HGCalParameters::moduleCellR_, HGCalParameters::moduleCellS_, HGCalParameters::scintCellSize(), waferHexagon6(), and waferHexagon8().

Referenced by assignCell(), assignCellTrap(), cellInLayer(), HGCalDDDConstants(), isValidTrap(), locateCell(), locateCellTrap(), maxCells(), maxRows(), modules(), modulesInit(), numberCells(), rangeRLayer(), simToReco(), waferFullInLayer(), waferInLayer(), wafers(), and waferZ().

                                                                        {
  int indx = layerIndex(lay, reco);
  if (indx < 0)
    return std::make_pair(-1, 0);
  float cell(0);
  if (waferHexagon6()) {
    cell = (reco ? hgpar_->moduleCellR_[0] : hgpar_->moduleCellS_[0]);
  } else {
    if (waferHexagon8()) {
      cell = (reco ? hgpar_->moduleCellR_[0] : hgpar_->moduleCellS_[0]);
    } else {
      cell = hgpar_->scintCellSize(lay);
    }
  }
  return std::make_pair(indx, cell);
}

getLayer()

int HGCalDDDConstants::getLayer	(	double	z,
		bool	reco
	)		const

Definition at line 444 of file HGCalDDDConstants.cc.

References funct::abs(), HGCalParameters::firstLayer_, hgpar_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layerGroupO_, layerIndex(), dt_dqm_sourceclient_common_cff::reco, waferHexagon6(), z, HGCalParameters::zLayerHex_, and geometryCSVtoXML::zz.

Referenced by distFromEdgeHex(), distFromEdgeTrap(), HGCalGeometry::getClosestCell(), and HGCalGeometry::getClosestCellHex().

                                                         {
  // Get the layer # from the gloabl z coordinate
  unsigned int k = 0;
  double zz = (reco ? std::abs(z) : HGCalParameters::k_ScaleFromDDD * std::abs(z));
  const auto& zLayerHex = hgpar_->zLayerHex_;
  auto itr = std::find_if(zLayerHex.begin() + 1, zLayerHex.end(), [&k, &zz, &zLayerHex](double zLayer) {
    ++k;
    return zz < 0.5 * (zLayerHex[k - 1] + zLayerHex[k]);
  });
  int lay = (itr == zLayerHex.end()) ? static_cast<int>(zLayerHex.size()) : k;
  if (waferHexagon6() && reco) {
    int indx = layerIndex(lay, false);
    if (indx >= 0)
      lay = hgpar_->layerGroupO_[indx];
  } else {
    lay += (hgpar_->firstLayer_ - 1);
  }
  return lay;
}

getLayerOffset()

int HGCalDDDConstants::getLayerOffset ( ) const

inline

Definition at line 84 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::layerOffset_.

Referenced by HGCalNumberingScheme::HGCalNumberingScheme().

{ return hgpar_->layerOffset_; }

getModule()

HGCalParameters::hgtrap HGCalDDDConstants::getModule	(	unsigned int	k,
		bool	hexType,
		bool	reco
	)		const

Definition at line 464 of file HGCalDDDConstants.cc.

References HGCalParameters::getModule(), HGCSiliconDetId::HGCalLD300, hgpar_, findQualityFiles::size, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, and HGCalParameters::waferTypeL_.

Referenced by HGCalGeometry::getSummary().

                                                                                                   {
  HGCalParameters::hgtrap mytr;
  if (hexType) {
    if (indx >= hgpar_->waferTypeL_.size())
      edm::LogWarning("HGCalGeom") << "Wafer no. out bound for index " << indx << ":" << (hgpar_->waferTypeL_).size()
                                   << ":" << (hgpar_->waferPosX_).size() << ":" << (hgpar_->waferPosY_).size()
                                   << " ***** ERROR *****";
    unsigned int type =
        ((indx < hgpar_->waferTypeL_.size()) ? hgpar_->waferTypeL_[indx] - 1 : HGCSiliconDetId::HGCalLD300);
    mytr = hgpar_->getModule(type, reco);
  } else {
    mytr = hgpar_->getModule(indx, reco);
  }
  return mytr;
}

getModules()

std::vector< HGCalParameters::hgtrap > HGCalDDDConstants::getModules

(

)

const

Definition at line 480 of file HGCalDDDConstants.cc.

References HGCalParameters::getModule(), hgpar_, dqmdumpme::k, and HGCalParameters::moduleLayR_.

                                                                     {
  std::vector<HGCalParameters::hgtrap> mytrs;
  for (unsigned int k = 0; k < hgpar_->moduleLayR_.size(); ++k)
    mytrs.emplace_back(hgpar_->getModule(k, true));
  return mytrs;
}

getParameter()

const HGCalParameters* HGCalDDDConstants::getParameter ( ) const

inline

Definition at line 87 of file HGCalDDDConstants.h.

References hgpar_.

Referenced by HGCalMouseBiteTester::analyze(), HGCGuardRing::exclude(), HGCGuardRingPartial::exclude(), HGCalGeometry::getSummary(), HGCalNumberingScheme::getUnitID(), HGCalCalibrationCell::HGCalCalibrationCell(), HeterogeneousHGCalHEFCellPositionsFiller::produce(), HFNoseSD::update(), and HGCalSD::update().

{ return hgpar_; }

getPhiBins()

int HGCalDDDConstants::getPhiBins

(

int

lay

)

const

Definition at line 487 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::scintCells(), and tileTrapezoid().

{ return (tileTrapezoid() ? hgpar_->scintCells(lay) : 0); }

getRadiusLayer()

const std::vector<double>& HGCalDDDConstants::getRadiusLayer ( int  layer ) const

inline

Definition at line 91 of file HGCalDDDConstants.h.

References hgpar_, nano_mu_digi_cff::layer, HGCalParameters::radiusLayer_, HGCalParameters::scintType(), and tileTrapezoid().

                                                                  {
    return hgpar_->radiusLayer_[(tileTrapezoid() ? hgpar_->scintType(layer) : 0)];
  }

getRangeR()

std::pair< double, double > HGCalDDDConstants::getRangeR	(	int	lay,
		bool	reco
	)		const

Definition at line 489 of file HGCalDDDConstants.cc.

References hgpar_, layerIndex(), HGCalParameters::rMaxLayHex_, and HGCalParameters::rMinLayHex_.

                                                                             {
  int indx = layerIndex(lay, false);
  if ((indx >= 0) && (indx < static_cast<int>(hgpar_->rMinLayHex_.size())))
    return std::make_pair(hgpar_->rMinLayHex_[indx], hgpar_->rMaxLayHex_[indx]);
  else
    return std::make_pair(0, -1.);
}

getREtaRange()

std::pair< int, int > HGCalDDDConstants::getREtaRange

(

int

lay

)

const

Definition at line 497 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, layerIndex(), and tileTrapezoid().

Referenced by HGCalTriggerGeometryV9Imp2::getModuleFromTriggerCell(), and HGCalTriggerGeometryV9Imp2::getTriggerCellsFromModule().

                                                               {
  int irmin(0), irmax(0);
  if (tileTrapezoid()) {
    int indx = layerIndex(lay, false);
    if ((indx >= 0) && (indx < static_cast<int>(hgpar_->iradMinBH_.size()))) {
      irmin = hgpar_->iradMinBH_[indx];
      irmax = hgpar_->iradMaxBH_[indx];
    }
  }
  return std::make_pair(irmin, irmax);
}

getTrForm()

HGCalParameters::hgtrform HGCalDDDConstants::getTrForm ( unsigned int  k ) const

inline

Definition at line 94 of file HGCalDDDConstants.h.

References HGCalParameters::getTrForm(), hgpar_, and dqmdumpme::k.

Referenced by HGCalGeometry::getSummary(), and HGCalDDDConstants().

{ return hgpar_->getTrForm(k); }

getTrFormN()

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 95 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::trformIndex_.

Referenced by HGCalGeometry::getSummary(), and HGCalDDDConstants().

{ return hgpar_->trformIndex_.size(); }

getTrForms()

std::vector< HGCalParameters::hgtrform > HGCalDDDConstants::getTrForms

(

)

const

Definition at line 509 of file HGCalDDDConstants.cc.

References HGCalParameters::getTrForm(), hgpar_, dqmdumpme::k, and HGCalParameters::trformIndex_.

Referenced by HGCalTrackCollectionProducer::beginLuminosityBlock().

                                                                       {
  std::vector<HGCalParameters::hgtrform> mytrs;
  for (unsigned int k = 0; k < hgpar_->trformIndex_.size(); ++k)
    mytrs.emplace_back(hgpar_->getTrForm(k));
  return mytrs;
}

getTypeHex()

int HGCalDDDConstants::getTypeHex	(	int	layer,
		int	waferU,
		int	waferV
	)		const

Definition at line 525 of file HGCalDDDConstants.cc.

References hgpar_, nano_mu_digi_cff::layer, HGCalParameters::typesInLayers_, waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferTypeL_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

Referenced by HGCalTriggerGeometryV9Imp2::detIdWaferType(), HGCalTriggerGeometryV9Imp3::detIdWaferType(), and HGCalTopology::neighbors().

                                                                         {
  // Get the module type for a silicon wafer
  if (waferHexagon8()) {
    auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
    return ((itr == hgpar_->typesInLayers_.end() ? 2 : hgpar_->waferTypeL_[itr->second]));
  } else {
    return -1;
  }
}

getTypeTrap()

int HGCalDDDConstants::getTypeTrap

(

int

layer

)

const

Definition at line 516 of file HGCalDDDConstants.cc.

References hgpar_, nano_mu_digi_cff::layer, HGCalParameters::scintType(), and tileTrapezoid().

Referenced by HGCalTriggerGeometryV9Imp3::detIdWaferType().

                                                  {
  // Get the module type for scinitllator
  if (tileTrapezoid()) {
    return hgpar_->scintType(layer);
  } else {
    return -1;
  }
}

getUVMax()

int HGCalDDDConstants::getUVMax ( int  type ) const

inline

Definition at line 100 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::nCellsCoarse_, and HGCalParameters::nCellsFine_.

Referenced by maskCell(), HGCalTopology::neighbors(), and HGCalSD::update().

{ return ((type == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_); }

getXY()

std::pair< double, double > HGCalDDDConstants::getXY	(	int	layer,
		double	x,
		double	y,
		bool	forwd
	)		const

Definition at line 535 of file HGCalDDDConstants.cc.

References HGCalParameters::firstLayer_, hgpar_, nano_mu_digi_cff::layer, HGCalParameters::layerRotV_, HGCalParameters::layerType_, x, testProducerWithPsetDescEmpty_cfi::x1, y, and testProducerWithPsetDescEmpty_cfi::y1.

Referenced by localToGlobal8(), locateCell(), waferFromPosition(), waferLocal2Global(), and waferPosition().

                                                                                                {
  int ll = layer - hgpar_->firstLayer_;
  double x0(x), y0(y);
  if ((!hgpar_->layerType_.empty()) && (ll < static_cast<int>(hgpar_->layerRotV_.size()))) {
    if (forwd) {
      x0 = x * hgpar_->layerRotV_[ll].first + y * hgpar_->layerRotV_[ll].second;
      y0 = y * hgpar_->layerRotV_[ll].first - x * hgpar_->layerRotV_[ll].second;
    } else {
      x0 = x * hgpar_->layerRotV_[ll].first - y * hgpar_->layerRotV_[ll].second;
      y0 = y * hgpar_->layerRotV_[ll].first + x * hgpar_->layerRotV_[ll].second;
    }
  }
#ifdef EDM_ML_DEBUG
  double x1(x0), y1(y0);
  if (ll < static_cast<int>(hgpar_->layerRotV_.size())) {
    if (forwd) {
      x1 = x0 * hgpar_->layerRotV_[ll].first - y0 * hgpar_->layerRotV_[ll].second;
      y1 = y0 * hgpar_->layerRotV_[ll].first + x0 * hgpar_->layerRotV_[ll].second;
    } else {
      x1 = x0 * hgpar_->layerRotV_[ll].first + y0 * hgpar_->layerRotV_[ll].second;
      y1 = y0 * hgpar_->layerRotV_[ll].first - x0 * hgpar_->layerRotV_[ll].second;
    }
  }
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants: Layer " << layer << ":" << ll << " mode " << forwd << " x " << x
                                << ":" << x0 << ":" << x1 << " y " << y << ":" << y0 << ":" << y1;
#endif
  return std::make_pair(x0, y0);
}

guardRingOffset()

double HGCalDDDConstants::guardRingOffset

(

bool

reco

)

const

Definition at line 564 of file HGCalDDDConstants.cc.

References HGCalParameters::guardRingOffset_, hgpar_, and HGCalParameters::k_ScaleToDDD.

Referenced by HGCalSD::update().

                                                         {
  return (reco ? hgpar_->guardRingOffset_ : HGCalParameters::k_ScaleToDDD * hgpar_->guardRingOffset_);
}

isHalfCell()

bool HGCalDDDConstants::isHalfCell	(	int	waferType,
		int	cell
	)		const

Definition at line 568 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseHalf_, HGCalParameters::cellFineHalf_, hgpar_, HGCalTypes::WaferLD200, HGCalTypes::WaferLD300, and waferType().

Referenced by hgcal::RecHitTools::isHalfCell().

                                                                {
  if (waferType < 1 || cell < 0)
    return false;
  return ((waferType == HGCalTypes::WaferLD200) || (waferType == HGCalTypes::WaferLD300))
             ? hgpar_->cellCoarseHalf_[cell]
             : hgpar_->cellFineHalf_[cell];
}

isValidCell()

bool HGCalDDDConstants::isValidCell ( int  layindex, int  wafer, int  cell  ) const

private

Definition at line 2079 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, mps_fire::result, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, findQualityFiles::rr, mathSSE::sqrt(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, x, and y.

Referenced by isValidHex().

                                                                      {
  // Calculate the position of the cell
  // Works for options HGCalHexagon/HGCalHexagonFull
  double x = hgpar_->waferPosX_[wafer];
  double y = hgpar_->waferPosY_[wafer];
  if (((hgpar_->waferTypeT_[wafer] - 1) == HGCSiliconDetId::HGCalHD120) ||
      ((hgpar_->waferTypeT_[wafer] - 1) == HGCSiliconDetId::HGCalHD200)) {
    x += hgpar_->cellFineX_[cell];
    y += hgpar_->cellFineY_[cell];
  } else {
    x += hgpar_->cellCoarseX_[cell];
    y += hgpar_->cellCoarseY_[cell];
  }
  double rr = sqrt(x * x + y * y);
  bool result = ((rr >= hgpar_->rMinLayHex_[lay - 1]) && (rr <= hgpar_->rMaxLayHex_[lay - 1]) &&
                 (wafer < static_cast<int>(hgpar_->waferPosX_.size())));
#ifdef EDM_ML_DEBUG
  if (!result)
    edm::LogVerbatim("HGCalGeom") << "Input " << lay << ":" << wafer << ":" << cell << " Position " << x << ":" << y
                                  << ":" << rr << " Compare Limits " << hgpar_->rMinLayHex_[lay - 1] << ":"
                                  << hgpar_->rMaxLayHex_[lay - 1] << " Flag " << result;
#endif
  return result;
}

isValidCell8()

bool HGCalDDDConstants::isValidCell8 ( int  lay, int  waferU, int  waferV, int  cellU, int  cellV, int  type  ) const

private

Definition at line 2104 of file HGCalDDDConstants.cc.

References cassetteMode(), HGCalParameters::cellCoarseIndex_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineIndex_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCalParameters::firstLayer_, HGCalWaferMask::goodCell(), HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, mode_, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, mps_fire::result, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, findQualityFiles::rr, mathSSE::sqrt(), waferHexagon8File(), waferPositionNoRot(), waferTypeRotation(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), x, geometryCSVtoXML::xy, and y.

Referenced by isValidHex8().

                                                                                                          {
  bool result(false);
  auto partn = waferTypeRotation(lay, waferU, waferV, false, false);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "waferHexagon8 " << waferHexagon8File() << ":" << mode_ << ":" << cassetteMode()
                                << " part " << partn.first << ":" << partn.second;
#endif
  if (cassetteMode()) {
    result = HGCalWaferMask::goodCell(cellU, cellV, partn.first);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "Input " << lay << ":" << waferU << ":" << waferV << ":" << cellU << ":" << cellV
                                  << " Result " << result << " from goodCell";
#endif
  } else {
    float x(0), y(0);
    int kndx = cellV * 100 + cellU;
    if ((type == HGCSiliconDetId::HGCalHD120) || (type == HGCSiliconDetId::HGCalHD200)) {
      auto ktr = hgpar_->cellFineIndex_.find(kndx);
      if (ktr != hgpar_->cellFineIndex_.end()) {
        x = hgpar_->cellFineX_[ktr->second];
        y = hgpar_->cellFineY_[ktr->second];
      }
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "Fine " << cellU << ":" << cellV << ":" << kndx << ":" << x << ":" << y << ":"
                                    << (ktr != hgpar_->cellFineIndex_.end());
#endif
    } else {
      auto ktr = hgpar_->cellCoarseIndex_.find(kndx);
      if (ktr != hgpar_->cellCoarseIndex_.end()) {
        x = hgpar_->cellCoarseX_[ktr->second];
        y = hgpar_->cellCoarseY_[ktr->second];
      }
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "Coarse " << cellU << ":" << cellV << ":" << kndx << ":" << x << ":" << y << ":"
                                    << (ktr != hgpar_->cellCoarseIndex_.end());
#endif
    }
    const auto& xy = waferPositionNoRot(lay, waferU, waferV, true, false);
    x += xy.first;
    y += xy.second;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "With wafer (" << waferU << "," << waferV << ") " << x << ":" << y;
#endif
    double rr = sqrt(x * x + y * y);
    int ll = lay - hgpar_->firstLayer_;
    double tol = waferHexagon8File() ? 0.5 : 0.0;
    result = (((rr + tol) >= hgpar_->rMinLayHex_[ll]) && (rr <= hgpar_->rMaxLayHex_[ll]));
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "Input " << lay << ":" << ll << ":" << waferU << ":" << waferV << ":" << cellU
                                  << ":" << cellV << " Position " << x << ":" << y << ":" << rr << " Compare Limits "
                                  << hgpar_->rMinLayHex_[ll] << ":" << hgpar_->rMaxLayHex_[ll] << " Flag " << result
                                  << " from Radius Limits";
#endif
    if (result && waferHexagon8File()) {
      int N = ((type == HGCSiliconDetId::HGCalHD120) || (type == HGCSiliconDetId::HGCalHD200)) ? hgpar_->nCellsFine_
                                                                                               : hgpar_->nCellsCoarse_;
      result = HGCalWaferMask::goodCell(cellU, cellV, N, partn.first, partn.second);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "Input " << lay << ":" << waferU << ":" << waferV << ":" << cellU << ":" << cellV
                                    << " N " << N << " part " << partn.first << ":" << partn.second << " Result "
                                    << result << " from goodCell";
#endif
    }
  }
  return result;
}

isValidHex()

bool HGCalDDDConstants::isValidHex	(	int	lay,
		int	mod,
		int	cell,
		bool	reco
	)		const

Definition at line 576 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::copiesInLayers_, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, isValidCell(), layers(), maxCells(), mod(), mps_fire::result, findQualityFiles::size, HGCalParameters::waferCopy_, waferHexagon6(), and HGCalParameters::waferTypeT_.

Referenced by HGCalTopology::valid().

                                                                              {
  // Check validity for a layer|wafer|cell of pre-TDR version
  bool result(false), resultMod(false);
  int cellmax(0);
  if (waferHexagon6()) {
    int32_t copyNumber = hgpar_->waferCopy_[mod];
    result = ((lay > 0 && lay <= static_cast<int>(layers(reco))));
    if (result) {
      const int32_t lay_idx = reco ? (lay - 1) * 3 + 1 : lay;
      const auto& the_modules = hgpar_->copiesInLayers_[lay_idx];
      auto moditr = the_modules.find(copyNumber);
      result = resultMod = (moditr != the_modules.end());
#ifdef EDM_ML_DEBUG
      if (!result)
        edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants: Layer " << lay << ":" << lay_idx << " Copy " << copyNumber
                                      << ":" << mod << " Flag " << result;
#endif
      if (result) {
        if (moditr->second >= 0) {
          if (mod >= static_cast<int>(hgpar_->waferTypeT_.size()))
            edm::LogWarning("HGCalGeom") << "Module no. out of bound for " << mod << " to be compared with "
                                         << (hgpar_->waferTypeT_).size() << " ***** ERROR *****";
          cellmax = (((hgpar_->waferTypeT_[mod] - 1) == HGCSiliconDetId::HGCalHD120) ||
                     ((hgpar_->waferTypeT_[mod] - 1) == HGCSiliconDetId::HGCalHD200))
                        ? static_cast<int>(hgpar_->cellFineX_.size())
                        : static_cast<int>(hgpar_->cellCoarseX_.size());
          result = (cell >= 0 && cell <= cellmax);
        } else {
          result = isValidCell(lay_idx, mod, cell);
        }
      }
    }
  }

#ifdef EDM_ML_DEBUG
  if (!result)
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants: Layer " << lay << ":"
                                  << (lay > 0 && (lay <= static_cast<int>(layers(reco)))) << " Module " << mod << ":"
                                  << resultMod << " Cell " << cell << ":" << cellmax << ":"
                                  << (cell >= 0 && cell <= cellmax) << ":" << maxCells(reco);
#endif
  return result;
}

isValidHex8() [1/2]

bool HGCalDDDConstants::isValidHex8	(	int	lay,
		int	waferU,
		int	waferV,
		bool	fullAndPart
	)		const

Definition at line 620 of file HGCalDDDConstants.cc.

References fullAndPart_, hgpar_, nano_mu_digi_cff::layer, HGCalParameters::typesInLayers_, HGCalTypes::WaferCornerMin, waferIn_, HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalParameters::waferMaskMode_, HGCalTypes::WaferOut, and HGCalParameters::waferTypes_.

Referenced by HGCalTopology::addHGCSiliconId(), isValidHex8(), HGCalSD::setDetUnitId(), HGCalTopology::valid(), and HGCalTopology::validModule().

                                                                                         {
  // Check validity for a layer|wafer|cell of post-TDR version
  int indx = HGCalWaferIndex::waferIndex(layer, modU, modV);
  auto itr = hgpar_->typesInLayers_.find(indx);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::isValidHex8:WaferType " << layer << ":" << modU << ":" << modV
                                << ":" << indx << " Test " << (itr != hgpar_->typesInLayers_.end());
#endif
  if (itr == hgpar_->typesInLayers_.end()) {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                  << " in wadferIndex";
#endif
    return false;
  }

  if (fullAndPart_) {
    auto ktr = hgpar_->waferInfoMap_.find(indx);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::isValidHex8:WaferInfoMap " << layer << ":" << modU << ":"
                                  << modV << ":" << indx << " Test " << (ktr != hgpar_->waferInfoMap_.end());
#endif
    if (ktr == hgpar_->waferInfoMap_.end()) {
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                    << " in wadferInfoMap";
#endif
      return false;
    }
  } else {
    auto jtr = waferIn_.find(indx);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::isValidHex8:WaferIn " << jtr->first << ":" << jtr->second;
#endif
    if (!(jtr->second)) {
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                    << " in wadferIn";
#endif
      return false;
    }
  }

  if (fullAndPart || fullAndPart_) {
    auto ktr = hgpar_->waferTypes_.find(indx);
    if (ktr != hgpar_->waferTypes_.end()) {
      if (hgpar_->waferMaskMode_ > 0) {
        if (ktr->second.first == HGCalTypes::WaferOut) {
#ifdef EDM_ML_DEBUG
          edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                        << " due to WaferOut";
#endif
          return false;
        }
      } else {
        if (ktr->second.first < HGCalTypes::WaferCornerMin) {
#ifdef EDM_ML_DEBUG
          edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                        << " due to WaferCornerMin";
#endif
          return false;
        }
      }
    }
  }
  return true;
}

isValidHex8() [2/2]

bool HGCalDDDConstants::isValidHex8	(	int	lay,
		int	modU,
		int	modV,
		int	cellU,
		int	cellV,
		bool	fullAndPart
	)		const

Definition at line 688 of file HGCalDDDConstants.cc.

References hgpar_, isValidCell8(), isValidHex8(), nano_mu_digi_cff::layer, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::typesInLayers_, HGCalTypes::WaferHD120, HGCalTypes::WaferHD200, HGCalWaferIndex::waferIndex(), and HGCalParameters::waferTypeL_.

                                                                                                               {
  // First check validity for a layer|wafer| of post TDR version
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: layer|wafer " << layer << ":" << modU << ":" << modV << ":"
                                << fullAndPart << " Valid " << isValidHex8(layer, modU, modV, fullAndPart);
#endif
  if (!isValidHex8(layer, modU, modV, fullAndPart))
    return false;
  int indx = HGCalWaferIndex::waferIndex(layer, modU, modV);
  auto itr = hgpar_->typesInLayers_.find(indx);
  int type = hgpar_->waferTypeL_[itr->second];
  int N = (((hgpar_->waferTypeL_[itr->second] == HGCalTypes::WaferHD120) ||
            (hgpar_->waferTypeL_[itr->second] == HGCalTypes::WaferHD200))
               ? hgpar_->nCellsFine_
               : hgpar_->nCellsCoarse_);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::isValidHex8:Cell " << cellU << ":" << cellV << ":" << N
                                << " Tests " << (cellU >= 0) << ":" << (cellU < 2 * N) << ":" << (cellV >= 0) << ":"
                                << (cellV < 2 * N) << ":" << ((cellV - cellU) < N) << ":" << ((cellU - cellV) <= N);
#endif
  if ((cellU < 0) || (cellU >= 2 * N) || (cellV < 0) || (cellV >= 2 * N)) {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot statisfy Cell 1 condition " << cellU << ":" << cellV
                                  << ":" << N;
#endif
    return false;
  }
  if (((cellV - cellU) >= N) || ((cellU - cellV) > N)) {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot statisfy Cell 2 condition " << cellU << ":" << cellV
                                  << ":" << N;
#endif
    return false;
  }
  return isValidCell8(layer, modU, modV, cellU, cellV, type);
}

isValidTrap()

bool HGCalDDDConstants::isValidTrap	(	int	zside,
		int	lay,
		int	ieta,
		int	iphi
	)		const

Definition at line 725 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, hcalRecHitTable_cff::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, nano_mu_digi_cff::layer, convertSQLiteXML::ok, HGCalParameters::scintCells(), tileExist(), trapezoidFile(), validateGeometry_cfg::valid, and ecaldqm::zside().

Referenced by HGCalTopology::addHGCSCintillatorId(), HGCScintSD::setDetUnitId(), and HGCalTopology::valid().

                                                                                  {
  // Check validity for a layer|eta|phi of scintillator
  const auto& indx = getIndex(layer, true);
  if (indx.first < 0)
    return false;
  bool ok = ((irad >= hgpar_->iradMinBH_[indx.first]) && (irad <= (hgpar_->iradMaxBH_[indx.first] + 1)) && (iphi > 0) &&
             (iphi <= hgpar_->scintCells(layer)));
  bool valid = ((ok && trapezoidFile()) ? tileExist(zside, layer, irad, iphi) : ok);
#ifdef EDM_ML_DEBUG
  bool tileEx = trapezoidFile() ? tileExist(zside, layer, irad, iphi) : true;
  edm::LogVerbatim("HGCalGeomT") << "HGCalDDDConstants::isValidityTrap: Input " << zside << ":" << layer << ":" << irad
                                 << ":" << iphi << " Range on Ring " << hgpar_->iradMinBH_[indx.first] << ":"
                                 << (hgpar_->iradMaxBH_[indx.first] + 1)
                                 << " Range on phi 0:" << hgpar_->scintCells(layer) << " tileExist " << tileEx
                                 << " Valid " << ok << ":" << valid;
#endif
  return valid;
}

lastLayer()

int HGCalDDDConstants::lastLayer

(

bool

reco

)

const

Definition at line 744 of file HGCalDDDConstants.cc.

References HGCalParameters::firstLayer_, hgpar_, and tot_layers_.

Referenced by HGCalGeometry::neighborZ(), HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_(), and tileCount().

                                                {
  return (hgpar_->firstLayer_ + tot_layers_[static_cast<int>(reco)] - 1);
}

layerFromIndex()

int HGCalDDDConstants::layerFromIndex ( int  index, bool  reco  ) const

private

Definition at line 2059 of file HGCalDDDConstants.cc.

References HGCalParameters::depthLayerF_, spr::find(), HGCalParameters::firstLayer_, hgpar_, HGCalParameters::layerIndex_, and waferHexagon6().

Referenced by waferIndex().

                                                                {
  int ll(-1);
  if (waferHexagon6() && reco) {
    ll = static_cast<int>(std::find(hgpar_->depthLayerF_.begin(), hgpar_->depthLayerF_.end(), index) -
                          hgpar_->depthLayerF_.begin());
    if (ll == static_cast<int>(hgpar_->depthLayerF_.size()))
      ll = -1;
  } else {
    ll = static_cast<int>(std::find(hgpar_->layerIndex_.begin(), hgpar_->layerIndex_.end(), index) -
                          hgpar_->layerIndex_.begin());
    if (ll == static_cast<int>(hgpar_->layerIndex_.size()))
      ll = -1;
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "LayerFromIndex for " << index << ":" << reco << ":" << waferHexagon6() << " is"
                                << ll << ":" << (ll + hgpar_->firstLayer_);
#endif
  return ((ll < 0) ? ll : (ll + hgpar_->firstLayer_));
}

layerIndex()

int HGCalDDDConstants::layerIndex	(	int	lay,
		bool	reco
	)		const

Definition at line 750 of file HGCalDDDConstants.cc.

References HGCalParameters::depthIndex_, HGCalParameters::depthLayerF_, HGCalParameters::firstLayer_, hgpar_, HGCalParameters::layerIndex_, and waferHexagon6().

Referenced by distFromEdgeHex(), distFromEdgeTrap(), getIndex(), getLayer(), getRangeR(), getREtaRange(), and HGCalGeometry::getSummary().

                                                          {
  int ll = lay - hgpar_->firstLayer_;
  if (ll < 0 || ll >= static_cast<int>(hgpar_->layerIndex_.size()))
    return -1;
  if (waferHexagon6()) {
    if (reco && ll >= static_cast<int>(hgpar_->depthIndex_.size()))
      return -1;
    return (reco ? hgpar_->depthLayerF_[ll] : hgpar_->layerIndex_[ll]);
  } else {
    return (hgpar_->layerIndex_[ll]);
  }
}

layers()

unsigned int HGCalDDDConstants::layers

(

bool

reco

)

const

Definition at line 748 of file HGCalDDDConstants.cc.

References dt_dqm_sourceclient_common_cff::reco, and tot_layers_.

Referenced by HGCalTB23Analyzer::analyze(), HGCalDigiClient::beginRun(), HGCalRecHitsClient::beginRun(), HGCalSimHitsClient::beginRun(), SimG4HGCalValidation::beginRun(), HGCalTB23Analyzer::beginRun(), HGCalDigiValidation::dqmBeginRun(), HGCalRecHitValidation::dqmBeginRun(), HGCalSimHitValidation::dqmBeginRun(), HGCalDDDConstants(), HGCalTopology::HGCalTopology(), HGCalTriggerGeometryV9Imp2::initialize(), HGCalTriggerGeometryV9Imp3::initialize(), isValidHex(), maxCells(), HGCalTriggerTools::setGeometry(), and wafers().

{ return tot_layers_[static_cast<int>(reco)]; }

layersInit()

unsigned int HGCalDDDConstants::layersInit

(

bool

reco

)

const

Definition at line 763 of file HGCalDDDConstants.cc.

References HGCalParameters::depthIndex_, hgpar_, and HGCalParameters::layerIndex_.

Referenced by HGCalDDDConstants().

                                                          {
  return (reco ? hgpar_->depthIndex_.size() : hgpar_->layerIndex_.size());
}

layerType()

int HGCalDDDConstants::layerType ( int  lay ) const

inline

Definition at line 111 of file HGCalDDDConstants.h.

References HGCalParameters::firstLayer_, hgpar_, HGCalParameters::layerType_, and HGCalTypes::WaferCenter.

Referenced by HGCalMouseBiteTester::analyze(), HGCalSD::calibCell(), HGCalCalibrationCell::findCell(), locateCell(), HGCalSD::setDetUnitId(), and waferFromPosition().

                                      {
    return ((hgpar_->layerType_.empty()) ? HGCalTypes::WaferCenter : hgpar_->layerType_[lay - hgpar_->firstLayer_]);
  }

levelTop()

int HGCalDDDConstants::levelTop ( int  ind = 0 ) const

inline

Definition at line 132 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::levelT_.

Referenced by SimG4HGCalValidation::beginRun(), HGCScintSD::update(), HFNoseSD::update(), and HGCalSD::update().

{ return hgpar_->levelT_[ind]; }

localToGlobal8()

std::pair< float, float > HGCalDDDConstants::localToGlobal8	(	int	zside,
		int	lay,
		int	waferU,
		int	waferV,
		double	localX,
		double	localY,
		bool	reco,
		bool	debug
	)		const

Definition at line 767 of file HGCalDDDConstants.cc.

References cassetteMode(), debug, HGCalParameters::firstLayer_, HGCalCassette::getShift(), getXY(), hgcassette_, hgpar_, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), HGCalParameters::k_ScaleToDDD, HGCalParameters::layerType_, HGCalTypes::WaferCenterR, HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, waferPositionNoRot(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), x, geometryCSVtoXML::xy, y, and ecaldqm::zside().

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

                                                                                                           {
  double x(localX), y(localY);
  bool rotx =
      ((!hgpar_->layerType_.empty()) && (hgpar_->layerType_[lay - hgpar_->firstLayer_] == HGCalTypes::WaferCenterR));
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "LocalToGlobal8 " << lay << ":" << (lay - hgpar_->firstLayer_) << ":" << rotx
                                  << " Local (" << x << ":" << y << ") Reco " << reco;
  if (!reco) {
    x *= HGCalParameters::k_ScaleToDDD;
    y *= HGCalParameters::k_ScaleToDDD;
  }
  const auto& xy = waferPositionNoRot(lay, waferU, waferV, reco, debug);
  x += xy.first;
  y += xy.second;
  int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
  auto ktr = hgpar_->waferInfoMap_.find(indx);
  if (cassetteMode() && (ktr != hgpar_->waferInfoMap_.end())) {
    auto cshift = hgcassette_.getShift(lay, -1, (ktr->second).cassette);
    std::ostringstream st1;
    if (debug)
      st1 << "Cassette " << (ktr->second).cassette << " Shift " << cshift.first << ":" << cshift.second << " Original "
          << x << ":" << y;
    if (!reco) {
      x -= ((HGCalParameters::k_ScaleToDDD)*zside * cshift.first);
      y += ((HGCalParameters::k_ScaleToDDD)*cshift.second);
    } else {
      x -= (zside * cshift.first);
      y += cshift.second;
    }
    if (debug) {
      st1 << " Final " << x << ":" << y;
      edm::LogVerbatim("HGCalGeom") << st1.str();
    }
  }
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "With wafer " << x << ":" << y << " by adding " << xy.first << ":" << xy.second;
  return (rotx ? getXY(lay, x, y, false) : std::make_pair(x, y));
}

locateCell() [1/4]

std::pair< float, float > HGCalDDDConstants::locateCell	(	int	cell,
		int	lay,
		int	type,
		bool	reco
	)		const

Definition at line 807 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, getIndex(), HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, mps_fire::i, HGCalParameters::k_ScaleToDDD, waferHexagon6(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, x, and y.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTB23Analyzer::analyzeSimHits(), cellInLayer(), HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), HGCalGeometry::get8Corners(), HGCalGeometry::getCorners(), HGCalGeometry::getNewCorners(), HGCalGeometry::getPosition(), locateCell(), HGCScintSD::setDetUnitId(), and HGCalSD::setDetUnitId().

                                                                                                {
  // type refers to wafer # for hexagon cell
  float x(999999.), y(999999.);
  const auto& index = getIndex(lay, reco);
  int i = index.first;
  if (i < 0)
    return std::make_pair(x, y);
  if (waferHexagon6()) {
    x = hgpar_->waferPosX_[type];
    y = hgpar_->waferPosY_[type];
#ifdef EDM_ML_DEBUG
    float x0(x), y0(y);
#endif
    if ((hgpar_->waferTypeT_[type] - 1 == HGCSiliconDetId::HGCalHD120) ||
        (hgpar_->waferTypeT_[type] - 1 == HGCSiliconDetId::HGCalHD200)) {
      x += hgpar_->cellFineX_[cell];
      y += hgpar_->cellFineY_[cell];
    } else {
      x += hgpar_->cellCoarseX_[cell];
      y += hgpar_->cellCoarseY_[cell];
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "LocateCell (Wafer) " << x0 << ":" << y0 << " Final " << x << ":" << y;
#endif
    if (!reco) {
      x *= HGCalParameters::k_ScaleToDDD;
      y *= HGCalParameters::k_ScaleToDDD;
    }
  }
  return std::make_pair(x, y);
}

locateCell() [2/4]

std::pair< float, float > HGCalDDDConstants::locateCell	(	int	zside,
		int	lay,
		int	waferU,
		int	waferV,
		int	cellU,
		int	cellV,
		bool	reco,
		bool	all,
		bool	norot,
		bool	cog,
		bool	debug
	)		const

Definition at line 839 of file HGCalDDDConstants.cc.

References python.cmstools::all(), cassetteMode(), HGCalParameters::cellCoarseIndex_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineIndex_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellOffset_, HGCalCell::cellPlacementIndex(), HGCalCell::cellPlacementOld, debug, HGCalParameters::firstLayer_, HGCalCassette::getShift(), getXY(), HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgcassette_, hgcell_, hgpar_, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), HGCalParameters::k_ScaleToDDD, HGCalTypes::layerFrontBack(), layerType(), hgcalPerformanceValidation::orient, partialWaferType(), HGCalParameters::typesInLayers_, HGCalTypes::WaferCenterR, waferHexagon8File(), waferHexagon8Fine(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, waferPositionNoRot(), HGCalParameters::waferTypeL_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), x, geometryCSVtoXML::xy, and y.

                                                                        {
  double x(0), y(0);
  int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
  auto itr = hgpar_->typesInLayers_.find(indx);
  int type = ((itr == hgpar_->typesInLayers_.end()) ? 2 : hgpar_->waferTypeL_[itr->second]);
  int layertype = layerType(lay);
  bool rotx = (norot) ? false : (layertype == HGCalTypes::WaferCenterR);
  if (debug) {
    edm::LogVerbatim("HGCalGeom") << "LocateCell " << lay << ":" << (lay - hgpar_->firstLayer_) << ":" << layertype
                                  << ":" << rotx << ":" << waferU << ":" << waferV << ":" << indx << ":"
                                  << (itr == hgpar_->typesInLayers_.end()) << ":" << type << " Flags " << reco << ":"
                                  << all;
  }
  auto ktr = hgpar_->waferInfoMap_.end();
  int place(HGCalCell::cellPlacementOld);
  if (waferHexagon8File()) {
    if (cassetteMode()) {
      ktr = hgpar_->waferInfoMap_.find(indx);
      if (ktr != hgpar_->waferInfoMap_.end())
        place = HGCalCell::cellPlacementIndex(1, HGCalTypes::layerFrontBack(layertype), (ktr->second).orient);
    }
    int part = partialWaferType(lay, waferU, waferV);
    auto xy = (waferHexagon8Fine() || cog) ? cellOffset_->cellOffsetUV2XY1(cellU, cellV, place, type, part)
                                           : hgcell_->cellUV2XY2(cellU, cellV, place, type);
    x = xy.first;
    y = xy.second;
    if (debug)
      edm::LogVerbatim("HGCalGeom") << "Type " << type << " Place " << place << " Cell " << cellU << ":" << cellV
                                    << " Position " << x << ":" << y;
  } else {
    int kndx = cellV * 100 + cellU;
    if ((type == HGCSiliconDetId::HGCalHD120) || (type == HGCSiliconDetId::HGCalHD200)) {
      auto jtr = hgpar_->cellFineIndex_.find(kndx);
      if (jtr != hgpar_->cellFineIndex_.end()) {
        x = hgpar_->cellFineX_[jtr->second];
        y = hgpar_->cellFineY_[jtr->second];
      }
      if (debug)
        edm::LogVerbatim("HGCalGeom") << "Fine " << cellU << ":" << cellV << ":" << kndx << ":" << x << ":" << y << ":"
                                      << (jtr != hgpar_->cellFineIndex_.end());
    } else {
      auto jtr = hgpar_->cellCoarseIndex_.find(kndx);
      if (jtr != hgpar_->cellCoarseIndex_.end()) {
        x = hgpar_->cellCoarseX_[jtr->second];
        y = hgpar_->cellCoarseY_[jtr->second];
      }
      if (debug)
        edm::LogVerbatim("HGCalGeom") << "Coarse " << cellU << ":" << cellV << ":" << kndx << ":" << x << ":" << y
                                      << ":" << (jtr != hgpar_->cellCoarseIndex_.end());
    }
  }
  if (!reco) {
    x *= HGCalParameters::k_ScaleToDDD;
    y *= HGCalParameters::k_ScaleToDDD;
  }
  if (all) {
    const auto& xy = waferPositionNoRot(lay, waferU, waferV, reco, debug);
    x += xy.first;
    y += xy.second;
    if (cassetteMode() && (ktr != hgpar_->waferInfoMap_.end())) {
      auto cshift = hgcassette_.getShift(lay, -1, (ktr->second).cassette);
      std::ostringstream st1;
      if (debug)
        st1 << "Cassette " << (ktr->second).cassette << " Shift " << cshift.first << ":" << cshift.second
            << " Original " << x << ":" << y;
      if (!reco) {
        x -= ((HGCalParameters::k_ScaleToDDD)*cshift.first);
        y += ((HGCalParameters::k_ScaleToDDD)*cshift.second);
      } else {
        x -= cshift.first;
        y += cshift.second;
      }
      if (debug) {
        st1 << " Final " << x << ":" << y;
        edm::LogVerbatim("HGCalGeom") << st1.str();
      }
    }
    if (debug)
      edm::LogVerbatim("HGCalGeom") << "With wafer " << x << ":" << y << " by adding " << xy.first << ":" << xy.second;
  }
  return (rotx ? getXY(lay, x, y, false) : std::make_pair(x, y));
}

locateCell() [3/4]

std::pair< float, float > HGCalDDDConstants::locateCell	(	const HGCSiliconDetId &	id,
		bool	cog,
		bool	debug
	)		const

Definition at line 932 of file HGCalDDDConstants.cc.

References debug, nano_mu_digi_cff::layer, locateCell(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), and ecaldqm::zside().

                                                                                                         {
  return locateCell(
      id.zside(), id.layer(), id.waferU(), id.waferV(), id.cellU(), id.cellV(), true, true, false, cog, debug);
}

locateCell() [4/4]

std::pair< float, float > HGCalDDDConstants::locateCell	(	const HGCScintillatorDetId &	id,
		bool	debug
	)		const

Definition at line 937 of file HGCalDDDConstants.cc.

References debug, hcalRecHitTable_cff::iphi, nano_mu_digi_cff::layer, locateCellTrap(), and ecaldqm::zside().

                                                                                                    {
  return locateCellTrap(id.zside(), id.layer(), id.iradius(), id.iphi(), true, debug);
}

locateCellHex()

std::pair< float, float > HGCalDDDConstants::locateCellHex	(	int	cell,
		int	wafer,
		bool	reco
	)		const

Definition at line 941 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::waferTypeT_, x, and y.

Referenced by HGCalGeometry::get8Corners(), HGCalGeometry::getCorners(), HGCalGeometry::getNewCorners(), and HGCalGeometry::getPosition().

                                                                                           {
  float x(0), y(0);
  if ((hgpar_->waferTypeT_[wafer] - 1 == HGCSiliconDetId::HGCalHD120) ||
      (hgpar_->waferTypeT_[wafer] - 1 == HGCSiliconDetId::HGCalHD200)) {
    x = hgpar_->cellFineX_[cell];
    y = hgpar_->cellFineY_[cell];
  } else {
    x = hgpar_->cellCoarseX_[cell];
    y = hgpar_->cellCoarseY_[cell];
  }
  if (!reco) {
    x *= HGCalParameters::k_ScaleToDDD;
    y *= HGCalParameters::k_ScaleToDDD;
  }
  return std::make_pair(x, y);
}

locateCellTrap()

std::pair< float, float > HGCalDDDConstants::locateCellTrap	(	int	zside,
		int	lay,
		int	ieta,
		int	iphi,
		bool	reco,
		bool	debug
	)		const

Definition at line 958 of file HGCalDDDConstants.cc.

References funct::abs(), cassetteMode(), HGCalParameters::cassettes_, angle_units::operators::convertRadToDeg(), funct::cos(), debug, HGCalParameters::firstLayer_, getIndex(), HGCalCassette::getShift(), hgcassette_, hgpar_, hcalRecHitTable_cff::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleToDDD, SiStripPI::max, SiStripPI::min, HGCalParameters::nphiCassette_, phi, HGCalParameters::phiOffset_, alignCSCRings::r, HGCalParameters::radiusLayer_, FastTimerService_cff::range, rangeR(), HGCalParameters::scintType(), funct::sin(), HGCalTileIndex::tileCassette(), trapezoidFile(), x, HGCalParameters::xLayerHex_, y, HGCalParameters::yLayerHex_, z, and HGCalParameters::zLayerHex_.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalNumberingScheme::checkPosition(), and locateCell().

                                                                         {
  float x(0), y(0);
  const auto& indx = getIndex(lay, reco);
  if (indx.first >= 0) {
    int ir = std::abs(irad);
    int type = hgpar_->scintType(lay);
    double phi = (iphi - 0.5) * indx.second;
    double z = hgpar_->zLayerHex_[indx.first];
    double r = 0.5 * (hgpar_->radiusLayer_[type][ir - 1] + hgpar_->radiusLayer_[type][ir]);
    std::pair<double, double> range = rangeR(z, true);
    if (debug)
      edm::LogVerbatim("HGCalGeom") << "locateCellTrap:: Input " << lay << ":" << irad << ":" << iphi << ":" << reco
                                    << " IR " << ir << ":" << hgpar_->iradMinBH_[indx.first] << ":"
                                    << hgpar_->iradMaxBH_[indx.first] << " Type " << type << " Z " << indx.first << ":"
                                    << z << " phi " << phi << ":" << convertRadToDeg(phi) << " R " << r << ":"
                                    << range.first << ":" << range.second;
    if (!trapezoidFile())
      r = std::max(range.first, std::min(r, range.second));
    x = r * std::cos(phi);
    y = r * std::sin(phi);
    int ll = lay - hgpar_->firstLayer_;
    x += hgpar_->xLayerHex_[ll];
    y += hgpar_->yLayerHex_[ll];
    if (irad < 0)
      x = -x;
    if (cassetteMode()) {
      int cassette = HGCalTileIndex::tileCassette(iphi, hgpar_->phiOffset_, hgpar_->nphiCassette_, hgpar_->cassettes_);
      auto cshift = hgcassette_.getShift(lay, -1, cassette);
      std::ostringstream st1;
      if (debug)
        st1 << "Cassette " << cassette << " Shift " << cshift.first << ":" << cshift.second << " Original " << x << ":"
            << y;
      x -= cshift.first;
      y += cshift.second;
      if (debug) {
        st1 << " Final " << x << ":" << y;
        edm::LogVerbatim("HGCalGeom") << st1.str();
      }
    }
  }
  if (!reco) {
    x *= HGCalParameters::k_ScaleToDDD;
    y *= HGCalParameters::k_ScaleToDDD;
  }
  return std::make_pair(x, y);
}

maskCell()

bool HGCalDDDConstants::maskCell	(	const DetId &	id,
		int	corners
	)		const

Definition at line 1006 of file HGCalDDDConstants.cc.

References cassetteMode(), hcalRecHitTable_cff::detId, DetId::Forward, getUVMax(), HGCalWaferMask::goodCell(), hgpar_, l1ctLayer2EG_cff::id, HGCalParameters::k_CornerSize, HGCalTypes::k_OffsetRotation, nano_mu_digi_cff::layer, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, HGCalWaferMask::maskCell(), N, edm::second(), findQualityFiles::v, HGCalTypes::WaferFull, waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalParameters::waferTypes_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), and LaserClient_cfi::wl.

Referenced by hgcal::RecHitTools::maskCell(), HGCalTopology::maskCell(), HFNoseSD::setDetUnitId(), HGCalSD::setDetUnitId(), and HGCalTopology::valid().

                                                                      {
  bool mask(false);
  if (corners > 2 && corners <= static_cast<int>(HGCalParameters::k_CornerSize)) {
    if (waferHexagon8()) {
      int N(0), layer(0), waferU(0), waferV(0), u(0), v(0);
      if (detId.det() == DetId::Forward) {
        HFNoseDetId id(detId);
        N = getUVMax(id.type());
        layer = id.layer();
        waferU = id.waferU();
        waferV = id.waferV();
        u = id.cellU();
        v = id.cellV();
      } else {
        HGCSiliconDetId id(detId);
        N = getUVMax(id.type());
        layer = id.layer();
        waferU = id.waferU();
        waferV = id.waferV();
        u = id.cellU();
        v = id.cellV();
      }
      int wl = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
      auto itr = hgpar_->waferTypes_.find(wl);
      auto ktr = hgpar_->waferInfoMap_.find(wl);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "MaskCell: Layer " << layer << " Wafer " << waferU << ":" << waferV << " Index "
                                    << wl << ":" << (itr != hgpar_->waferTypes_.end()) << ":"
                                    << (ktr != hgpar_->waferInfoMap_.end());
#endif
      if (cassetteMode()) {
        int part = (ktr != hgpar_->waferInfoMap_.end()) ? (ktr->second).part : HGCalTypes::WaferFull;
        mask = !(HGCalWaferMask::goodCell(u, v, part));
      } else if (itr != hgpar_->waferTypes_.end()) {
        if ((itr->second).second <= HGCalTypes::k_OffsetRotation)
          mask = HGCalWaferMask::maskCell(u, v, N, (itr->second).first, (itr->second).second, corners);
        else
          mask = !(HGCalWaferMask::goodCell(
              u, v, N, (itr->second).first, ((itr->second).second - HGCalTypes::k_OffsetRotation)));
      }
    }
  }
  return mask;
}

maxCells() [1/2]

int HGCalDDDConstants::maxCells

(

bool

reco

)

const

Definition at line 1051 of file HGCalDDDConstants.cc.

References hgcalTBTopologyTester_cfi::cells, HGCalParameters::depth_, hgpar_, mps_fire::i, HGCalParameters::layer_, and layers().

Referenced by HGCalDDDConstants(), HGCalTopology::HGCalTopology(), and isValidHex().

                                               {
  int cells(0);
  for (unsigned int i = 0; i < layers(reco); ++i) {
    int lay = reco ? hgpar_->depth_[i] : hgpar_->layer_[i];
    if (cells < maxCells(lay, reco))
      cells = maxCells(lay, reco);
  }
  return cells;
}

maxCells() [2/2]

int HGCalDDDConstants::maxCells	(	int	lay,
		bool	reco
	)		const

Definition at line 1061 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, hgcalTBTopologyTester_cfi::cells, HGCalParameters::defineFull_, HGCalParameters::firstLayer_, getIndex(), HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, HGCSiliconDetId::HGCalLD300, hgpar_, dqmdumpme::k, SiStripPI::max, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::scintCells(), tileTrapezoid(), HGCalParameters::typesInLayers_, HGCalParameters::waferCopy_, waferHexagon6(), waferHexagon8(), HGCalWaferIndex::waferIndex(), waferInLayerTest(), HGCalParameters::waferTypeL_, HGCalParameters::waferTypeT_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

                                                        {
  const auto& index = getIndex(lay, reco);
  if (index.first < 0)
    return 0;
  if (waferHexagon6()) {
    unsigned int cells(0);
    for (unsigned int k = 0; k < hgpar_->waferTypeT_.size(); ++k) {
      if (waferInLayerTest(k, index.first, hgpar_->defineFull_)) {
        unsigned int cell = (((hgpar_->waferTypeT_[k] - 1) == HGCSiliconDetId::HGCalHD120) ||
                             ((hgpar_->waferTypeT_[k] - 1) == HGCSiliconDetId::HGCalHD200))
                                ? (hgpar_->cellFineX_.size())
                                : (hgpar_->cellCoarseX_.size());
        if (cell > cells)
          cells = cell;
      }
    }
    return static_cast<int>(cells);
  } else if (waferHexagon8()) {
    int cells(0);
    for (unsigned int k = 0; k < hgpar_->waferCopy_.size(); ++k) {
      if (waferInLayerTest(k, index.first, hgpar_->defineFull_)) {
        auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(
            lay, HGCalWaferIndex::waferU(hgpar_->waferCopy_[k]), HGCalWaferIndex::waferV(hgpar_->waferCopy_[k])));
        int type =
            ((itr == hgpar_->typesInLayers_.end()) ? HGCSiliconDetId::HGCalLD300 : hgpar_->waferTypeL_[itr->second]);
        int N = ((type == HGCSiliconDetId::HGCalHD120) || (type == HGCSiliconDetId::HGCalHD200))
                    ? hgpar_->nCellsFine_
                    : hgpar_->nCellsCoarse_;
        cells = std::max(cells, 3 * N * N);
      }
    }
    return cells;
  } else if (tileTrapezoid()) {
    return hgpar_->scintCells(index.first + hgpar_->firstLayer_);
  } else {
    return 0;
  }
}

maxCellUV()

int HGCalDDDConstants::maxCellUV ( ) const

inline

Definition at line 134 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::nCellsFine_, and tileTrapezoid().

Referenced by HGCalTopology::HGCalTopology().

{ return (tileTrapezoid() ? hgpar_->nCellsFine_ : 2 * hgpar_->nCellsFine_); }

maxModules()

int HGCalDDDConstants::maxModules ( ) const

inline

Definition at line 137 of file HGCalDDDConstants.h.

References modHalf_.

{ return modHalf_; }

maxModulesPerLayer()

int HGCalDDDConstants::maxModulesPerLayer ( ) const

inline

Definition at line 138 of file HGCalDDDConstants.h.

References maxWafersPerLayer_.

{ return maxWafersPerLayer_; }

maxRows()

int HGCalDDDConstants::maxRows	(	int	lay,
		bool	reco
	)		const

Definition at line 1100 of file HGCalDDDConstants.cc.

References HGCalParameters::defineFull_, getIndex(), hgpar_, mps_fire::i, dqmdumpme::k, HGCalParameters::waferCopy_, waferHexagon6(), waferHexagon8(), waferInLayerTest(), and HGCalParameters::waferUVMaxLayer_.

                                                       {
  int kymax(0);
  const auto& index = getIndex(lay, reco);
  int i = index.first;
  if (i < 0)
    return kymax;
  if (waferHexagon6()) {
    for (unsigned int k = 0; k < hgpar_->waferCopy_.size(); ++k) {
      if (waferInLayerTest(k, i, hgpar_->defineFull_)) {
        int ky = ((hgpar_->waferCopy_[k]) / 100) % 100;
        if (ky > kymax)
          kymax = ky;
      }
    }
  } else if (waferHexagon8()) {
    kymax = 1 + 2 * hgpar_->waferUVMaxLayer_[index.first];
  }
  return kymax;
}

minSlope()

double HGCalDDDConstants::minSlope ( ) const

inline

Definition at line 140 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::slopeMin_.

Referenced by HGCScintSD::update(), HFNoseSD::update(), and HGCalSD::update().

{ return hgpar_->slopeMin_[0]; }

modifyUV()

int HGCalDDDConstants::modifyUV	(	int	uv,
		int	type1,
		int	type2
	)		const

Definition at line 1120 of file HGCalDDDConstants.cc.

References HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, HGCSiliconDetId::HGCalLD200, and HGCSiliconDetId::HGCalLD300.

Referenced by HGCalTopology::neighbors().

                                                                  {
  // Modify u/v for transition of type1 to type2
  int uvx(uv);
  if (type1 != type2) {
    if ((type1 == HGCSiliconDetId::HGCalHD120) || (type1 == HGCSiliconDetId::HGCalHD200)) {
      if ((type2 == HGCSiliconDetId::HGCalLD200) || (type2 == HGCSiliconDetId::HGCalLD300))
        uvx = (2 * uv + 1) / 3;
    } else {
      if ((type2 == HGCSiliconDetId::HGCalHD120) || (type2 == HGCSiliconDetId::HGCalHD200))
        uvx = (3 * uv) / 2;
    }
  }
  return uvx;
}

modules()

int HGCalDDDConstants::modules	(	int	lay,
		bool	reco
	)		const

Definition at line 1135 of file HGCalDDDConstants.cc.

References dqmdumpme::first, getIndex(), max_modules_layer_, and dt_dqm_sourceclient_common_cff::reco.

Referenced by wafers().

                                                       {
  if (getIndex(lay, reco).first < 0)
    return 0;
  else
    return max_modules_layer_[static_cast<int>(reco)][lay];
}

modulesInit()

int HGCalDDDConstants::modulesInit	(	int	lay,
		bool	reco
	)		const

Definition at line 1142 of file HGCalDDDConstants.cc.

References HGCalParameters::defineFull_, HGCalParameters::firstModule_, getIndex(), hgpar_, dqmdumpme::k, HGCalParameters::lastModule_, tileTrapezoid(), waferInLayerTest(), and HGCalParameters::waferPosX_.

Referenced by HGCalDDDConstants().

                                                           {
  int nmod(0);
  const auto& index = getIndex(lay, reco);
  if (index.first < 0)
    return nmod;
  if (!tileTrapezoid()) {
    for (unsigned int k = 0; k < hgpar_->waferPosX_.size(); ++k) {
      if (waferInLayerTest(k, index.first, hgpar_->defineFull_))
        ++nmod;
    }
  } else {
    nmod = 1 + hgpar_->lastModule_[index.first] - hgpar_->firstModule_[index.first];
  }
  return nmod;
}

mouseBite()

double HGCalDDDConstants::mouseBite

(

bool

reco

)

const

Definition at line 1158 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::k_ScaleToDDD, and HGCalParameters::mouseBite_.

Referenced by HFNoseSD::update(), and HGCalSD::update().

                                                   {
  return (reco ? hgpar_->mouseBite_ : HGCalParameters::k_ScaleToDDD * hgpar_->mouseBite_);
}

numberCells() [1/2]

int HGCalDDDConstants::numberCells

(

bool

reco

)

const

Definition at line 1162 of file HGCalDDDConstants.cc.

References hgcalTBTopologyTester_cfi::cells, HGCalParameters::depth_, hgpar_, dqmdumpme::k, HGCalParameters::layer_, dt_dqm_sourceclient_common_cff::reco, HGCalGeomParameters::scintillatorCassette, HGCalGeomParameters::scintillatorFile, tileCount(), tileTrapezoid(), and HGCalParameters::waferMaskMode_.

Referenced by HGCalTopology::allGeomModules().

                                                  {
  int cells = (tileTrapezoid() && ((hgpar_->waferMaskMode_ == HGCalGeomParameters::scintillatorFile) ||
                                   (hgpar_->waferMaskMode_ == HGCalGeomParameters::scintillatorCassette)))
                  ? tileCount(0, -1)
                  : 0;
  if (cells == 0) {
    unsigned int nlayer = (reco) ? hgpar_->depth_.size() : hgpar_->layer_.size();
    for (unsigned k = 0; k < nlayer; ++k) {
      std::vector<int> ncells = numberCells(((reco) ? hgpar_->depth_[k] : hgpar_->layer_[k]), reco);
      cells = std::accumulate(ncells.begin(), ncells.end(), cells);
    }
  }
  return cells;
}

numberCells() [2/2]

std::vector< int > HGCalDDDConstants::numberCells	(	int	lay,
		bool	reco
	)		const

Definition at line 1177 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::defineFull_, HGCalParameters::firstModule_, getIndex(), HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, mps_fire::i, dqmdumpme::k, nphi, numberCellsHexagon(), HGCalParameters::scintCells(), tileTrapezoid(), HGCalParameters::waferCopy_, waferHexagon6(), waferInLayerTest(), HGCalParameters::waferTypeT_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

                                                                      {
  const auto& index = getIndex(lay, reco);
  int i = index.first;
  std::vector<int> ncell;
  if (i >= 0) {
    if (waferHexagon6()) {
      for (unsigned int k = 0; k < hgpar_->waferTypeT_.size(); ++k) {
        if (waferInLayerTest(k, i, hgpar_->defineFull_)) {
          unsigned int cell = (((hgpar_->waferTypeT_[k] - 1) == HGCSiliconDetId::HGCalHD120) ||
                               ((hgpar_->waferTypeT_[k] - 1) == HGCSiliconDetId::HGCalHD200))
                                  ? (hgpar_->cellFineX_.size())
                                  : (hgpar_->cellCoarseX_.size());
          ncell.emplace_back(static_cast<int>(cell));
        }
      }
    } else if (tileTrapezoid()) {
      int nphi = hgpar_->scintCells(lay);
      for (int k = hgpar_->firstModule_[i]; k <= hgpar_->lastModule_[i]; ++k)
        ncell.emplace_back(nphi);
    } else {
      for (unsigned int k = 0; k < hgpar_->waferCopy_.size(); ++k) {
        if (waferInLayerTest(k, index.first, hgpar_->defineFull_)) {
          int cell = numberCellsHexagon(lay,
                                        HGCalWaferIndex::waferU(hgpar_->waferCopy_[k]),
                                        HGCalWaferIndex::waferV(hgpar_->waferCopy_[k]),
                                        true);
          ncell.emplace_back(cell);
        }
      }
    }
  }
  return ncell;
}

numberCellsHexagon() [1/2]

int HGCalDDDConstants::numberCellsHexagon

(

int

wafer

)

const

Definition at line 1211 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, and HGCalParameters::waferTypeT_.

Referenced by HGCalGeometry::newCell(), numberCells(), and HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

                                                         {
  if (wafer >= 0 && wafer < static_cast<int>(hgpar_->waferTypeT_.size())) {
    if (((hgpar_->waferTypeT_[wafer] - 1) == HGCSiliconDetId::HGCalHD120) ||
        ((hgpar_->waferTypeT_[wafer] - 1) == HGCSiliconDetId::HGCalHD200))
      return static_cast<int>(hgpar_->cellFineX_.size());
    else
      return static_cast<int>(hgpar_->cellCoarseX_.size());
  } else {
    return 0;
  }
}

numberCellsHexagon() [2/2]

int HGCalDDDConstants::numberCellsHexagon	(	int	lay,
		int	waferU,
		int	waferV,
		bool	flag
	)		const

Definition at line 1223 of file HGCalDDDConstants.cc.

References RemoveAddSevLevel::flag, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, HGCSiliconDetId::HGCalLD300, hgpar_, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::typesInLayers_, HGCalWaferIndex::waferIndex(), HGCalParameters::waferTypeL_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

                                                                                          {
  auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(lay, waferU, waferV));
  int type = ((itr == hgpar_->typesInLayers_.end()) ? HGCSiliconDetId::HGCalLD300 : hgpar_->waferTypeL_[itr->second]);
  int N = ((type == HGCSiliconDetId::HGCalHD120) || (type == HGCSiliconDetId::HGCalHD200)) ? hgpar_->nCellsFine_
                                                                                           : hgpar_->nCellsCoarse_;
  if (flag)
    return (3 * N * N);
  else
    return N;
}

partialWaferType()

int HGCalDDDConstants::partialWaferType ( int  lay, int  waferU, int  waferV  ) const

inline

Definition at line 149 of file HGCalDDDConstants.h.

References hgpar_, HGCalTypes::WaferFull, HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

Referenced by locateCell().

                                                                     {
    int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
    auto ktr = hgpar_->waferInfoMap_.find(indx);
    int part = (ktr != hgpar_->waferInfoMap_.end()) ? (ktr->second).part : HGCalTypes::WaferFull;
    return part;
  }

rangeR()

std::pair< double, double > HGCalDDDConstants::rangeR	(	double	z,
		bool	reco
	)		const

Definition at line 1234 of file HGCalDDDConstants.cc.

References funct::abs(), HGCalParameters::detectorType_, HGCalParameters::firstLayer_, HGCalParameters::firstMixedLayer_, hgpar_, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, HGCalGeomTools::radius(), HGCalParameters::radiusMixBoundary_, HGCalParameters::rMaxFront_, HGCalParameters::rMinFront_, HGCalParameters::slopeMin_, HGCalParameters::slopeTop_, z, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zLayerHex_, and geometryCSVtoXML::zz.

Referenced by ticl::SeedingRegionByTracks::buildFirstLayers(), ticl::GeneralInterpretationAlgo::buildLayers(), ticl::LinkingAlgoByDirectionGeometric::buildLayers(), ticl::TracksterLinkingbySkeletons::buildLayers(), HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), HGCDigitizer::checkPosition(), DetectorTools::DetectorTools(), locateCellTrap(), HGCalGeometry::neighborZ(), and TICLCandidateProducer::produce().

                                                                           {
  double rmin(0), rmax(0), zz(0);
  if (hgpar_->detectorType_ > 0) {
    zz = (reco ? std::abs(z) : HGCalParameters::k_ScaleFromDDD * std::abs(z));
    if (hgpar_->detectorType_ <= 2) {
      rmin = HGCalGeomTools::radius(zz, hgpar_->zFrontMin_, hgpar_->rMinFront_, hgpar_->slopeMin_);
    } else {
      rmin = HGCalGeomTools::radius(
          zz, hgpar_->firstLayer_, hgpar_->firstMixedLayer_, hgpar_->zLayerHex_, hgpar_->radiusMixBoundary_);
    }
    if ((hgpar_->detectorType_ == 2) && (zz >= hgpar_->zLayerHex_[hgpar_->firstMixedLayer_ - 1])) {
      rmax = HGCalGeomTools::radius(
          zz, hgpar_->firstLayer_, hgpar_->firstMixedLayer_, hgpar_->zLayerHex_, hgpar_->radiusMixBoundary_);
    } else {
      rmax = HGCalGeomTools::radius(zz, hgpar_->zFrontTop_, hgpar_->rMaxFront_, hgpar_->slopeTop_);
    }
  }
  if (!reco) {
    rmin *= HGCalParameters::k_ScaleToDDD;
    rmax *= HGCalParameters::k_ScaleToDDD;
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:rangeR: " << z << ":" << zz << " R " << rmin << ":" << rmax;
#endif
  return std::make_pair(rmin, rmax);
}

rangeRLayer()

std::pair< double, double > HGCalDDDConstants::rangeRLayer	(	int	lay,
		bool	reco
	)		const

Definition at line 1261 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::rMaxLayHex_, and HGCalParameters::rMinLayHex_.

                                                                               {
  double rmin(0), rmax(0);
  const auto& index = getIndex(lay, reco);
  if (index.first >= 0 && index.first < static_cast<int>(hgpar_->rMinLayHex_.size())) {
    rmin = hgpar_->rMinLayHex_[index.first];
    rmax = hgpar_->rMaxLayHex_[index.first];
  }
  if (!reco) {
    rmin *= HGCalParameters::k_ScaleToDDD;
    rmax *= HGCalParameters::k_ScaleToDDD;
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:rangeR: " << lay << ":" << index.first << " R " << rmin << ":"
                                << rmax;
#endif
  return std::make_pair(rmin, rmax);
}

rangeZ()

std::pair< double, double > HGCalDDDConstants::rangeZ

(

bool

reco

)

const

Definition at line 1279 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::waferThick_, HGCalParameters::zLayerHex_, SiStripMonitorCluster_cfi::zmax, and SiStripMonitorCluster_cfi::zmin.

Referenced by HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), and HGCDigitizer::checkPosition().

                                                                 {
  double zmin = (hgpar_->zLayerHex_[0] - hgpar_->waferThick_);
  double zmax = (hgpar_->zLayerHex_[hgpar_->zLayerHex_.size() - 1] + hgpar_->waferThick_);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:rangeZ: " << zmin << ":" << zmax << ":" << hgpar_->waferThick_;
#endif
  if (!reco) {
    zmin *= HGCalParameters::k_ScaleToDDD;
    zmax *= HGCalParameters::k_ScaleToDDD;
  }
  return std::make_pair(zmin, zmax);
}

rowColumnWafer()

std::pair< int, int > HGCalDDDConstants::rowColumnWafer

(

const int

wafer

)

const

Definition at line 1292 of file HGCalDDDConstants.cc.

References cuy::col, filterCSVwithJSON::copy, HGCalTypes::getUnpackedU(), HGCalTypes::getUnpackedV(), hgpar_, and HGCalParameters::waferCopy_.

                                                                   {
  int row(0), col(0);
  if (wafer < static_cast<int>(hgpar_->waferCopy_.size())) {
    int copy = hgpar_->waferCopy_[wafer];
    col = HGCalTypes::getUnpackedU(copy);
    row = HGCalTypes::getUnpackedV(copy);
    ;
  }
  return std::make_pair(row, col);
}

sectors()

int HGCalDDDConstants::sectors ( ) const

inline

Definition at line 159 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::nSectors_.

Referenced by HGCalGeometry::getSummary(), HGCalDDDConstants(), and HGCalTopology::HGCalTopology().

{ return hgpar_->nSectors_; }

sensorSizeOffset()

double HGCalDDDConstants::sensorSizeOffset

(

bool

reco

)

const

Definition at line 1303 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::k_ScaleToDDD, and HGCalParameters::sensorSizeOffset_.

Referenced by HGCalSD::update().

                                                          {
  return (reco ? hgpar_->sensorSizeOffset_ : HGCalParameters::k_ScaleToDDD * hgpar_->sensorSizeOffset_);
}

simToReco()

std::pair< int, int > HGCalDDDConstants::simToReco	(	int	cell,
		int	layer,
		int	mod,
		bool	half
	)		const

Definition at line 1307 of file HGCalDDDConstants.cc.

References hcalRecHitTable_cff::depth, getIndex(), hgpar_, mps_fire::i, HGCalParameters::layerGroup_, HGCalParameters::layerGroupM_, HGCalParameters::layerGroupO_, mod(), findQualityFiles::size, waferHexagon6(), and HGCalParameters::waferTypeL_.

Referenced by HGCalTB23Analyzer::analyzeSimHits(), CaloParticleDebugger::fillSimHits(), and CaloTruthAccumulator::fillSimHits().

                                                                                          {
  if (!waferHexagon6()) {
    return std::make_pair(cell, lay);
  } else {
    const auto& index = getIndex(lay, false);
    int i = index.first;
    if (i < 0) {
      edm::LogWarning("HGCalGeom") << "Wrong Layer # " << lay << " not in the list ***** ERROR *****";
      return std::make_pair(-1, -1);
    }
    if (mod >= static_cast<int>(hgpar_->waferTypeL_.size())) {
      edm::LogWarning("HGCalGeom") << "Invalid Wafer # " << mod << "should be < " << (hgpar_->waferTypeL_).size()
                                   << " ***** ERROR *****";
      return std::make_pair(-1, -1);
    }
    int depth(-1);
    int kx = cell;
    int type = hgpar_->waferTypeL_[mod];
    if (type == 1) {
      depth = hgpar_->layerGroup_[i];
    } else if (type == 2) {
      depth = hgpar_->layerGroupM_[i];
    } else {
      depth = hgpar_->layerGroupO_[i];
    }
    return std::make_pair(kx, depth);
  }
}

tileCount()

int HGCalDDDConstants::tileCount	(	int	layer,
		int	ring
	)		const

Definition at line 1336 of file HGCalDDDConstants.cc.

References b, HGCalParameters::firstLayer_, hgpar_, dqmdumpme::k, lastLayer(), nano_mu_digi_cff::layer, relativeConstraints::ring, HGCalTileIndex::tileIndex(), HGCalParameters::tileInfoMap_, and HGCalParameters::tileRingRange_.

Referenced by numberCells().

                                                          {
  int laymin(layer), laymax(layer), ringmin(ring), ringmax(ring), kount(0);
  if (layer == 0) {
    laymin = hgpar_->firstLayer_;
    laymax = lastLayer(true);
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "tileCount: layer " << layer << " ring " << ring << " layerMin/Max " << laymin << ":"
                                << laymax;
#endif
  for (int lay = laymin; lay <= laymax; ++lay) {
    if (ring < 0) {
      int ll = lay - hgpar_->firstLayer_;
      ringmin = hgpar_->tileRingRange_[ll].first;
      ringmax = hgpar_->tileRingRange_[ll].second;
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "tileCount: lay " << lay << ":" << (lay - hgpar_->firstLayer_) << " rings "
                                  << ringmin << ":" << ringmax;
#endif
    for (int rin = ringmin; rin <= ringmax; ++rin) {
      int indx = HGCalTileIndex::tileIndex(lay, rin + 1, 0);
      auto itr = hgpar_->tileInfoMap_.find(indx);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "tileCount: rin  " << rin << " indx " << indx << " itr "
                                    << (itr != hgpar_->tileInfoMap_.end());
#endif
      if (itr != hgpar_->tileInfoMap_.end()) {
        for (int k = 0; k < 4; ++k) {
          std::bitset<24> b(itr->second.hex[k]);
          kount += b.count();
        }
      }
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "tileCount: lay|rin  " << lay << ":" << rin << " kount " << kount;
#endif
    }
  }
  return (3 * kount);
}

tileExist()

bool HGCalDDDConstants::tileExist	(	int	zside,
		int	layer,
		int	ring,
		int	phi
	)		const

Definition at line 1377 of file HGCalDDDConstants.cc.

References hgpar_, nano_mu_digi_cff::layer, convertSQLiteXML::ok, phi, relativeConstraints::ring, HGCalTileIndex::tileExist(), HGCalTileIndex::tileIndex(), HGCalParameters::tileInfoMap_, and ecaldqm::zside().

Referenced by assignCellTrap(), and isValidTrap().

                                                                               {
  int indx = HGCalTileIndex::tileIndex(layer, ring, 0);
  auto itr = hgpar_->tileInfoMap_.find(indx);
  bool ok = (itr == hgpar_->tileInfoMap_.end()) ? false : HGCalTileIndex::tileExist(itr->second.hex, zside, phi);
  return ok;
}

tileInfo()

HGCalParameters::tileInfo HGCalDDDConstants::tileInfo	(	int	zside,
		int	layer,
		int	ring
	)		const

Definition at line 1384 of file HGCalDDDConstants.cc.

References hgpar_, nano_mu_digi_cff::layer, relativeConstraints::ring, HGCalTileIndex::tileIndex(), and HGCalParameters::tileInfoMap_.

                                                                                        {
  int indx = HGCalTileIndex::tileIndex(layer, ring, 0);
  auto itr = hgpar_->tileInfoMap_.find(indx);
  return ((itr == hgpar_->tileInfoMap_.end()) ? HGCalParameters::tileInfo() : itr->second);
}

tilePhiEdge()

bool HGCalDDDConstants::tilePhiEdge	(	double	phi,
		int	layer,
		int	iphi
	)		const

Definition at line 1390 of file HGCalDDDConstants.cc.

References funct::abs(), cuy::dif1, cuy::dif2, hgpar_, hcalRecHitTable_cff::iphi, nano_mu_digi_cff::layer, phi, HGCalParameters::scintCellSize(), and tol_.

Referenced by assignCellTrap().

                                                                         {
  double dif1 = std::abs(phi - hgpar_->scintCellSize(layer) * (iphi - 1));
  double dif2 = std::abs(phi - hgpar_->scintCellSize(layer) * iphi);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeomT") << "HGCalDDDConstants::tilePhiEdge:: input: " << phi << ":" << layer << ":" << iphi
                                 << " Differences " << dif1 << ":" << dif2;
#endif
  return ((dif1 < tol_) || (dif2 < tol_));
}

tileRingEdge()

bool HGCalDDDConstants::tileRingEdge	(	double	rho,
		int	layer,
		int	ring
	)		const

Definition at line 1400 of file HGCalDDDConstants.cc.

References funct::abs(), cuy::dif1, cuy::dif2, hgpar_, nano_mu_digi_cff::layer, alignCSCRings::r, HGCalParameters::radiusLayer_, relativeConstraints::ring, HGCalParameters::scintType(), and tol_.

Referenced by assignCellTrap().

                                                                        {
  int type = hgpar_->scintType(layer);
  double dif1 = std::abs(r - hgpar_->radiusLayer_[type][ring - 1]);
  double dif2 = std::abs(r - hgpar_->radiusLayer_[type][ring]);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeomT") << "HGCalDDDConstants::tileRingEdge:: input: " << r << ":" << layer << ":" << ring
                                 << " Differences " << dif1 << ":" << dif2;
#endif
  return ((dif1 < tol_) || (dif2 < tol_));
}

tileRings()

std::pair< int, int > HGCalDDDConstants::tileRings

(

int

layer

)

const

Definition at line 1410 of file HGCalDDDConstants.cc.

References HGCalParameters::firstLayer_, hgpar_, nano_mu_digi_cff::layer, HGCalParameters::tileRingRange_, and trapezoidFile().

                                                              {
  if (trapezoidFile()) {
    int ll = layer - hgpar_->firstLayer_;
    if (ll >= 0 && ll < static_cast<int>(hgpar_->tileRingRange_.size()))
      return hgpar_->tileRingRange_[ll];
  }
  return std::make_pair(0, 0);
}

tileSiPM()

int HGCalDDDConstants::tileSiPM ( int  sipm ) const

inline

Definition at line 168 of file HGCalDDDConstants.h.

References HGCalTypes::SiPMLarge, and HGCalTypes::SiPMSmall.

Referenced by HGCalNumberingScheme::getUnitID().

{ return ((sipm > 0) ? HGCalTypes::SiPMSmall : HGCalTypes::SiPMLarge); }

tileTrapezoid()

bool HGCalDDDConstants::tileTrapezoid ( ) const

inline

Definition at line 169 of file HGCalDDDConstants.h.

References mode_, HGCalGeometryMode::Trapezoid, HGCalGeometryMode::TrapezoidCassette, HGCalGeometryMode::TrapezoidFile, HGCalGeometryMode::TrapezoidFineCell, and HGCalGeometryMode::TrapezoidModule.

Referenced by HGCalSimHitValidation::analyzeHits(), cellEtaPhiTrap(), cellSizeHex(), getPhiBins(), getRadiusLayer(), getREtaRange(), getTypeTrap(), HGCalNumberingScheme::getUnitID(), HGCalNumberingScheme::HGCalNumberingScheme(), maxCells(), maxCellUV(), modulesInit(), numberCells(), HGCalTopology::tileTrapezoid(), and wafers().

                             {
    return ((mode_ == HGCalGeometryMode::Trapezoid) || (mode_ == HGCalGeometryMode::TrapezoidFile) ||
            (mode_ == HGCalGeometryMode::TrapezoidModule) || (mode_ == HGCalGeometryMode::TrapezoidCassette) ||
            (mode_ == HGCalGeometryMode::TrapezoidFineCell));
  }

tileType()

std::pair< int, int > HGCalDDDConstants::tileType	(	int	layer,
		int	ring,
		int	phi
	)		const

Definition at line 1419 of file HGCalDDDConstants.cc.

References hgpar_, nano_mu_digi_cff::layer, phi, relativeConstraints::ring, HGCalTypes::SiPMLarge, HGCalTileIndex::tileIndex(), and HGCalParameters::tileInfoMap_.

Referenced by HGCalTopology::encode(), HGCalNumberingScheme::getUnitID(), and HGCalGeometry::newCell().

                                                                                {
  int indx = HGCalTileIndex::tileIndex(layer, ring, phi);
  int type(-1), sipm(-1);
  auto itr = hgpar_->tileInfoMap_.find(indx);
  if (itr != hgpar_->tileInfoMap_.end()) {
    type = 1 + (itr->second).type;
    sipm = ((itr->second).sipm == HGCalTypes::SiPMLarge) ? 0 : 1;
  }
  return std::make_pair(type, sipm);
}

trapezoidFile()

bool HGCalDDDConstants::trapezoidFile ( ) const

inline

Definition at line 175 of file HGCalDDDConstants.h.

References mode_, HGCalGeometryMode::TrapezoidCassette, HGCalGeometryMode::TrapezoidFile, HGCalGeometryMode::TrapezoidFineCell, and HGCalGeometryMode::TrapezoidModule.

Referenced by isValidTrap(), locateCellTrap(), and tileRings().

                                    {
    return ((mode_ == HGCalGeometryMode::TrapezoidFile) || (mode_ == HGCalGeometryMode::TrapezoidModule) ||
            (mode_ == HGCalGeometryMode::TrapezoidCassette) || (mode_ == HGCalGeometryMode::TrapezoidFineCell));
  }

v17OrLess()

bool HGCalDDDConstants::v17OrLess ( ) const

inline

Definition at line 179 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8CalibCell, and mode_.

Referenced by HGCalMouseBiteTester::analyze().

{ return (mode_ < HGCalGeometryMode::Hexagon8CalibCell); }

volumes()

unsigned int HGCalDDDConstants::volumes ( ) const

inline

Definition at line 180 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::moduleLayR_.

{ return hgpar_->moduleLayR_.size(); }

waferCount()

int HGCalDDDConstants::waferCount ( const int  type ) const

inline

Definition at line 216 of file HGCalDDDConstants.h.

References waferMax_.

{ return ((type == 0) ? waferMax_[2] : waferMax_[3]); }

waferFileIndex()

int HGCalDDDConstants::waferFileIndex

(

unsigned int

kk

)

const

Definition at line 1737 of file HGCalDDDConstants.cc.

References hgpar_, GetRecoTauVFromDQM_MC_cff::kk, and HGCalParameters::waferInfoMap_.

                                                           {
  if (kk < hgpar_->waferInfoMap_.size()) {
    auto itr = hgpar_->waferInfoMap_.begin();
    std::advance(itr, kk);
    return itr->first;
  } else
    return 0;
}

waferFileInfo()

std::tuple< int, int, int, int > HGCalDDDConstants::waferFileInfo

(

unsigned int

kk

)

const

Definition at line 1746 of file HGCalDDDConstants.cc.

References hgpar_, GetRecoTauVFromDQM_MC_cff::kk, and HGCalParameters::waferInfoMap_.

Referenced by HGCalSD::setDetUnitId().

                                                                                   {
  if (kk < hgpar_->waferInfoMap_.size()) {
    auto itr = hgpar_->waferInfoMap_.begin();
    std::advance(itr, kk);
    return std::make_tuple(itr->second.type, itr->second.part, itr->second.orient, itr->second.cassette);
  } else
    return std::make_tuple(0, 0, 0, 0);
}

waferFileInfoExist()

bool HGCalDDDConstants::waferFileInfoExist ( int  kk ) const

inline

Definition at line 227 of file HGCalDDDConstants.h.

References hgpar_, GetRecoTauVFromDQM_MC_cff::kk, and HGCalParameters::waferInfoMap_.

                                               {
    return (hgpar_->waferInfoMap_.find(kk) != hgpar_->waferInfoMap_.end());
  }

waferFileInfoFromIndex()

std::tuple< int, int, int, int > HGCalDDDConstants::waferFileInfoFromIndex

(

int

kk

)

const

Definition at line 1755 of file HGCalDDDConstants.cc.

References hgpar_, GetRecoTauVFromDQM_MC_cff::kk, and HGCalParameters::waferInfoMap_.

                                                                                   {
  auto itr = hgpar_->waferInfoMap_.find(kk);
  if (itr != hgpar_->waferInfoMap_.end()) {
    return std::make_tuple(itr->second.type, itr->second.part, itr->second.orient, itr->second.cassette);
  } else
    return std::make_tuple(0, 0, 0, 0);
}

waferFileSize()

unsigned int HGCalDDDConstants::waferFileSize ( ) const

inline

Definition at line 223 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferInfoMap_.

Referenced by waferType(), and waferTypeRotation().

{ return hgpar_->waferInfoMap_.size(); }

waferFromCopy()

int HGCalDDDConstants::waferFromCopy

(

int

copy

)

const

Definition at line 1430 of file HGCalDDDConstants.cc.

References filterCSVwithJSON::copy, hgpar_, dqmdumpme::k, mps_fire::result, and HGCalParameters::waferCopy_.

                                                   {
  const int ncopies = hgpar_->waferCopy_.size();
  int wafer(ncopies);
  bool result(false);
  for (int k = 0; k < ncopies; ++k) {
    if (copy == hgpar_->waferCopy_[k]) {
      wafer = k;
      result = true;
      break;
    }
  }
  if (!result) {
    wafer = -1;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "Cannot find " << copy << " in a list of " << ncopies << " members";
    for (int k = 0; k < ncopies; ++k)
      edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << hgpar_->waferCopy_[k];
#endif
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "WaferFromCopy " << copy << ":" << wafer << ":" << result;
#endif
  return wafer;
}

waferFromPosition() [1/2]

void HGCalDDDConstants::waferFromPosition	(	const double	x,
		const double	y,
		int &	wafer,
		int &	icell,
		int &	celltyp
	)		const

Definition at line 1455 of file HGCalDDDConstants.cc.

References funct::abs(), HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellHex(), HGCalParameters::cellSize_, PVValHelper::dx, PVValHelper::dy, hexside_, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, hgpar_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, rmax_, tan30deg_, HGCalParameters::waferCopy_, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, x, geometryCSVtoXML::xx, y, and geometryCSVtoXML::yy.

Referenced by assignCellHex(), HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), HFNoseNumberingScheme::getUnitID(), and HGCalNumberingScheme::getUnitID().

                                                                                                                    {
  // Input x, y in Geant4 unit and transformed to CMSSW standard
  double xx = HGCalParameters::k_ScaleFromDDD * x;
  double yy = HGCalParameters::k_ScaleFromDDD * y;
  int size_ = static_cast<int>(hgpar_->waferCopy_.size());
  wafer = size_;
  for (int k = 0; k < size_; ++k) {
    double dx = std::abs(xx - hgpar_->waferPosX_[k]);
    double dy = std::abs(yy - hgpar_->waferPosY_[k]);
    if (dx <= rmax_ && dy <= hexside_) {
      if ((dy <= 0.5 * hexside_) || (dx * tan30deg_ <= (hexside_ - dy))) {
        wafer = k;
        celltyp = hgpar_->waferTypeT_[k];
        xx -= hgpar_->waferPosX_[k];
        yy -= hgpar_->waferPosY_[k];
        break;
      }
    }
  }
  if (wafer < size_) {
    if ((celltyp - 1 == HGCSiliconDetId::HGCalHD120) || (celltyp - 1 == HGCSiliconDetId::HGCalHD200))
      icell = cellHex(
          xx, yy, 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[0], hgpar_->cellFineX_, hgpar_->cellFineY_);
    else
      icell = cellHex(xx,
                      yy,
                      0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[1],
                      hgpar_->cellCoarseX_,
                      hgpar_->cellCoarseY_);
  } else {
    wafer = -1;
#ifdef EDM_ML_DEBUG
    edm::LogWarning("HGCalGeom") << "Cannot get wafer type corresponding to " << x << ":" << y << "    " << xx << ":"
                                 << yy;
#endif
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "Position " << x << ":" << y << " Wafer " << wafer << ":" << size_ << " XX " << xx
                                << ":" << yy << " Cell " << icell << " Type " << celltyp;
#endif
}

waferFromPosition() [2/2]

void HGCalDDDConstants::waferFromPosition	(	const double	x,
		const double	y,
		const int	zside,
		const int	layer,
		int &	waferU,
		int &	waferV,
		int &	cellU,
		int &	cellV,
		int &	celltype,
		double &	wt,
		bool	extend,
		bool	debug
	)		const

Definition at line 1497 of file HGCalDDDConstants.cc.

References funct::abs(), cassetteMode(), cellHex(), HGCalCell::cellPlacementIndex(), HGCalCell::cellPlacementOld, HGCalParameters::cellThickness_, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), debug, PVValHelper::dx, PVValHelper::dy, HGCalParameters::firstLayer_, HGCalWaferType::getCassette(), HGCalWaferType::getOrient(), HGCalWaferType::getPartial(), HGCalCassette::getShift(), HGCalWaferType::getType(), getXY(), hexside_, hexsideT_, HGCSiliconDetId::HGCalHD120, HGCSiliconDetId::HGCalHD200, HGCSiliconDetId::HGCalLD300, hgcassette_, hgpar_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, nano_mu_digi_cff::layer, HGCalTypes::layerFrontBack(), layerType(), HGCalParameters::layerType_, SiStripPI::min, HGCalParameters::nCellsFine_, hgcalPerformanceValidation::orient, rmax_, rmaxT_, tan30deg_, tolmin, HGCalParameters::typesInLayers_, HGCalParameters::useSimWt_, HGCalTypes::WaferCenterR, HGCalParameters::waferCopy_, HGCalTypes::WaferFull, waferHexagon8File(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferThick_, HGCalParameters::waferTypeL_, HGCalWaferIndex::waferU(), HGCalParameters::waferUVMax_, HGCalWaferIndex::waferV(), x, testProducerWithPsetDescEmpty_cfi::x1, HGCalParameters::xLayerHex_, geometryCSVtoXML::xx, geometryCSVtoXML::xy, y, testProducerWithPsetDescEmpty_cfi::y1, HGCalParameters::yLayerHex_, geometryCSVtoXML::yy, and ecaldqm::zside().

                                                            {
  // Expect x, y as in SIM step
  bool waferin = ((waferU == 0) && (waferV == 0));
  if (waferin)
    waferU = waferV = 1 + hgpar_->waferUVMax_;
  cellU = cellV = celltype = 0;
  if ((hgpar_->xLayerHex_.empty()) || (hgpar_->yLayerHex_.empty()))
    return;
  int ll = layer - hgpar_->firstLayer_;
  int layertype = layerType(layer);
  bool rotx = ((!hgpar_->layerType_.empty()) && (layertype == HGCalTypes::WaferCenterR));
  double xx(0), yy(0);
  if (rotx) {
    std::pair<double, double> xy =
        getXY(layer, HGCalParameters::k_ScaleFromDDD * x, HGCalParameters::k_ScaleFromDDD * y, true);
    xx = xy.first - hgpar_->xLayerHex_[ll];
    yy = xy.second - hgpar_->yLayerHex_[ll];
  } else {
    xx = HGCalParameters::k_ScaleFromDDD * x - hgpar_->xLayerHex_[ll];
    yy = HGCalParameters::k_ScaleFromDDD * y - hgpar_->yLayerHex_[ll];
  }
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "waferFromPosition:: Layer " << layer << ":" << ll << " Rot " << rotx << " X " << x
                                  << ":" << xx << " Y " << y << ":" << yy << " side " << zside << " extend " << extend
                                  << " initial wafer index " << waferU << ":" << waferV;
  ;
  double rmax = extend ? rmaxT_ : rmax_;
  double hexside = extend ? hexsideT_ : hexside_;
  if (waferin) {
    double tolmin(100.0);
    for (unsigned int k = 0; k < hgpar_->waferPosX_.size(); ++k) {
      double dx0(0), dy0(0);
      waferU = HGCalWaferIndex::waferU(hgpar_->waferCopy_[k]);
      waferV = HGCalWaferIndex::waferV(hgpar_->waferCopy_[k]);
      if (cassetteMode()) {
        int indx = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
        auto ktr = hgpar_->waferInfoMap_.find(indx);
        if (ktr != hgpar_->waferInfoMap_.end()) {
          auto cshift = hgcassette_.getShift(layer, -1, (ktr->second).cassette);
          if (debug)
            edm::LogVerbatim("HGCalGeom")
                << "Cassette " << (ktr->second).cassette << " Shift " << cshift.first << ":" << cshift.second;
          dx0 = -cshift.first;
          dy0 = cshift.second;
        }
      }
      double dx = std::abs(xx - dx0 - hgpar_->waferPosX_[k]);
      double dy = std::abs(yy - dy0 - hgpar_->waferPosY_[k]);
      constexpr double tolc = 0.01;
      if (debug) {
        edm::LogVerbatim("HGCalGeom") << "Wafer " << waferU << ":" << waferV << " position " << xx << ":" << yy
                                      << " Distance " << dx << ":" << dy << " diff0 " << (dx - rmax) << ":"
                                      << (dy - hexside) << " diff1 " << (dy - 0.5 * hexside) << ":"
                                      << (dx * tan30deg_ - (hexside - dy));
        if ((dx - rmax) <= tolc && (dy - hexside) <= tolc) {
          tolmin = std::min(tolmin, (dy - 0.5 * hexside));
          tolmin = std::min(tolmin, (dx * tan30deg_ - (hexside - dy)));
        }
      }
      if ((dx - rmax) <= tolc && (dy - hexside) <= tolc) {
        if (((dy - 0.5 * hexside) <= tolc) || ((dx * tan30deg_ - (hexside - dy)) <= tolc)) {
          if (waferHexagon8File()) {
            int index = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
            celltype = HGCalWaferType::getType(index, hgpar_->waferInfoMap_);
            if (debug)
              edm::LogVerbatim("HGCalGeom")
                  << "Position (" << x << ", " << y << ") Wafer type:partial:orient:cassette " << celltype << ":"
                  << HGCalWaferType::getPartial(index, hgpar_->waferInfoMap_) << ":"
                  << HGCalWaferType::getOrient(index, hgpar_->waferInfoMap_) << ":"
                  << HGCalWaferType::getCassette(index, hgpar_->waferInfoMap_);
          } else {
            auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
            celltype = ((itr == hgpar_->typesInLayers_.end()) ? HGCSiliconDetId::HGCalLD300
                                                              : hgpar_->waferTypeL_[itr->second]);
          }
          if (debug)
            edm::LogVerbatim("HGCalGeom")
                << "WaferFromPosition:: Input " << layer << ":" << ll << ":" << hgpar_->firstLayer_ << ":" << rotx
                << ":" << x << ":" << y << ":" << hgpar_->xLayerHex_[ll] << ":" << hgpar_->yLayerHex_[ll] << ":" << xx
                << ":" << yy << " compared with " << hgpar_->waferPosX_[k] << ":" << hgpar_->waferPosY_[k]
                << " difference " << dx << ":" << dy << ":" << dx * tan30deg_ << ":" << (hexside_ - dy)
                << " comparator " << rmax_ << ":" << rmaxT_ << ":" << hexside_ << ":" << hexsideT_ << " wafer "
                << waferU << ":" << waferV << ":" << celltype;
          xx -= (dx0 + hgpar_->waferPosX_[k]);
          yy -= (dy0 + hgpar_->waferPosY_[k]);
          break;
        }
      }
    }
    if (debug)
      edm::LogVerbatim("HGCalGeom") << "Tolmin " << tolmin;
  } else {
    for (unsigned int k = 0; k < hgpar_->waferPosX_.size(); ++k) {
      double dx0(0), dy0(0);
      if ((waferU == HGCalWaferIndex::waferU(hgpar_->waferCopy_[k])) &&
          (waferV == HGCalWaferIndex::waferV(hgpar_->waferCopy_[k]))) {
        if (cassetteMode()) {
          int indx = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
          auto ktr = hgpar_->waferInfoMap_.find(indx);
          if (ktr != hgpar_->waferInfoMap_.end()) {
            auto cshift = hgcassette_.getShift(layer, -1, (ktr->second).cassette);
            if (debug)
              edm::LogVerbatim("HGCalGeom")
                  << "Cassette " << (ktr->second).cassette << " Shift " << cshift.first << ":" << cshift.second;
            dx0 = -cshift.first;
            dy0 = cshift.second;
          }
        }
        if (waferHexagon8File()) {
          int index = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
          celltype = HGCalWaferType::getType(index, hgpar_->waferInfoMap_);
          if (debug)
            edm::LogVerbatim("HGCalGeom") << "Position (" << x << ", " << y << ") Wafer type:partial:orient:cassette "
                                          << celltype << ":" << HGCalWaferType::getPartial(index, hgpar_->waferInfoMap_)
                                          << ":" << HGCalWaferType::getOrient(index, hgpar_->waferInfoMap_) << ":"
                                          << HGCalWaferType::getCassette(index, hgpar_->waferInfoMap_);
        } else {
          auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
          celltype =
              ((itr == hgpar_->typesInLayers_.end()) ? HGCSiliconDetId::HGCalLD300 : hgpar_->waferTypeL_[itr->second]);
        }
        xx -= (dx0 + hgpar_->waferPosX_[k]);
        yy -= (dy0 + hgpar_->waferPosY_[k]);
        break;
      }
    }
  }
  if ((std::abs(waferU) <= hgpar_->waferUVMax_) && (celltype >= 0)) {
    int place(HGCalCell::cellPlacementOld), part(HGCalTypes::WaferFull);
    if (cassetteMode()) {
      int indx = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
      auto ktr = hgpar_->waferInfoMap_.find(indx);
      if (ktr != hgpar_->waferInfoMap_.end()) {
        place = HGCalCell::cellPlacementIndex(1, HGCalTypes::layerFrontBack(layertype), (ktr->second).orient);
        part = (ktr->second).part;
        if (debug)
          edm::LogVerbatim("HGCalGeom") << "waferFromPosition: frontback " << layertype << ":"
                                        << HGCalTypes::layerFrontBack(layertype) << " Orient " << (ktr->second).orient
                                        << " place " << place << " part " << part;
      }
    }
    cellHex(xx, yy, celltype, place, part, cellU, cellV, extend, debug);
    wt = ((((celltype == HGCSiliconDetId::HGCalHD120) || (celltype == HGCSiliconDetId::HGCalHD200)) &&
           (hgpar_->useSimWt_ > 0))
              ? (hgpar_->cellThickness_[celltype] / hgpar_->waferThick_)
              : 1.0);
  } else {
    cellU = cellV = 2 * hgpar_->nCellsFine_;
    wt = 1.0;
    celltype = -1;
  }
  if ((celltype < 0) && debug) {
    double x1(xx);
    double y1(yy);
    edm::LogVerbatim("HGCalGeom") << "waferfFromPosition: Bad type for X " << x << ":" << x1 << ":" << xx << " Y " << y
                                  << ":" << y1 << ":" << yy << " Wafer " << waferU << ":" << waferV << " Cell " << cellU
                                  << ":" << cellV;
    for (unsigned int k = 0; k < hgpar_->waferPosX_.size(); ++k) {
      double dx = std::abs(x1 - hgpar_->waferPosX_[k]);
      double dy = std::abs(y1 - hgpar_->waferPosY_[k]);
      edm::LogVerbatim("HGCalGeom") << "Wafer [" << k << "] Position (" << hgpar_->waferPosX_[k] << ", "
                                    << hgpar_->waferPosY_[k] << ") difference " << dx << ":" << dy << ":"
                                    << dx * tan30deg_ << ":" << hexside - dy << " Paramerers " << rmax << ":"
                                    << hexside;
    }
  }
  edm::LogVerbatim("HGCalGeomX") << "Input x:y:layer " << x << ":" << y << ":" << layer << " Wafer " << waferU << ":"
                                 << waferV << " Cell " << cellU << ":" << cellV << ":" << celltype << " wt " << wt;
}

waferFullInLayer()

bool HGCalDDDConstants::waferFullInLayer	(	int	wafer,
		int	lay,
		bool	reco
	)		const

Definition at line 1685 of file HGCalDDDConstants.cc.

References getIndex(), and waferInLayerTest().

                                                                            {
  const auto& indx = getIndex(lay, reco);
  if (indx.first < 0)
    return false;
  return waferInLayerTest(wafer, indx.first, false);
}

waferHexagon6()

bool HGCalDDDConstants::waferHexagon6 ( ) const

inline

Definition at line 195 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, and mode_.

Referenced by assignCell(), cellInLayer(), cellThickness(), getIndex(), getLayer(), HGCalDDDConstants(), isValidHex(), layerFromIndex(), layerIndex(), locateCell(), maxCells(), maxRows(), numberCells(), simToReco(), HGCalTopology::waferHexagon6(), waferInLayerTest(), waferType(), and waferVirtual().

                                    {
    return ((mode_ == HGCalGeometryMode::Hexagon) || (mode_ == HGCalGeometryMode::HexagonFull));
  }

waferHexagon8()

bool HGCalDDDConstants::waferHexagon8 ( ) const

inline

Definition at line 198 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8CalibCell, HGCalGeometryMode::Hexagon8Cassette, HGCalGeometryMode::Hexagon8File, HGCalGeometryMode::Hexagon8FineCell, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::Hexagon8Module, and mode_.

Referenced by HGCalSimHitValidation::analyzeHits(), assignCellHex(), cellInLayer(), cellSizeHex(), cellThickness(), distFromEdgeHex(), getIndex(), getTypeHex(), HGCalNumberingScheme::getUnitID(), HGCalDDDConstants(), HGCMouseBite::HGCMouseBite(), maskCell(), maxCells(), maxRows(), HGCalTopology::waferHexagon8(), waferType(), waferTypeRotation(), and waferVirtual().

                                    {
    return ((mode_ == HGCalGeometryMode::Hexagon8) || (mode_ == HGCalGeometryMode::Hexagon8Full) ||
            (mode_ == HGCalGeometryMode::Hexagon8File) || (mode_ == HGCalGeometryMode::Hexagon8Module) ||
            (mode_ == HGCalGeometryMode::Hexagon8Cassette) || (mode_ == HGCalGeometryMode::Hexagon8CalibCell) ||
            (mode_ == HGCalGeometryMode::Hexagon8FineCell));
  }

waferHexagon8File()

bool HGCalDDDConstants::waferHexagon8File ( ) const

inline

Definition at line 204 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8CalibCell, HGCalGeometryMode::Hexagon8Cassette, HGCalGeometryMode::Hexagon8File, HGCalGeometryMode::Hexagon8FineCell, HGCalGeometryMode::Hexagon8Module, and mode_.

Referenced by cellHex(), HGCalNumberingScheme::getUnitID(), HGCalNumberingScheme::HGCalNumberingScheme(), isValidCell8(), locateCell(), HGCalSD::setDetUnitId(), and waferFromPosition().

                                        {
    return ((mode_ == HGCalGeometryMode::Hexagon8File) || (mode_ == HGCalGeometryMode::Hexagon8Module) ||
            (mode_ == HGCalGeometryMode::Hexagon8Cassette) || (mode_ == HGCalGeometryMode::Hexagon8CalibCell) ||
            (mode_ == HGCalGeometryMode::Hexagon8FineCell));
  }

waferHexagon8Fine()

bool HGCalDDDConstants::waferHexagon8Fine ( ) const

inline

Definition at line 209 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8FineCell, and mode_.

Referenced by locateCell().

{ return ((mode_ == HGCalGeometryMode::Hexagon8FineCell)); }

waferHexagon8Module()

bool HGCalDDDConstants::waferHexagon8Module ( ) const

inline

Definition at line 210 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8CalibCell, HGCalGeometryMode::Hexagon8Cassette, HGCalGeometryMode::Hexagon8FineCell, HGCalGeometryMode::Hexagon8Module, and mode_.

Referenced by HGCGuardRing::exclude(), and HGCalNumberingScheme::getUnitID().

                                          {
    return ((mode_ == HGCalGeometryMode::Hexagon8Module) || (mode_ == HGCalGeometryMode::Hexagon8Cassette) ||
            (mode_ == HGCalGeometryMode::Hexagon8CalibCell) || (mode_ == HGCalGeometryMode::Hexagon8FineCell));
  }

waferIndex()

int32_t HGCalDDDConstants::waferIndex ( int  wafer, int  index  ) const

private

Definition at line 2171 of file HGCalDDDConstants.cc.

References hgpar_, nano_mu_digi_cff::layer, layerFromIndex(), HGCalParameters::waferCopy_, HGCalWaferIndex::waferIndex(), HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

Referenced by waferInLayerTest().

                                                                {
  int layer = layerFromIndex(index, true);
  int waferU = HGCalWaferIndex::waferU(hgpar_->waferCopy_[wafer]);
  int waferV = HGCalWaferIndex::waferV(hgpar_->waferCopy_[wafer]);
  int indx = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "WaferIndex for " << wafer << ":" << index << " (" << layer << ":" << waferU << ":"
                                << waferV << ") " << indx;
#endif
  return indx;
}

waferInfo()

HGCalParameters::waferInfo HGCalDDDConstants::waferInfo	(	int	lay,
		int	waferU,
		int	waferV
	)		const

Definition at line 1692 of file HGCalDDDConstants.cc.

References hgpar_, HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

Referenced by HGCalSD::calibCell(), HGCalCalibrationCell::findCell(), and HGCalNumberingScheme::getUnitID().

                                                                                           {
  int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
  auto itr = hgpar_->waferInfoMap_.find(indx);
  return ((itr == hgpar_->waferInfoMap_.end()) ? HGCalParameters::waferInfo() : itr->second);
}

waferInLayer()

bool HGCalDDDConstants::waferInLayer	(	int	wafer,
		int	lay,
		bool	reco
	)		const

Definition at line 1678 of file HGCalDDDConstants.cc.

References HGCalParameters::defineFull_, getIndex(), hgpar_, and waferInLayerTest().

Referenced by HGCalGeometry::getSummary(), and HGCalDDDConstants().

                                                                        {
  const auto& indx = getIndex(lay, reco);
  if (indx.first < 0)
    return false;
  return waferInLayerTest(wafer, indx.first, hgpar_->defineFull_);
}

waferInLayerTest()

bool HGCalDDDConstants::waferInLayerTest ( int  wafer, int  lay, bool  full  ) const

private

Definition at line 2183 of file HGCalDDDConstants.cc.

References TCMET_cfi::corner, full, fullAndPart_, hexside_, hgpar_, recoMuon::in, HGCalParameters::k_CornerSize, rmax_, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, HGCalGeomTools::waferCorner(), waferHexagon6(), waferIndex(), HGCalParameters::waferInfoMap_, HGCalWaferIndex::waferLayer(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), HGCalParameters::xLayerHex_, and HGCalParameters::yLayerHex_.

Referenced by maxCells(), maxRows(), modulesInit(), numberCells(), waferFullInLayer(), and waferInLayer().

                                                                            {
  bool in = (waferHexagon6()) ? true : false;
  if (!in) {
    double xpos = hgpar_->waferPosX_[wafer] + hgpar_->xLayerHex_[lay];
    double ypos = hgpar_->waferPosY_[wafer] + hgpar_->yLayerHex_[lay];
    std::pair<int, int> corner = HGCalGeomTools::waferCorner(
        xpos, ypos, rmax_, hexside_, hgpar_->rMinLayHex_[lay], hgpar_->rMaxLayHex_[lay], in);
    in = (full ? (corner.first > 0) : (corner.first == static_cast<int>(HGCalParameters::k_CornerSize)));
    if (in && fullAndPart_) {
      int indx = waferIndex(wafer, lay);
      in = (hgpar_->waferInfoMap_.find(indx) != hgpar_->waferInfoMap_.end());
#ifdef EDM_ML_DEBUG
      if (!in)
        edm::LogVerbatim("HGCalGeom") << "WaferInLayerTest: Layer " << lay << " wafer " << wafer << " index " << indx
                                      << "( " << HGCalWaferIndex::waferLayer(indx) << ", "
                                      << HGCalWaferIndex::waferU(indx) << ", " << HGCalWaferIndex::waferV(indx)
                                      << ") in " << in;
#endif
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "WaferInLayerTest: Layer " << lay << " wafer " << wafer << " R-limits "
                                  << hgpar_->rMinLayHex_[lay] << ":" << hgpar_->rMaxLayHex_[lay] << " Corners "
                                  << corner.first << ":" << corner.second << " In " << in;
#endif
  }
  return in;
}

waferLocal2Global()

GlobalPoint HGCalDDDConstants::waferLocal2Global	(	HepGeom::Point3D< float > &	loc,
		const DetId &	id,
		bool	useWafer,
		bool	reco,
		bool	debug
	)		const

Definition at line 1763 of file HGCalDDDConstants.cc.

References debug, getXY(), HGCSiliconDetId::layer(), dt_dqm_sourceclient_common_cff::reco, waferPositionNoRot(), HGCSiliconDetId::waferU(), HGCSiliconDetId::waferV(), waferZ(), x, geometryCSVtoXML::xx, geometryCSVtoXML::xy, y, HGCSiliconDetId::zside(), and geometryCSVtoXML::zz.

                                                                                             {
  HGCSiliconDetId detid(id);
  double x(0), y(0);
  if (useWafer) {
    auto xyw = waferPositionNoRot(detid.layer(), detid.waferU(), detid.waferV(), reco, debug);
    x = xyw.first;
    y = xyw.second;
  }
  auto xy = getXY(detid.layer(), (x + loc.x()), (y + loc.y()), false);
  double zz = (detid.zside() < 0) ? -(loc.z() + waferZ(detid.layer(), reco)) : (loc.z() + waferZ(detid.layer(), reco));
  double xx = (detid.zside() < 0) ? -xy.first : xy.first;
  return GlobalPoint(xx, xy.second, zz);
}

waferMax()

int HGCalDDDConstants::waferMax ( ) const

inline

Definition at line 218 of file HGCalDDDConstants.h.

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

{ return waferMax_[1]; }

waferMin()

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 219 of file HGCalDDDConstants.h.

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

{ return waferMax_[0]; }

waferParameters()

std::pair< double, double > HGCalDDDConstants::waferParameters

(

bool

reco

)

const

Definition at line 1698 of file HGCalDDDConstants.cc.

References hexside_, HGCalParameters::k_ScaleToDDD, and rmax_.

                                                                          {
  if (reco)
    return std::make_pair(rmax_, hexside_);
  else
    return std::make_pair(HGCalParameters::k_ScaleToDDD * rmax_, HGCalParameters::k_ScaleToDDD * hexside_);
}

waferPosition() [1/3]

std::pair< double, double > HGCalDDDConstants::waferPosition	(	int	wafer,
		bool	reco
	)		const

Definition at line 1705 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

Referenced by HGCalMouseBiteTester::analyze(), HGCMouseBite::exclude(), and waferPositionNoRot().

                                                                                   {
  double xx(0), yy(0);
  if (wafer >= 0 && wafer < static_cast<int>(hgpar_->waferPosX_.size())) {
    xx = hgpar_->waferPosX_[wafer];
    yy = hgpar_->waferPosY_[wafer];
  }
  if (!reco) {
    xx *= HGCalParameters::k_ScaleToDDD;
    yy *= HGCalParameters::k_ScaleToDDD;
  }
  return std::make_pair(xx, yy);
}

waferPosition() [2/3]

std::pair< double, double > HGCalDDDConstants::waferPosition	(	int	lay,
		int	waferU,
		int	waferV,
		bool	reco,
		bool	debug
	)		const

Definition at line 1718 of file HGCalDDDConstants.cc.

References debug, HGCalParameters::firstLayer_, getXY(), hgpar_, HGCalParameters::layerType_, HGCalTypes::WaferCenterR, waferPositionNoRot(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), and geometryCSVtoXML::xy.

                                                                  {
  int ll = lay - hgpar_->firstLayer_;
  bool rotx = ((!hgpar_->layerType_.empty()) && (hgpar_->layerType_[ll] == HGCalTypes::WaferCenterR));
#ifdef EDM_ML_DEBUG
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "Layer " << lay << ":" << ll << " Rotation " << rotx << " U:V " << waferU << ":"
                                  << waferV;
#endif
  auto xy = waferPositionNoRot(lay, waferU, waferV, reco, debug);
  std::pair<double, double> xy0 = (rotx) ? getXY(lay, xy.first, xy.second, false) : xy;
#ifdef EDM_ML_DEBUG
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "Without and with rotation " << xy.first << ":" << xy.second << ":" << xy0.first
                                  << ":" << xy0.second;
#endif
  return xy0;
}

waferPosition() [3/3]

std::pair< double, double > HGCalDDDConstants::waferPosition ( int  waferU, int  waferV, bool  reco  ) const

private

Definition at line 2235 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::k_ScaleToDDD, HGCalWaferIndex::waferIndex(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::wafersInLayers_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

                                                                                                {
  double xx(0), yy(0);
  int indx = HGCalWaferIndex::waferIndex(0, waferU, waferV);
  auto itr = hgpar_->wafersInLayers_.find(indx);
  if (itr != hgpar_->wafersInLayers_.end()) {
    xx = hgpar_->waferPosX_[itr->second];
    yy = hgpar_->waferPosY_[itr->second];
  }
  if (!reco) {
    xx *= HGCalParameters::k_ScaleToDDD;
    yy *= HGCalParameters::k_ScaleToDDD;
  }
  return std::make_pair(xx, yy);
}

waferPositionNoRot()

std::pair< double, double > HGCalDDDConstants::waferPositionNoRot ( int  lay, int  waferU, int  waferV, bool  reco, bool  debug  ) const

private

Definition at line 2211 of file HGCalDDDConstants.cc.

References debug, HGCalParameters::firstLayer_, hgpar_, HGCalParameters::k_ScaleToDDD, waferPosition(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), x, HGCalParameters::xLayerHex_, geometryCSVtoXML::xy, y, and HGCalParameters::yLayerHex_.

Referenced by isValidCell8(), localToGlobal8(), locateCell(), waferLocal2Global(), and waferPosition().

                                                                  {
  int ll = lay - hgpar_->firstLayer_;
  double x = hgpar_->xLayerHex_[ll];
  double y = hgpar_->yLayerHex_[ll];
#ifdef EDM_ML_DEBUG
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "Layer " << lay << ":" << ll << " Shift " << hgpar_->xLayerHex_[ll] << ":"
                                  << hgpar_->yLayerHex_[ll] << " U:V " << waferU << ":" << waferV;
#endif
  if (!reco) {
    x *= HGCalParameters::k_ScaleToDDD;
    y *= HGCalParameters::k_ScaleToDDD;
  }
  const auto& xy = waferPosition(waferU, waferV, reco);
  x += xy.first;
  y += xy.second;
#ifdef EDM_ML_DEBUG
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "With wafer " << x << ":" << y << ":" << xy.first << ":" << xy.second;
#endif
  return std::make_pair(x, y);
}

wafers() [1/2]

int HGCalDDDConstants::wafers

(

)

const

Definition at line 1778 of file HGCalDDDConstants.cc.

References HGCalParameters::depth_, hgpar_, mps_fire::i, layers(), HGCalParameters::moduleLayR_, modules(), and tileTrapezoid().

Referenced by HGCalTopology::allGeomModules(), and HGCalDDDConstants().

                                    {
  int wafer(0);
  if (!tileTrapezoid()) {
    for (unsigned int i = 0; i < layers(true); ++i) {
      int lay = hgpar_->depth_[i];
      wafer += modules(lay, true);
    }
  } else {
    wafer = static_cast<int>(hgpar_->moduleLayR_.size());
  }
  return wafer;
}

wafers() [2/2]

int HGCalDDDConstants::wafers	(	int	layer,
		int	type
	)		const

Definition at line 1791 of file HGCalDDDConstants.cc.

References HGCalParameters::firstModule_, getIndex(), hgpar_, HGCalParameters::lastModule_, nano_mu_digi_cff::layer, tileTrapezoid(), and waferLayer_.

                                                       {
  int wafer(0);
  if (!tileTrapezoid()) {
    auto itr = waferLayer_.find(layer);
    if (itr != waferLayer_.end()) {
      unsigned ity = (type > 0 && type <= 2) ? type : 0;
      wafer = (itr->second)[ity];
    }
  } else {
    const auto& index = getIndex(layer, true);
    wafer = 1 + hgpar_->lastModule_[index.first] - hgpar_->firstModule_[index.first];
  }
  return wafer;
}

waferSepar()

double HGCalDDDConstants::waferSepar ( bool  reco ) const

inline

Definition at line 232 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::k_ScaleToDDD, and HGCalParameters::sensorSeparation_.

                                            {
    return (reco ? hgpar_->sensorSeparation_ : HGCalParameters::k_ScaleToDDD * hgpar_->sensorSeparation_);
  }

waferSize()

double HGCalDDDConstants::waferSize ( bool  reco ) const

inline

Definition at line 235 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::k_ScaleToDDD, and HGCalParameters::waferSize_.

Referenced by HGCalMouseBiteTester::analyze(), HFNoseSD::update(), and HGCalSD::update().

                                           {
    return (reco ? hgpar_->waferSize_ : HGCalParameters::k_ScaleToDDD * hgpar_->waferSize_);
  }

waferToCopy()

int HGCalDDDConstants::waferToCopy ( int  wafer ) const

inline

Definition at line 240 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferCopy_.

                                          {
    return ((wafer >= 0) && (wafer < static_cast<int>(hgpar_->waferCopy_.size())))
               ? hgpar_->waferCopy_[wafer]
               : static_cast<int>(hgpar_->waferCopy_.size());
  }

waferType() [1/3]

int HGCalDDDConstants::waferType	(	DetId const &	id,
		bool	fromFile
	)		const

Definition at line 1806 of file HGCalDDDConstants.cc.

References DetId::Forward, hgpar_, nano_mu_digi_cff::layer, HFNoseDetId::layer(), HGCSiliconDetId::layer(), HFNoseDetId::type(), HGCSiliconDetId::type(), waferFileSize(), waferHexagon6(), waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, waferTypeL(), HGCalWaferIndex::waferU(), HFNoseDetId::waferU(), HGCSiliconDetId::waferU(), HGCalWaferIndex::waferV(), HFNoseDetId::waferV(), and HGCSiliconDetId::waferV().

Referenced by HGCalSimHitValidation::analyzeHits(), assignCellHex(), cellThickness(), HGCalNumberingScheme::getUnitID(), isHalfCell(), HGCalUncalibRecHitRecWeightsAlgo< HGCDataFrame >::makeRecHit(), and HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

                                                                     {
  int type(1);
  if (waferHexagon8()) {
    if (fromFile && (waferFileSize() > 0)) {
      int layer(0), waferU(0), waferV(0);
      if (id.det() != DetId::Forward) {
        HGCSiliconDetId hid(id);
        layer = hid.layer();
        waferU = hid.waferU();
        waferV = hid.waferV();
      } else {
        HFNoseDetId hid(id);
        layer = hid.layer();
        waferU = hid.waferU();
        waferV = hid.waferV();
      }
      auto itr = hgpar_->waferInfoMap_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
      if (itr != hgpar_->waferInfoMap_.end())
        type = (itr->second).type;
    } else {
      type = ((id.det() != DetId::Forward) ? HGCSiliconDetId(id).type() : HFNoseDetId(id).type());
    }
  } else if (waferHexagon6()) {
    type = waferTypeL(HGCalDetId(id).wafer()) - 1;
  }
  return type;
}

waferType() [2/3]

int HGCalDDDConstants::waferType	(	int	layer,
		int	waferU,
		int	waferV,
		bool	fromFile
	)		const

Definition at line 1834 of file HGCalDDDConstants.cc.

References HGCSiliconDetId::HGCalLD300, hgpar_, nano_mu_digi_cff::layer, HGCalParameters::typesInLayers_, waferFileSize(), waferHexagon6(), waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalParameters::waferTypeL_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

                                                                                       {
  int type(HGCSiliconDetId::HGCalLD300);
  if (waferHexagon8()) {
    if (fromFile && (waferFileSize() > 0)) {
      auto itr = hgpar_->waferInfoMap_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
      if (itr != hgpar_->waferInfoMap_.end())
        type = (itr->second).type;
    } else {
      auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
      if (itr != hgpar_->typesInLayers_.end())
        type = hgpar_->waferTypeL_[itr->second];
    }
  } else if (waferHexagon6()) {
    if ((waferU >= 0) && (waferU < static_cast<int>(hgpar_->waferTypeL_.size())))
      type = (hgpar_->waferTypeL_[waferU] - 1);
  }
  return type;
}

waferType() [3/3]

std::tuple< int, int, int > HGCalDDDConstants::waferType	(	HGCSiliconDetId const &	id,
		bool	fromFile
	)		const

Definition at line 1853 of file HGCalDDDConstants.cc.

References dqmdumpme::first, hgpar_, HGCalGeomTools::k_allCorners, HGCalGeomTools::k_fiveCorners, HGCalGeomTools::k_fourCorners, HGCalTypes::k_OffsetRotation, HGCalGeomTools::k_threeCorners, nano_mu_digi_cff::layer, hgcalPerformanceValidation::orient, edm::second(), HGCalParameters::typesInLayers_, waferFileSize(), HGCalTypes::WaferFive, HGCalTypes::WaferFull, HGCalTypes::WaferHalf, HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalTypes::WaferThree, HGCalParameters::waferTypeL_, HGCalParameters::waferTypes_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

                                                                                                   {
  const auto& index = HGCalWaferIndex::waferIndex(id.layer(), id.waferU(), id.waferV());
  int type(-1), part(-1), orient(-1);
  if (fromFile && (waferFileSize() > 0)) {
    auto itr = hgpar_->waferInfoMap_.find(index);
    if (itr != hgpar_->waferInfoMap_.end()) {
      type = (itr->second).type;
      part = (itr->second).part;
      orient = (itr->second).orient;
    }
  } else {
    auto ktr = hgpar_->typesInLayers_.find(index);
    if (ktr != hgpar_->typesInLayers_.end())
      type = hgpar_->waferTypeL_[ktr->second];
    auto itr = hgpar_->waferTypes_.find(index);
    if (itr != hgpar_->waferTypes_.end()) {
      if ((itr->second).second < HGCalTypes::k_OffsetRotation) {
        orient = (itr->second).second;
        if ((itr->second).first == HGCalGeomTools::k_allCorners) {
          part = HGCalTypes::WaferFull;
        } else if ((itr->second).first == HGCalGeomTools::k_fiveCorners) {
          part = HGCalTypes::WaferFive;
        } else if ((itr->second).first == HGCalGeomTools::k_fourCorners) {
          part = HGCalTypes::WaferHalf;
        } else if ((itr->second).first == HGCalGeomTools::k_threeCorners) {
          part = HGCalTypes::WaferThree;
        }
      } else {
        part = (itr->second).first;
        orient = ((itr->second).second - HGCalTypes::k_OffsetRotation);
      }
    } else {
      part = HGCalTypes::WaferFull;
      orient = 0;
    }
  }
  return std::make_tuple(type, part, orient);
}

waferTypeL()

int HGCalDDDConstants::waferTypeL ( int  wafer ) const

inline

Definition at line 250 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

Referenced by PFRecHitQTestThresholdInThicknessNormalizedMIPs::test(), and waferType().

                                         {
    return ((wafer >= 0) && (wafer < static_cast<int>(hgpar_->waferTypeL_.size()))) ? hgpar_->waferTypeL_[wafer] : 0;
  }

waferTypeRotation()

std::pair< int, int > HGCalDDDConstants::waferTypeRotation	(	int	layer,
		int	waferU,
		int	waferV,
		bool	fromFile,
		bool	debug
	)		const

Definition at line 1892 of file HGCalDDDConstants.cc.

References debug, TauDecayModes::dec, dqmdumpme::first, hgpar_, HGCalGeomTools::k_allCorners, HGCalGeomTools::k_fiveCorners, HGCalGeomTools::k_fourCorners, HGCalTypes::k_OffsetRotation, HGCalGeomTools::k_threeCorners, nano_mu_digi_cff::layer, hgcalPerformanceValidation::orient, edm::second(), HGCalTypes::WaferCorner0, waferFileSize(), HGCalTypes::WaferFive, HGCalTypes::WaferFull, HGCalTypes::WaferHalf, waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalTypes::WaferOut, HGCalTypes::WaferThree, HGCalParameters::waferTypes_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), and LaserClient_cfi::wl.

Referenced by isValidCell8(), and HGCalSD::setDetUnitId().

                                                                        {
  int type(HGCalTypes::WaferOut), rotn(0);
  int wl = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
  bool withinList(true);
  if (fromFile && (waferFileSize() > 0)) {
    auto itr = hgpar_->waferInfoMap_.find(wl);
    withinList = (itr != hgpar_->waferInfoMap_.end());
    if (withinList) {
      type = (itr->second).part;
      rotn = (itr->second).orient;
    }
  } else {
    auto itr = hgpar_->waferTypes_.find(wl);
    if (waferHexagon8()) {
      withinList = (itr != hgpar_->waferTypes_.end());
      if (withinList) {
        if ((itr->second).second < HGCalTypes::k_OffsetRotation) {
          rotn = (itr->second).second;
          if ((itr->second).first == HGCalGeomTools::k_allCorners) {
            type = HGCalTypes::WaferFull;
          } else if ((itr->second).first == HGCalGeomTools::k_fiveCorners) {
            type = HGCalTypes::WaferFive;
          } else if ((itr->second).first == HGCalGeomTools::k_fourCorners) {
            type = HGCalTypes::WaferHalf;
          } else if ((itr->second).first == HGCalGeomTools::k_threeCorners) {
            type = HGCalTypes::WaferThree;
          }
        } else {
          type = (itr->second).first;
          rotn = ((itr->second).second - HGCalTypes::k_OffsetRotation);
        }
      } else {
        type = HGCalTypes::WaferFull;
        rotn = HGCalTypes::WaferCorner0;
      }
    }
  }
#ifdef EDM_ML_DEBUG
  if (debug)
    edm::LogVerbatim("HGCalGeom") << "waferTypeRotation: Layer " << layer << " Wafer " << waferU << ":" << waferV
                                  << " Index " << std::hex << wl << std::dec << ":" << withinList << " Type " << type
                                  << " Rotation " << rotn;
#endif
  return std::make_pair(type, rotn);
}

waferTypeT()

int HGCalDDDConstants::waferTypeT ( int  wafer ) const

inline

Definition at line 246 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeT_.

Referenced by HGCalGeometry::getClosestCell(), and hgcal::RecHitTools::isHalfCell().

                                         {
    return ((wafer >= 0) && (wafer < static_cast<int>(hgpar_->waferTypeT_.size()))) ? hgpar_->waferTypeT_[wafer] : 0;
  }

waferUVMax()

int HGCalDDDConstants::waferUVMax ( ) const

inline

Definition at line 257 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferUVMax_.

Referenced by HGCalTopology::HGCalTopology().

{ return hgpar_->waferUVMax_; }

waferVirtual()

bool HGCalDDDConstants::waferVirtual	(	int	layer,
		int	waferU,
		int	waferV
	)		const

Definition at line 1939 of file HGCalDDDConstants.cc.

References hgpar_, nano_mu_digi_cff::layer, waferHexagon6(), waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferTypes_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), and LaserClient_cfi::wl.

                                                                            {
  bool type(false);
  if (waferHexagon8()) {
    int wl = HGCalWaferIndex::waferIndex(layer, waferU, waferV, false);
    type = (hgpar_->waferTypes_.find(wl) != hgpar_->waferTypes_.end());
  } else if (waferHexagon6()) {
    int wl = HGCalWaferIndex::waferIndex(layer, waferU, 0, true);
    type = (hgpar_->waferTypes_.find(wl) != hgpar_->waferTypes_.end());
  }
  return type;
}

waferZ()

double HGCalDDDConstants::waferZ	(	int	layer,
		bool	reco
	)		const

Definition at line 1951 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, HGCalParameters::k_ScaleToDDD, and HGCalParameters::zLayerHex_.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTB23Analyzer::analyzeSimHits(), ticl::SeedingRegionByTracks::buildFirstLayers(), ticl::GeneralInterpretationAlgo::buildLayers(), ticl::LinkingAlgoByDirectionGeometric::buildLayers(), ticl::TracksterLinkingbySkeletons::buildLayers(), HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), DetectorTools::DetectorTools(), HGCalGeometry::get8Corners(), HGCalGeometry::getCorners(), HGCalTriggerTools::getLayerZ(), HGCalGeometry::getNewCorners(), HGCalGeometry::getPosition(), hgcal::RecHitTools::getPositionLayer(), ticl::LinkingAlgoByDirectionGeometric::linkTracksters(), ticl::GeneralInterpretationAlgo::makeCandidates(), HGCalGeometry::neighborZ(), HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_(), and waferLocal2Global().

                                                         {
  const auto& index = getIndex(lay, reco);
  if (index.first < 0)
    return 0;
  else
    return (reco ? hgpar_->zLayerHex_[index.first] : HGCalParameters::k_ScaleToDDD * hgpar_->zLayerHex_[index.first]);
}

Member Data Documentation

cellOffset_

std::unique_ptr<HGCalCellOffset> HGCalDDDConstants::cellOffset_

private

Definition at line 282 of file HGCalDDDConstants.h.

Referenced by cellOffset(), HGCalDDDConstants(), and locateCell().

dPhiMin

constexpr float HGCalDDDConstants::dPhiMin = 0.02

staticprivate

Definition at line 285 of file HGCalDDDConstants.h.

fullAndPart_

const bool HGCalDDDConstants::fullAndPart_

private

Definition at line 293 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), isValidHex8(), and waferInLayerTest().

geomTools_

HGCalGeomTools HGCalDDDConstants::geomTools_

private

Definition at line 283 of file HGCalDDDConstants.h.

hexside_

double HGCalDDDConstants::hexside_

private

Definition at line 294 of file HGCalDDDConstants.h.

Referenced by distFromEdgeHex(), HGCalDDDConstants(), waferFromPosition(), waferInLayerTest(), and waferParameters().

hexsideT_

double HGCalDDDConstants::hexsideT_

private

Definition at line 295 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and waferFromPosition().

hgcassette_

HGCalCassette HGCalDDDConstants::hgcassette_

private

Definition at line 279 of file HGCalDDDConstants.h.

Referenced by assignCellTrap(), cassetteShiftScintillator(), cassetteShiftSilicon(), HGCalDDDConstants(), localToGlobal8(), locateCell(), locateCellTrap(), and waferFromPosition().

hgcell_

std::unique_ptr<HGCalCell> HGCalDDDConstants::hgcell_

private

Definition at line 280 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and locateCell().

hgcellUV_

std::unique_ptr<HGCalCellUV> HGCalDDDConstants::hgcellUV_

private

Definition at line 281 of file HGCalDDDConstants.h.

Referenced by cellHex(), and HGCalDDDConstants().

hgpar_

const HGCalParameters* HGCalDDDConstants::hgpar_

private

Definition at line 288 of file HGCalDDDConstants.h.

Referenced by assignCell(), assignCellTrap(), calibCellRad(), calibCells(), cassetteShiftSilicon(), cassetteTile(), cellEtaPhiTrap(), cellHex(), cellInLayer(), cellSizeHex(), cellSizeTrap(), cellThickness(), cellType(), distFromEdgeHex(), distFromEdgeTrap(), firstLayer(), getIndex(), getLayer(), getLayerOffset(), getModule(), getModules(), getParameter(), getPhiBins(), getRadiusLayer(), getRangeR(), getREtaRange(), getTrForm(), getTrFormN(), getTrForms(), getTypeHex(), getTypeTrap(), getUVMax(), getXY(), guardRingOffset(), HGCalDDDConstants(), isHalfCell(), isValidCell(), isValidCell8(), isValidHex(), isValidHex8(), isValidTrap(), lastLayer(), layerFromIndex(), layerIndex(), layersInit(), layerType(), levelTop(), localToGlobal8(), locateCell(), locateCellHex(), locateCellTrap(), maskCell(), maxCells(), maxCellUV(), maxRows(), minSlope(), modulesInit(), mouseBite(), numberCells(), numberCellsHexagon(), partialWaferType(), rangeR(), rangeRLayer(), rangeZ(), rowColumnWafer(), sectors(), sensorSizeOffset(), simToReco(), tileCount(), tileExist(), tileInfo(), tilePhiEdge(), tileRingEdge(), tileRings(), tileType(), volumes(), waferFileIndex(), waferFileInfo(), waferFileInfoExist(), waferFileInfoFromIndex(), waferFileSize(), waferFromCopy(), waferFromPosition(), waferIndex(), waferInfo(), waferInLayer(), waferInLayerTest(), waferPosition(), waferPositionNoRot(), wafers(), waferSepar(), waferSize(), waferToCopy(), waferType(), waferTypeL(), waferTypeRotation(), waferTypeT(), waferUVMax(), waferVirtual(), and waferZ().

k_horizontalShift

constexpr double HGCalDDDConstants::k_horizontalShift = 1.0

staticprivate

Definition at line 284 of file HGCalDDDConstants.h.

max_modules_layer_

Simrecovecs HGCalDDDConstants::max_modules_layer_

private

Definition at line 298 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and modules().

maxWafersPerLayer_

int32_t HGCalDDDConstants::maxWafersPerLayer_

private

Definition at line 299 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModulesPerLayer().

mode_

const HGCalGeometryMode::GeometryMode HGCalDDDConstants::mode_

private

Definition at line 292 of file HGCalDDDConstants.h.

Referenced by cassetteMode(), cellInLayer(), geomMode(), HGCalDDDConstants(), isValidCell8(), tileTrapezoid(), trapezoidFile(), v17OrLess(), waferHexagon6(), waferHexagon8(), waferHexagon8File(), waferHexagon8Fine(), and waferHexagon8Module().

modHalf_

int32_t HGCalDDDConstants::modHalf_

private

Definition at line 296 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModules().

rmax_

double HGCalDDDConstants::rmax_

private

Definition at line 294 of file HGCalDDDConstants.h.

Referenced by assignCell(), cellHex(), distFromEdgeHex(), HGCalDDDConstants(), waferFromPosition(), waferInLayerTest(), and waferParameters().

rmaxT_

double HGCalDDDConstants::rmaxT_

private

Definition at line 295 of file HGCalDDDConstants.h.

Referenced by cellHex(), HGCalDDDConstants(), and waferFromPosition().

sqrt3_

const double HGCalDDDConstants::sqrt3_

private

Definition at line 291 of file HGCalDDDConstants.h.

Referenced by cellHex(), and distFromEdgeHex().

tan30deg_

constexpr double HGCalDDDConstants::tan30deg_ = 0.5773502693

staticprivate

Definition at line 289 of file HGCalDDDConstants.h.

Referenced by cellHex(), distFromEdgeHex(), HGCalDDDConstants(), and waferFromPosition().

tol_

constexpr double HGCalDDDConstants::tol_ = 0.001

staticprivate

Definition at line 290 of file HGCalDDDConstants.h.

Referenced by assignCellTrap(), tilePhiEdge(), and tileRingEdge().

tot_layers_

std::array<uint32_t, 2> HGCalDDDConstants::tot_layers_

private

Definition at line 297 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), lastLayer(), and layers().

tot_wafers_

int32_t HGCalDDDConstants::tot_wafers_

private

Definition at line 296 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants().

waferIn_

std::unordered_map<int32_t, bool> HGCalDDDConstants::waferIn_

private

Definition at line 302 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and isValidHex8().

waferLayer_

std::map<int, HGCWaferParam> HGCalDDDConstants::waferLayer_

private

Definition at line 300 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and wafers().

waferMax_

std::array<int, 4> HGCalDDDConstants::waferMax_

private

Definition at line 301 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), waferCount(), waferMax(), and waferMin().