#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

bool	cassetteShiftScintillator (int layer, int iphi) const

bool	cassetteShiftSilicon (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

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

	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 debug) const

std::pair< float, float >	locateCell (const HGCSiliconDetId &, 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

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

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

unsigned int	volumes () const

int	waferCount (const int type) const

int	waferFileIndex (unsigned int kk) const

std::tuple< int, int, int >	waferFileInfo (unsigned int kk) const

bool	waferFileInfoExist (int kk) const

std::tuple< 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

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
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 35 of file HGCalDDDConstants.h.

Member Typedef Documentation

◆ HGCWaferParam

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

private

Definition at line 246 of file HGCalDDDConstants.h.

◆ Simrecovecs

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

private

Definition at line 245 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 HGCalParameters::cassettes_, HGCalParameters::cassetteShift_, HGCalParameters::cellSize_, funct::cos(), fullAndPart_, getIndex(), getTrForm(), getTrFormN(), HGCalGeometryMode::Hexagon8Cassette, hexside_, hexsideT_, hgcassette_, hgcell_, hgcellUV_, hgpar_, mps_fire::i, HGCalParameters::k_ScaleFromDDD, HGCalParameters::hgtrform::lay, pixelTopology::layer, layers(), layersInit(), SiStripPI::max, max_modules_layer_, maxCells(), maxWafersPerLayer_, mode_, modHalf_, modulesInit(), Skims_PA_cff::name, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, rmax_, rmaxT_, sectors(), HGCalParameters::sensorSeparation_, HGCalCassette::setParameter(), tan30deg_, tot_layers_, tot_wafers_, HGCalGeometryMode::TrapezoidCassette, HGCalParameters::waferCopy_, waferHexagon6(), waferHexagon8(), waferIn_, HGCalWaferIndex::waferIndex(), waferInLayer(), waferLayer_, waferMax_, HGCalParameters::waferR_, wafers(), 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") << "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_);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "rmax_ " << rmax_ << ":" << rmaxT_ << ":" << hexside_ << ":" << hexsideT_
                                   << " CellSize " << 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[0] << ":"
                                   << 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[1];
 #endif
   }
   if ((mode_ == HGCalGeometryMode::Hexagon8Cassette) || (mode_ == HGCalGeometryMode::TrapezoidCassette)) {
     hgcassette_.setParameter(hgpar_->cassettes_, hgpar_->cassetteShift_);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "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") << "Layer " << layer << " with " << max_modules_layer_[simreco][layer] << ":"
                                       << modHalf_ << " modules in RECO";
       } else {
         edm::LogVerbatim("HGCalGeom") << "Layer " << layer << " with " << max_modules_layer_[simreco][layer]
                                       << " modules in SIM";
 #endif
       }
     }
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "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 127 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 HGCNumberingScheme::assignCell(), and 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 166 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 181 of file HGCalDDDConstants.cc.

References funct::abs(), HGCalParameters::cassettes_, angle_units::operators::convertRadToDeg(), HGCalParameters::firstLayer_, getIndex(), HGCalCassette::getShift(), hgcassette_, hgpar_, LEDCalibrationChannels::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, pixelTopology::layer, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, M_PI, mode_, 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_, HGCalGeometryMode::TrapezoidCassette, 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 (mode_ == HGCalGeometryMode::TrapezoidCassette) {
     int cassette = HGCalTileIndex::tileCassette(iphi, hgpar_->phiOffset_, hgpar_->nphiCassette_, hgpar_->cassettes_);
     auto cshift = hgcassette_.getShift(layer, -1, cassette);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeomT") << "Cassette " << cassette << " Shift " << cshift.first << ":" << cshift.second<< " Original " << xx << ":"
                    << yy;
 #endif
     xx += (zside * cshift.first);
     yy -= cshift.second;
   }
   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}};
 }

◆ cassetteShiftScintillator()

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

Definition at line 268 of file HGCalDDDConstants.cc.

References cassetteTile(), HGCalCassette::getShift(), hgcassette_, LEDCalibrationChannels::iphi, pixelTopology::layer, mode_, edm::shift, and HGCalGeometryMode::TrapezoidCassette.

Referenced by HGCScintSD::setDetUnitId().

                                                                            {
   bool shift(false);
   if (mode_ == HGCalGeometryMode::TrapezoidCassette) {
     auto cshift = hgcassette_.getShift(layer, 1, cassetteTile(iphi));
     if ((cshift.first != 0) || (cshift.second != 0))
       shift = true;
   }
   return shift;
 }

◆ cassetteShiftSilicon()

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

Definition at line 254 of file HGCalDDDConstants.cc.

References HGCalCassette::getShift(), HGCalGeometryMode::Hexagon8Cassette, hgcassette_, hgpar_, pixelTopology::layer, mode_, edm::shift, HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

Referenced by HGCalSD::setDetUnitId().

                                                                                     {
   bool shift(false);
   if (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
     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 ((cshift.first != 0) || (cshift.second != 0))
         shift = true;
     }
   }
   return shift;
 }

◆ cassetteTile()

int HGCalDDDConstants::cassetteTile ( int iphi ) const

inline

Definition at line 45 of file HGCalDDDConstants.h.

References HGCalParameters::cassettes_, hgpar_, LEDCalibrationChannels::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 278 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, hgcalPerformanceValidation::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 1835 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 1854 of file HGCalDDDConstants.cc.

References funct::abs(), cellType(), debug, newFWLiteAna::found, HGCalGeometryMode::Hexagon8Cassette, hgcellUV_, hgpar_, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, SiStripPI::max, SiStripPI::min, mode_, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, rmax_, rmaxT_, edm::shift, sqrt3_, V0Monitor_cff::v0, HGCalTypes::WaferFull, and waferHexagon8File().

                                                                                                                         {
   if (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
     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 == 0) ? 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 288 of file HGCalDDDConstants.cc.

References getIndex(), HGCalWaferMask::goodCell(), HGCalGeometryMode::Hexagon8Cassette, HGCalGeometryMode::Hexagon8Module, hgpar_, locateCell(), mode_, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, hgcalPerformanceValidation::orient, HGCalParameters::rMinLayHex_, mathSSE::sqrt(), HGCalTypes::WaferFineThin, HGCalTypes::WaferFull, 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 (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
       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::WaferFineThin), 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::WaferFineThin) ? 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)
                              : 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;
   }
 }

◆ cellSizeHex()

double HGCalDDDConstants::cellSizeHex ( int type ) const

Definition at line 334 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), and 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 51 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 321 of file HGCalDDDConstants.cc.

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

Referenced by HGCalTBAnalyzer::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 341 of file HGCalDDDConstants.cc.

References HGCalCell::cellPlacementIndex(), HGCalCell::cellPlacementOld, HGCalCell::cellType(), 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 == 0) ? 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 348 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(), and HGCalSD::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 394 of file HGCalDDDConstants.cc.

References funct::abs(), getLayer(), hgpar_, LEDCalibrationChannels::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 66 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().

66 { return hgpar_->firstLayer_; }

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:77

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ geomMode()

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

Definition at line 67 of file HGCalDDDConstants.h.

References mode_.

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

67 { return mode_; }

HGCalDDDConstants::mode_

const HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:251

◆ getIndex()

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

private

Definition at line 1916 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 424 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(), HGCMouseBite::exclude(), 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 69 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::layerOffset_.

Referenced by HGCalNumberingScheme::HGCalNumberingScheme().

69 { return hgpar_->layerOffset_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

HGCalParameters::layerOffset_

int layerOffset_

Definition: HGCalParameters.h:178

◆ getModule()

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

Definition at line 444 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), and 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::HGCalCoarseThick);
     mytr = hgpar_->getModule(type, reco);
   } else {
     mytr = hgpar_->getModule(indx, reco);
   }
   return mytr;
 }

◆ getModules()

std::vector< HGCalParameters::hgtrap > HGCalDDDConstants::getModules ( ) const

Definition at line 460 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 72 of file HGCalDDDConstants.h.

References hgpar_.

Referenced by HGCalGeometryLoader::build(), HGCalGeometry::getSummary(), HGCalNumberingScheme::getUnitID(), HeterogeneousHGCalHEFCellPositionsFiller::produce(), and HGCalSD::update().

72 { return hgpar_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ getPhiBins()

int HGCalDDDConstants::getPhiBins ( int lay ) const

Definition at line 467 of file HGCalDDDConstants.cc.

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

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

HGCalDDDConstants::tileTrapezoid

bool tileTrapezoid() const

Definition: HGCalDDDConstants.h:138

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

HGCalParameters::scintCells

int scintCells(const int layer) const

Definition: HGCalParameters.h:67

◆ getRadiusLayer()

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

inline

Definition at line 76 of file HGCalDDDConstants.h.

References hgpar_, pixelTopology::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 469 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 477 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 79 of file HGCalDDDConstants.h.

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

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

79 { return hgpar_->getTrForm(k); }

HGCalParameters::getTrForm

hgtrform getTrForm(unsigned int k) const

Definition: HGCalParameters.cc:108

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

dqmdumpme.k

k

Definition: dqmdumpme.py:60

◆ getTrFormN()

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 80 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::trformIndex_.

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:103

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ getTrForms()

std::vector< HGCalParameters::hgtrform > HGCalDDDConstants::getTrForms ( ) const

Definition at line 489 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 505 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), 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 496 of file HGCalDDDConstants.cc.

References hgpar_, pixelTopology::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 85 of file HGCalDDDConstants.h.

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

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

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

type

Definition: SiPixelVCal_PayloadInspector.cc:39

HGCalParameters::nCellsCoarse_

int nCellsCoarse_

Definition: HGCalParameters.h:152

HGCalParameters::nCellsFine_

int nCellsFine_

Definition: HGCalParameters.h:151

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ getXY()

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

Definition at line 515 of file HGCalDDDConstants.cc.

References HGCalParameters::firstLayer_, hgpar_, pixelTopology::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);
 }

◆ isHalfCell()

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

Definition at line 544 of file HGCalDDDConstants.cc.

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

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

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

◆ isValidCell()

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

private

Definition at line 1953 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCSiliconDetId::HGCalFine, 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::HGCalFine) {
     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 1977 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseIndex_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineIndex_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCalParameters::firstLayer_, HGCalWaferMask::goodCell(), HGCalGeometryMode::Hexagon8Cassette, 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_ << ":"
                                 << HGCalGeometryMode::Hexagon8Cassette << " part " << partn.first << ":"
                                 << partn.second;
 #endif
   if (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
     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 == 0) {
       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 == 0) ? 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 550 of file HGCalDDDConstants.cc.

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

Referenced by HGCNumberingScheme::getUnitID(), and 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::HGCalFine)
                          ? 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 593 of file HGCalDDDConstants.cc.

References fullAndPart_, hgpar_, pixelTopology::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 661 of file HGCalDDDConstants.cc.

References hgpar_, isValidCell8(), isValidHex8(), pixelTopology::layer, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::typesInLayers_, 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] == 0) ? 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 695 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, LEDCalibrationChannels::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, pixelTopology::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 714 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 1933 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 720 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), 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 718 of file HGCalDDDConstants.cc.

References dt_dqm_sourceclient_common_cff::reco, and tot_layers_.

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

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

dt_dqm_sourceclient_common_cff.reco

reco

Definition: dt_dqm_sourceclient_common_cff.py:111

HGCalDDDConstants::tot_layers_

std::array< uint32_t, 2 > tot_layers_

Definition: HGCalDDDConstants.h:256

◆ layersInit()

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

Definition at line 733 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 95 of file HGCalDDDConstants.h.

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

Referenced by locateCell(), 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 108 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::levelT_.

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

108 { return hgpar_->levelT_[ind]; }

HGCalParameters::levelT_

std::vector< int > levelT_

Definition: HGCalParameters.h:148

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ 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 737 of file HGCalDDDConstants.cc.

References debug, HGCalParameters::firstLayer_, HGCalCassette::getShift(), getXY(), HGCalGeometryMode::Hexagon8Cassette, hgcassette_, hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::layerType_, mode_, 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 ((mode_ == HGCalGeometryMode::Hexagon8Cassette) && (ktr != hgpar_->waferInfoMap_.end())) {
     auto cshift = hgcassette_.getShift(lay, -zside, (ktr->second).cassette);
     if (debug)
       edm::LogVerbatim("HGCalGeom") << "Cassette " << (ktr->second).cassette << " Shift " << -(zside * cshift.first)
                                     << ":" << cshift.second;
     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)
     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 772 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTBAnalyzer::analyzeSimHits(), cellInLayer(), HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), HGCalGeometry::get8Corners(), HGCalGeometry::getCorners(), HGCNumberingScheme::getLocalCoords(), 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::HGCalFine) {
       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	debug
	)		const

Definition at line 803 of file HGCalDDDConstants.cc.

References python.cmstools::all(), HGCalParameters::cellCoarseIndex_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineIndex_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCalCell::cellPlacementIndex(), HGCalCell::cellPlacementOld, debug, HGCalParameters::firstLayer_, HGCalCassette::getShift(), getXY(), HGCalGeometryMode::Hexagon8Cassette, hgcassette_, hgcell_, hgpar_, HGCalParameters::k_ScaleToDDD, HGCalTypes::layerFrontBack(), layerType(), mode_, hgcalPerformanceValidation::orient, HGCalParameters::typesInLayers_, HGCalTypes::WaferCenterR, waferHexagon8File(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, waferPositionNoRot(), HGCalParameters::waferTypeL_, HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), x, geometryCSVtoXML::xy, y, and ecaldqm::zside().

           {
   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 (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
       ktr = hgpar_->waferInfoMap_.find(indx);
       if (ktr != hgpar_->waferInfoMap_.end())
         place = HGCalCell::cellPlacementIndex(1, HGCalTypes::layerFrontBack(layertype), (ktr->second).orient);
     }
     auto xy = 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 == 0) {
       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 ((mode_ == HGCalGeometryMode::Hexagon8Cassette) && (ktr != hgpar_->waferInfoMap_.end())) {
       auto cshift = hgcassette_.getShift(lay, -zside, (ktr->second).cassette);
       if (debug)
         edm::LogVerbatim("HGCalGeom") << "Cassette " << (ktr->second).cassette << " Shift " << -(zside * cshift.first)
                                       << ":" << cshift.second;
       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)
       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	debug
	)		const

Definition at line 881 of file HGCalDDDConstants.cc.

References debug, pixelTopology::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, debug);
 }

◆ locateCell() [4/4]

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

Definition at line 885 of file HGCalDDDConstants.cc.

References debug, LEDCalibrationChannels::iphi, pixelTopology::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 889 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCSiliconDetId::HGCalFine, 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::HGCalFine) {
     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 905 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalGeometryLoader::build(), 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 ((mode_ != HGCalGeometryMode::TrapezoidFile) && (mode_ != HGCalGeometryMode::TrapezoidModule) &&
         (mode_ != HGCalGeometryMode::TrapezoidCassette))
       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 (mode_ == HGCalGeometryMode::TrapezoidCassette) {
       int cassette = HGCalTileIndex::tileCassette(iphi, hgpar_->phiOffset_, hgpar_->nphiCassette_, hgpar_->cassettes_);
       auto cshift = hgcassette_.getShift(lay, -1, cassette);
       if (debug)
         edm::LogVerbatim("HGCalGeom") << "Cassette " << cassette << " Shift " << -(zside * cshift.first) << ":"
                                       << cshift.second;
       x -= cshift.first;
       y += cshift.second;
     }
   }
   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 949 of file HGCalDDDConstants.cc.

References DetId::det(), DetId::Forward, getUVMax(), HGCalWaferMask::goodCell(), HGCalGeometryMode::Hexagon8Cassette, hgpar_, l1ctLayer2EG_cff::id, HGCalParameters::k_CornerSize, HGCalTypes::k_OffsetRotation, pixelTopology::layer, gpuClustering::pixelStatus::mask, HGCalWaferMask::maskCell(), mode_, 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 (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
         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 994 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 1004 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, hgcalTBTopologyTester_cfi::cells, HGCalParameters::defineFull_, HGCalParameters::firstLayer_, getIndex(), HGCSiliconDetId::HGCalCoarseThick, HGCSiliconDetId::HGCalFine, 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::HGCalFine) ? (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::HGCalCoarseThick
                                                           : hgpar_->waferTypeL_[itr->second]);
         int N = (type == HGCSiliconDetId::HGCalFine) ? 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 110 of file HGCalDDDConstants.h.

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

Referenced by HGCalTopology::HGCalTopology().

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

HGCalDDDConstants::tileTrapezoid

bool tileTrapezoid() const

Definition: HGCalDDDConstants.h:138

HGCalParameters::nCellsFine_

int nCellsFine_

Definition: HGCalParameters.h:151

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ maxModules()

int HGCalDDDConstants::maxModules ( ) const

inline

Definition at line 113 of file HGCalDDDConstants.h.

References modHalf_.

113 { return modHalf_; }

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:255

◆ maxModulesPerLayer()

int HGCalDDDConstants::maxModulesPerLayer ( ) const

inline

Definition at line 114 of file HGCalDDDConstants.h.

References maxWafersPerLayer_.

114 { return maxWafersPerLayer_; }

HGCalDDDConstants::maxWafersPerLayer_

int32_t maxWafersPerLayer_

Definition: HGCalDDDConstants.h:258

◆ maxRows()

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

Definition at line 1039 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 116 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::slopeMin_.

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

116 { return hgpar_->slopeMin_[0]; }

HGCalParameters::slopeMin_

std::vector< double > slopeMin_

Definition: HGCalParameters.h:82

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ modifyUV()

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

Definition at line 1059 of file HGCalDDDConstants.cc.

Referenced by HGCalTopology::neighbors().

                                                                   {
   // Modify u/v for transition of type1 to type2
   return (((type1 == type2) || (type1 * type2 != 0)) ? uv : ((type1 == 0) ? (2 * uv + 1) / 3 : (3 * uv) / 2));
 }

◆ modules()

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

Definition at line 1064 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 1071 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 1087 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 1091 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 1106 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::defineFull_, HGCalParameters::firstModule_, getIndex(), HGCSiliconDetId::HGCalFine, 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::HGCalFine)
                                   ? (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 1139 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCSiliconDetId::HGCalFine, 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::HGCalFine)
       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 1150 of file HGCalDDDConstants.cc.

References RemoveAddSevLevel::flag, HGCSiliconDetId::HGCalCoarseThick, hgpar_, caHitNtupletGeneratorKernels::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::HGCalCoarseThick : hgpar_->waferTypeL_[itr->second]);
   int N = (type == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_;
   if (flag)
     return (3 * N * N);
   else
     return N;
 }

◆ rangeR()

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

Definition at line 1161 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::LinkingAlgoByDirectionGeometric::buildLayers(), HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), HGCDigitizer::checkPosition(), locateCellTrap(), and HGCalGeometry::neighborZ().

                                                                            {
   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 1188 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 1206 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 1219 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 129 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::nSectors_.

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

129 { return hgpar_->nSectors_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:76

◆ simToReco()

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

Definition at line 1230 of file HGCalDDDConstants.cc.

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

Referenced by HGCalTimingAnalyzer::analyzeSimHits(), HGCalTBAnalyzer::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 1259 of file HGCalDDDConstants.cc.

References b, HGCalParameters::firstLayer_, hgpar_, dqmdumpme::k, lastLayer(), pixelTopology::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 1300 of file HGCalDDDConstants.cc.

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

Referenced by assignCellTrap(), HGCalGeometryLoader::build(), 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 1307 of file HGCalDDDConstants.cc.

References hgpar_, pixelTopology::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 1313 of file HGCalDDDConstants.cc.

References funct::abs(), cuy::dif1, cuy::dif2, hgpar_, LEDCalibrationChannels::iphi, pixelTopology::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 1323 of file HGCalDDDConstants.cc.

References funct::abs(), cuy::dif1, cuy::dif2, hgpar_, pixelTopology::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 1333 of file HGCalDDDConstants.cc.

References HGCalParameters::firstLayer_, hgpar_, pixelTopology::layer, mode_, HGCalParameters::tileRingRange_, HGCalGeometryMode::TrapezoidCassette, HGCalGeometryMode::TrapezoidFile, and HGCalGeometryMode::TrapezoidModule.

                                                               {
   if ((mode_ == HGCalGeometryMode::TrapezoidFile) || (mode_ == HGCalGeometryMode::TrapezoidModule) ||
       (mode_ == HGCalGeometryMode::TrapezoidCassette)) {
     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 137 of file HGCalDDDConstants.h.

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

Referenced by HGCalNumberingScheme::getUnitID().

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

HGCalTypes::SiPMLarge

Definition: HGCalTypes.h:106

HGCalTypes::SiPMSmall

Definition: HGCalTypes.h:106

◆ tileTrapezoid()

bool HGCalDDDConstants::tileTrapezoid ( ) const

inline

Definition at line 138 of file HGCalDDDConstants.h.

References mode_, HGCalGeometryMode::Trapezoid, HGCalGeometryMode::TrapezoidCassette, HGCalGeometryMode::TrapezoidFile, 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));
   }

◆ tileType()

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

Definition at line 1343 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), 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 143 of file HGCalDDDConstants.h.

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

Referenced by isValidTrap().

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

◆ volumes()

unsigned int HGCalDDDConstants::volumes ( ) const

inline

Definition at line 147 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::moduleLayR_.

Referenced by HGCalGeometryLoader::build().

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:96

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ waferCount()

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 176 of file HGCalDDDConstants.h.

References waferMax_.

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

type

Definition: SiPixelVCal_PayloadInspector.cc:39

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:260

◆ waferFileIndex()

int HGCalDDDConstants::waferFileIndex ( unsigned int kk ) const

Definition at line 1613 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 > HGCalDDDConstants::waferFileInfo ( unsigned int kk ) const

Definition at line 1622 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 std::make_tuple(itr->second.type, itr->second.part, itr->second.orient);
   } else
     return std::make_tuple(0, 0, 0);
 }

◆ waferFileInfoExist()

bool HGCalDDDConstants::waferFileInfoExist ( int kk ) const

inline

Definition at line 187 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 > HGCalDDDConstants::waferFileInfoFromIndex ( int kk ) const

Definition at line 1631 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);
   } else
     return std::make_tuple(0, 0, 0);
 }

◆ waferFileSize()

unsigned int HGCalDDDConstants::waferFileSize ( ) const

inline

Definition at line 183 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferInfoMap_.

Referenced by waferType(), and waferTypeRotation().

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

HGCalParameters::waferInfoMap_

waferInfo_map waferInfoMap_

Definition: HGCalParameters.h:187

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

◆ waferFromCopy()

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 1354 of file HGCalDDDConstants.cc.

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

Referenced by HGCNumberingScheme::getUnitID().

                                                    {
   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 1379 of file HGCalDDDConstants.cc.

References funct::abs(), HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellHex(), HGCalParameters::cellSize_, PVValHelper::dx, PVValHelper::dy, hexside_, HGCSiliconDetId::HGCalFine, 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(), HGCNumberingScheme::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::HGCalFine)
       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 1421 of file HGCalDDDConstants.cc.

References funct::abs(), cellHex(), HGCalCell::cellPlacementIndex(), HGCalCell::cellPlacementOld, HGCalParameters::cellThickness_, debug, PVValHelper::dx, PVValHelper::dy, HGCalParameters::firstLayer_, HGCalWaferType::getCassette(), HGCalWaferType::getOrient(), HGCalWaferType::getPartial(), HGCalCassette::getShift(), HGCalWaferType::getType(), getXY(), HGCalGeometryMode::Hexagon8Cassette, hexside_, hexsideT_, HGCSiliconDetId::HGCalCoarseThick, hgcassette_, hgpar_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, pixelTopology::layer, HGCalTypes::layerFrontBack(), layerType(), HGCalParameters::layerType_, mode_, HGCalParameters::nCellsFine_, hgcalPerformanceValidation::orient, rmax_, rmaxT_, tan30deg_, 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
   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];
   }
 #ifdef EDM_ML_DEBUG
   if (debug)
     edm::LogVerbatim("HGCalGeom") << "waferFromPosition:: Layer " << layer << ":" << ll << " Rot " << rotx << " X " << x
                                   << ":" << xx << " Y " << y << ":" << yy;
 #endif
   double rmax = extend ? rmaxT_ : rmax_;
   double hexside = extend ? hexsideT_ : hexside_;
   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 (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
       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);
 #ifdef EDM_ML_DEBUG
         if (debug)
           edm::LogVerbatim("HGCalGeom") << "Cassette " << (ktr->second).cassette << " Shift " << -(zside * cshift.first)
                                         << ":" << cshift.second;
 #endif
         dx0 = -(zside * cshift.first);
         dy0 = cshift.second;
       }
     }
     double dx = std::abs(xx - dx0 - hgpar_->waferPosX_[k]);
     double dy = std::abs(yy - dy0 - hgpar_->waferPosY_[k]);
     if (dx <= rmax && dy <= hexside) {
       if ((dy <= 0.5 * hexside) || (dx * tan30deg_ <= (hexside - dy))) {
         if (waferHexagon8File()) {
           int index = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
           celltype = HGCalWaferType::getType(index, hgpar_->waferInfoMap_);
 #ifdef EDM_ML_DEBUG
           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_);
 #endif
         } else {
           auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
           celltype = ((itr == hgpar_->typesInLayers_.end()) ? HGCSiliconDetId::HGCalCoarseThick
                                                             : hgpar_->waferTypeL_[itr->second]);
         }
 #ifdef EDM_ML_DEBUG
         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;
 #endif
         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 (mode_ == HGCalGeometryMode::Hexagon8Cassette) {
       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;
 #ifdef EDM_ML_DEBUG
         if (debug)
           edm::LogVerbatim("HGCalGeom") << "waferFromPosition: frontback " << layertype << ":"
                                         << HGCalTypes::layerFrontBack(layertype) << " Orient " << (ktr->second).orient
                                         << " place " << place << " part " << part;
 #endif
       }
     }
     cellHex(xx, yy, celltype, place, part, cellU, cellV, extend, debug);
     wt = (((celltype < 2) && (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 1561 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 162 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 165 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Cassette, HGCalGeometryMode::Hexagon8File, 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));
   }

◆ waferHexagon8File()

bool HGCalDDDConstants::waferHexagon8File ( ) const

inline

Definition at line 170 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8Cassette, HGCalGeometryMode::Hexagon8File, 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));
   }

◆ waferIndex()

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

private

Definition at line 2044 of file HGCalDDDConstants.cc.

References hgpar_, pixelTopology::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 1568 of file HGCalDDDConstants.cc.

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

Referenced by 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 1554 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), 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 2056 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 1639 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 178 of file HGCalDDDConstants.h.

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

178 { return waferMax_[1]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:260

◆ waferMin()

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 179 of file HGCalDDDConstants.h.

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

179 { return waferMax_[0]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:260

◆ waferParameters()

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

Definition at line 1574 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 1581 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), 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 1594 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 2108 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 2084 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 1654 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 1667 of file HGCalDDDConstants.cc.

References HGCalParameters::firstModule_, getIndex(), hgpar_, HGCalParameters::lastModule_, pixelTopology::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 192 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 195 of file HGCalDDDConstants.h.

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

Referenced by 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 200 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 1682 of file HGCalDDDConstants.cc.

References DetId::Forward, hgpar_, HFNoseDetId::layer(), HGCSiliconDetId::layer(), pixelTopology::layer, HGCSiliconDetId::type(), HFNoseDetId::type(), waferFileSize(), waferHexagon6(), waferHexagon8(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferInfoMap_, waferTypeL(), HGCalWaferIndex::waferU(), HFNoseDetId::waferU(), HGCSiliconDetId::waferU(), HGCalWaferIndex::waferV(), HGCSiliconDetId::waferV(), and HFNoseDetId::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 1710 of file HGCalDDDConstants.cc.

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

                                                                                        {
   int type(HGCSiliconDetId::HGCalCoarseThick);
   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 1729 of file HGCalDDDConstants.cc.

References dqmdumpme::first, hgpar_, HGCalGeomTools::k_allCorners, HGCalGeomTools::k_fiveCorners, HGCalGeomTools::k_fourCorners, HGCalTypes::k_OffsetRotation, HGCalGeomTools::k_threeCorners, pixelTopology::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 210 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

Referenced by HGCalTBAnalyzer::analyzeRecHits(), 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 1768 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, pixelTopology::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 206 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeT_.

Referenced by HGCalGeometryLoader::build(), 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 217 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferUVMax_.

Referenced by HGCalTopology::HGCalTopology().

217 { return hgpar_->waferUVMax_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:247

HGCalParameters::waferUVMax_

int waferUVMax_

Definition: HGCalParameters.h:157

◆ waferVirtual()

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

Definition at line 1815 of file HGCalDDDConstants.cc.

References hgpar_, pixelTopology::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 1827 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTBAnalyzer::analyzeRecHits(), HGCalTBAnalyzer::analyzeSimHits(), ticl::SeedingRegionByTracks::buildFirstLayers(), ticl::LinkingAlgoByDirectionGeometric::buildLayers(), HFNoseNumberingScheme::checkPosition(), HGCalNumberingScheme::checkPosition(), HGCalGeometry::get8Corners(), HGCalGeometry::getCorners(), HGCalTriggerTools::getLayerZ(), HGCalGeometry::getNewCorners(), HGCalGeometry::getPosition(), hgcal::RecHitTools::getPositionLayer(), ticl::LinkingAlgoByDirectionGeometric::linkTracksters(), 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

◆ dPhiMin

constexpr float HGCalDDDConstants::dPhiMin = 0.02

staticprivate

Definition at line 244 of file HGCalDDDConstants.h.

◆ fullAndPart_

const bool HGCalDDDConstants::fullAndPart_

private

Definition at line 252 of file HGCalDDDConstants.h.

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

◆ geomTools_

HGCalGeomTools HGCalDDDConstants::geomTools_

private

Definition at line 242 of file HGCalDDDConstants.h.

◆ hexside_

double HGCalDDDConstants::hexside_

private

Definition at line 253 of file HGCalDDDConstants.h.

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

◆ hexsideT_

double HGCalDDDConstants::hexsideT_

private

Definition at line 254 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and waferFromPosition().

◆ hgcassette_

HGCalCassette HGCalDDDConstants::hgcassette_

private

Definition at line 239 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 240 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and locateCell().

◆ hgcellUV_

std::unique_ptr<HGCalCellUV> HGCalDDDConstants::hgcellUV_

private

Definition at line 241 of file HGCalDDDConstants.h.

Referenced by cellHex(), and HGCalDDDConstants().

◆ hgpar_

const HGCalParameters* HGCalDDDConstants::hgpar_

private

Definition at line 247 of file HGCalDDDConstants.h.

Referenced by assignCell(), assignCellTrap(), 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(), 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(), rangeR(), rangeRLayer(), rangeZ(), rowColumnWafer(), sectors(), 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 243 of file HGCalDDDConstants.h.

◆ max_modules_layer_

Simrecovecs HGCalDDDConstants::max_modules_layer_

private

Definition at line 257 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and modules().

◆ maxWafersPerLayer_

int32_t HGCalDDDConstants::maxWafersPerLayer_

private

Definition at line 258 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModulesPerLayer().

◆ mode_

const HGCalGeometryMode::GeometryMode HGCalDDDConstants::mode_

private

Definition at line 251 of file HGCalDDDConstants.h.

Referenced by assignCellTrap(), cassetteShiftScintillator(), cassetteShiftSilicon(), cellHex(), cellInLayer(), geomMode(), HGCalDDDConstants(), isValidCell8(), localToGlobal8(), locateCell(), locateCellTrap(), maskCell(), tileRings(), tileTrapezoid(), trapezoidFile(), waferFromPosition(), waferHexagon6(), waferHexagon8(), and waferHexagon8File().

◆ modHalf_

int32_t HGCalDDDConstants::modHalf_

private

Definition at line 255 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModules().

◆ rmax_

double HGCalDDDConstants::rmax_

private

Definition at line 253 of file HGCalDDDConstants.h.

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

◆ rmaxT_

double HGCalDDDConstants::rmaxT_

private

Definition at line 254 of file HGCalDDDConstants.h.

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

◆ sqrt3_

const double HGCalDDDConstants::sqrt3_

private

Definition at line 250 of file HGCalDDDConstants.h.

Referenced by cellHex(), and distFromEdgeHex().

◆ tan30deg_

constexpr double HGCalDDDConstants::tan30deg_ = 0.5773502693

staticprivate

Definition at line 248 of file HGCalDDDConstants.h.

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

◆ tol_

constexpr double HGCalDDDConstants::tol_ = 0.001

staticprivate

Definition at line 249 of file HGCalDDDConstants.h.

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

◆ tot_layers_

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

private

Definition at line 256 of file HGCalDDDConstants.h.

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

◆ tot_wafers_

int32_t HGCalDDDConstants::tot_wafers_

private

Definition at line 255 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants().

◆ waferIn_

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

private

Definition at line 261 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and isValidHex8().

◆ waferLayer_

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

private

Definition at line 259 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and wafers().

◆ waferMax_

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

private

Definition at line 260 of file HGCalDDDConstants.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ HGCWaferParam

◆ Simrecovecs

Constructor & Destructor Documentation

◆ HGCalDDDConstants()

◆ ~HGCalDDDConstants()

Member Function Documentation

◆ assignCell()

◆ assignCellHex()

◆ assignCellTrap()

◆ cassetteShiftScintillator()

◆ cassetteShiftSilicon()

◆ cassetteTile()

◆ cellEtaPhiTrap()

◆ cellHex() [1/2]

◆ cellHex() [2/2]

◆ cellInLayer()

◆ cellSizeHex()

◆ cellSizeTrap()

◆ cellThickness()

◆ cellType()

◆ distFromEdgeHex()

◆ distFromEdgeTrap()

◆ etaPhiFromPosition()

◆ firstLayer()

◆ geomMode()

◆ getIndex()

◆ getLayer()

◆ getLayerOffset()

◆ getModule()

◆ getModules()

◆ getParameter()

◆ getPhiBins()

◆ getRadiusLayer()

◆ getRangeR()

◆ getREtaRange()

◆ getTrForm()

◆ getTrFormN()

◆ getTrForms()

◆ getTypeHex()

◆ getTypeTrap()

◆ getUVMax()

◆ getXY()

◆ isHalfCell()

◆ isValidCell()

◆ isValidCell8()

◆ isValidHex()

◆ isValidHex8() [1/2]

◆ isValidHex8() [2/2]

◆ isValidTrap()

◆ lastLayer()

◆ layerFromIndex()

◆ layerIndex()

◆ layers()

◆ layersInit()

◆ layerType()

◆ levelTop()

◆ localToGlobal8()

◆ locateCell() [1/4]

◆ locateCell() [2/4]

◆ locateCell() [3/4]

◆ locateCell() [4/4]

◆ locateCellHex()

◆ locateCellTrap()

◆ maskCell()

◆ maxCells() [1/2]

◆ maxCells() [2/2]

◆ maxCellUV()

◆ maxModules()

◆ maxModulesPerLayer()

◆ maxRows()

◆ minSlope()

◆ modifyUV()

◆ modules()