#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	cassetteMode () const

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

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

int	cassetteTile (int iphi) const

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

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

double	cellSizeHex (int type) const

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

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

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

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

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

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

int	firstLayer () const

HGCalGeometryMode::GeometryMode	geomMode () const

int	getLayer (double z, bool reco) const

int	getLayerOffset () const

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

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

const HGCalParameters *	getParameter () const

int	getPhiBins (int lay) const

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

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

std::pair< int, int >	getREtaRange (int lay) const

HGCalParameters::hgtrform	getTrForm (unsigned int k) const

unsigned int	getTrFormN () const

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

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

int	getTypeTrap (int layer) const

int	getUVMax (int type) const

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

double	guardRingOffset (bool reco) const

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

bool	isHalfCell (int waferType, int cell) const

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

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

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

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

int	lastLayer (bool reco) const

int	layerIndex (int lay, bool reco) const

unsigned int	layers (bool reco) const

unsigned int	layersInit (bool reco) const

int	layerType (int lay) const

int	levelTop (int ind=0) const

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

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

std::pair< float, float >	locateCell (int zside, int lay, int waferU, int waferV, int cellU, int cellV, bool reco, bool all, bool norot, bool 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

double	sensorSizeOffset (bool reco) const

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

int	tileCount (int layer, int ring) const

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

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

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

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

std::pair< int, int >	tileRings (int layer) const

int	tileSiPM (int sipm) const

bool	tileTrapezoid () const

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

bool	trapezoidFile () const

unsigned int	volumes () const

int	waferCount (const int type) const

int	waferFileIndex (unsigned int kk) const

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

bool	waferFileInfoExist (int kk) const

std::tuple< int, int, int, int >	waferFileInfoFromIndex (int kk) const

unsigned int	waferFileSize () const

int	waferFromCopy (int copy) const

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

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

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

bool	waferHexagon6 () const

bool	waferHexagon8 () const

bool	waferHexagon8File () const

bool	waferHexagon8Module () const

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

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

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

int	waferMax () const

int	waferMin () const

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

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

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

int	wafers () const

int	wafers (int layer, int type) const

double	waferSepar (bool reco) const

double	waferSize (bool reco) const

int	waferToCopy (int wafer) const

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

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

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

int	waferTypeL (int wafer) const

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

int	waferTypeT (int wafer) const

int	waferUVMax () const

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

double	waferZ (int layer, bool reco) const

	~HGCalDDDConstants ()=default

Private Types
typedef std::array< int, 3 >	HGCWaferParam

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

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

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

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

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

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

int	layerFromIndex (int index, bool reco) const

int32_t	waferIndex (int wafer, int index) const

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

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

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

Private Attributes
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 256 of file HGCalDDDConstants.h.

◆ Simrecovecs

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

private

Definition at line 255 of file HGCalDDDConstants.h.

Constructor & Destructor Documentation

◆ HGCalDDDConstants()

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

Definition at line 25 of file HGCalDDDConstants.cc.

References cassetteMode(), HGCalParameters::cassettes_, HGCalParameters::cassetteShift_, HGCalParameters::cellSize_, funct::cos(), fullAndPart_, getIndex(), getTrForm(), getTrFormN(), hexside_, hexsideT_, hgcassette_, hgcell_, hgcellUV_, hgpar_, mps_fire::i, HGCalParameters::k_ScaleFromDDD, HGCalParameters::hgtrform::lay, nano_mu_digi_cff::layer, layers(), layersInit(), SiStripPI::max, max_modules_layer_, maxCells(), maxWafersPerLayer_, mode_, modHalf_, modulesInit(), Skims_PA_cff::name, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, rmax_, rmaxT_, sectors(), HGCalParameters::sensorSeparation_, HGCalCassette::setParameter(), tan30deg_, tot_layers_, tot_wafers_, 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 (cassetteMode()) {
     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(), cassetteMode(), HGCalParameters::cassettes_, angle_units::operators::convertRadToDeg(), HGCalParameters::firstLayer_, getIndex(), HGCalCassette::getShift(), hgcassette_, hgpar_, hcalRecHitTable_cff::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, nano_mu_digi_cff::layer, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, M_PI, HGCalParameters::nphiCassette_, phi, HGCalParameters::phiOffset_, alignCSCRings::r, HGCalParameters::radiusLayer_, dt_dqm_sourceclient_common_cff::reco, HGCalParameters::scintCells(), HGCalParameters::scintCellSize(), HGCalParameters::scintType(), mathSSE::sqrt(), HGCalTileIndex::tileCassette(), tileExist(), tilePhiEdge(), tileRingEdge(), tol_, x, HGCalParameters::xLayerHex_, geometryCSVtoXML::xx, y, HGCalParameters::yLayerHex_, geometryCSVtoXML::yy, z, and ecaldqm::zside().

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

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

◆ cassetteMode()

bool HGCalDDDConstants::cassetteMode ( ) const

inline

Definition at line 43 of file HGCalDDDConstants.h.

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

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

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

◆ cassetteShiftScintillator()

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

Definition at line 273 of file HGCalDDDConstants.cc.

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

Referenced by HGCScintSD::setDetUnitId().

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

◆ cassetteShiftSilicon()

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

Definition at line 259 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSD::setDetUnitId().

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

◆ cassetteTile()

int HGCalDDDConstants::cassetteTile ( int iphi ) const

inline

Definition at line 49 of file HGCalDDDConstants.h.

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

Referenced by cassetteShiftScintillator().

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

◆ cellEtaPhiTrap()

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

Definition at line 283 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 1851 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 1870 of file HGCalDDDConstants.cc.

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

                                                                                                                         {
   if (cassetteMode()) {
     auto uv = (part == HGCalTypes::WaferFull)
                   ? hgcellUV_->cellUVFromXY3(xloc, yloc, place, cellType, true, debug)
                   : hgcellUV_->cellUVFromXY1(xloc, yloc, place, cellType, part, true, debug);
     cellU = uv.first;
     cellV = uv.second;
   } else if (waferHexagon8File()) {
     auto uv = hgcellUV_->cellUVFromXY3(xloc, yloc, place, cellType, extend, debug);
     cellU = uv.first;
     cellV = uv.second;
   } else {
     int ncell = (cellType == 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 293 of file HGCalDDDConstants.cc.

References cassetteMode(), getIndex(), HGCalWaferMask::goodCell(), HGCalGeometryMode::Hexagon8Module, hgpar_, locateCell(), mode_, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, hgcalPerformanceValidation::orient, HGCalParameters::rMinLayHex_, mathSSE::sqrt(), HGCalTypes::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 (cassetteMode()) {
       int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
       auto ktr = hgpar_->waferInfoMap_.find(indx);
       int part = (ktr != hgpar_->waferInfoMap_.end()) ? (ktr->second).part : HGCalTypes::WaferFull;
       return HGCalWaferMask::goodCell(cellU, cellV, part);
     } else if (mode_ == HGCalGeometryMode::Hexagon8Module) {
       int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
       auto ktr = hgpar_->waferInfoMap_.find(indx);
       int thck(HGCalTypes::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 339 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 55 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 326 of file HGCalDDDConstants.cc.

References HGCalParameters::cellThickness_, hgpar_, nano_mu_digi_cff::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 346 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 353 of file HGCalDDDConstants.cc.

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

Referenced by HFNoseSD::isItinFidVolume().

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

◆ distFromEdgeTrap()

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

Definition at line 399 of file HGCalDDDConstants.cc.

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

Referenced by HGCScintSD::isItinFidVolume().

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

◆ etaPhiFromPosition()

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

◆ firstLayer()

int HGCalDDDConstants::firstLayer ( ) const

inline

Definition at line 70 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().

70 { return hgpar_->firstLayer_; }

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:77

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

◆ geomMode()

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

Definition at line 71 of file HGCalDDDConstants.h.

References mode_.

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

71 { return mode_; }

HGCalDDDConstants::mode_

const HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:261

◆ getIndex()

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

private

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

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

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

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

◆ getLayerOffset()

int HGCalDDDConstants::getLayerOffset ( ) const

inline

Definition at line 73 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::layerOffset_.

Referenced by HGCalNumberingScheme::HGCalNumberingScheme().

73 { return hgpar_->layerOffset_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

HGCalParameters::layerOffset_

int layerOffset_

Definition: HGCalParameters.h:181

◆ getModule()

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

Definition at line 449 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 465 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 76 of file HGCalDDDConstants.h.

References hgpar_.

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

76 { return hgpar_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

◆ getPhiBins()

int HGCalDDDConstants::getPhiBins ( int lay ) const

Definition at line 472 of file HGCalDDDConstants.cc.

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

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

HGCalDDDConstants::tileTrapezoid

bool tileTrapezoid() const

Definition: HGCalDDDConstants.h:144

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

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

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

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

◆ getRangeR()

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

Definition at line 474 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 482 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 83 of file HGCalDDDConstants.h.

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

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

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

HGCalParameters::getTrForm

hgtrform getTrForm(unsigned int k) const

Definition: HGCalParameters.cc:108

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

dqmdumpme.k

k

Definition: dqmdumpme.py:60

◆ getTrFormN()

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 84 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::trformIndex_.

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:103

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

◆ getTrForms()

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

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

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

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

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

Referenced by HGCalTriggerGeometryV9Imp3::detIdWaferType().

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

◆ getUVMax()

int HGCalDDDConstants::getUVMax ( int type ) const

inline

Definition at line 89 of file HGCalDDDConstants.h.

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

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

89 { 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:257

◆ getXY()

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

Definition at line 520 of file HGCalDDDConstants.cc.

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

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

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

◆ guardRingOffset()

double HGCalDDDConstants::guardRingOffset ( bool reco ) const

Definition at line 549 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSD::update().

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

◆ isHalfCell()

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

Definition at line 553 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 1969 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 1993 of file HGCalDDDConstants.cc.

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

Referenced by isValidHex8().

                                                                                                           {
   bool result(false);
   auto partn = waferTypeRotation(lay, waferU, waferV, false, false);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "waferHexagon8 " << waferHexagon8File() << ":" << mode_ << ":" << cassetteMode()
                                 << " part " << partn.first << ":" << partn.second;
 #endif
   if (cassetteMode()) {
     result = HGCalWaferMask::goodCell(cellU, cellV, partn.first);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "Input " << lay << ":" << waferU << ":" << waferV << ":" << cellU << ":" << cellV
                                   << " Result " << result << " from goodCell";
 #endif
   } else {
     float x(0), y(0);
     int kndx = cellV * 100 + cellU;
     if (type == 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 559 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 602 of file HGCalDDDConstants.cc.

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

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

                                                                                          {
   // Check validity for a layer|wafer|cell of post-TDR version
   int indx = HGCalWaferIndex::waferIndex(layer, modU, modV);
   auto itr = hgpar_->typesInLayers_.find(indx);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::isValidHex8:WaferType " << layer << ":" << modU << ":" << modV
                                 << ":" << indx << " Test " << (itr != hgpar_->typesInLayers_.end());
 #endif
   if (itr == hgpar_->typesInLayers_.end()) {
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                   << " in wadferIndex";
 #endif
     return false;
   }
 
   if (fullAndPart_) {
     auto ktr = hgpar_->waferInfoMap_.find(indx);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::isValidHex8:WaferInfoMap " << layer << ":" << modU << ":"
                                   << modV << ":" << indx << " Test " << (ktr != hgpar_->waferInfoMap_.end());
 #endif
     if (ktr == hgpar_->waferInfoMap_.end()) {
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                     << " in wadferInfoMap";
 #endif
       return false;
     }
   } else {
     auto jtr = waferIn_.find(indx);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants::isValidHex8:WaferIn " << jtr->first << ":" << jtr->second;
 #endif
     if (!(jtr->second)) {
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                     << " in wadferIn";
 #endif
       return false;
     }
   }
 
   if (fullAndPart || fullAndPart_) {
     auto ktr = hgpar_->waferTypes_.find(indx);
     if (ktr != hgpar_->waferTypes_.end()) {
       if (hgpar_->waferMaskMode_ > 0) {
         if (ktr->second.first == HGCalTypes::WaferOut) {
 #ifdef EDM_ML_DEBUG
           edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                         << " due to WaferOut";
 #endif
           return false;
         }
       } else {
         if (ktr->second.first < HGCalTypes::WaferCornerMin) {
 #ifdef EDM_ML_DEBUG
           edm::LogVerbatim("HGCalGeom") << "HGCalDDDConstants:: Cannot find " << layer << ":" << modU << ":" << modV
                                         << " due to WaferCornerMin";
 #endif
           return false;
         }
       }
     }
   }
   return true;
 }

◆ isValidHex8() [2/2]

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

Definition at line 670 of file HGCalDDDConstants.cc.

References hgpar_, isValidCell8(), isValidHex8(), nano_mu_digi_cff::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 704 of file HGCalDDDConstants.cc.

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

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

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

◆ lastLayer()

int HGCalDDDConstants::lastLayer ( bool reco ) const

Definition at line 723 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 1949 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 729 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 727 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().

727 { 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:266

◆ layersInit()

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

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

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

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

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

◆ levelTop()

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

inline

Definition at line 113 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::levelT_.

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

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

HGCalParameters::levelT_

std::vector< int > levelT_

Definition: HGCalParameters.h:148

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

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

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

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

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

◆ locateCell() [1/4]

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

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

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

           {
   double x(0), y(0);
   int indx = HGCalWaferIndex::waferIndex(lay, waferU, waferV);
   auto itr = hgpar_->typesInLayers_.find(indx);
   int type = ((itr == hgpar_->typesInLayers_.end()) ? 2 : hgpar_->waferTypeL_[itr->second]);
   int layertype = layerType(lay);
   bool rotx = (norot) ? false : (layertype == HGCalTypes::WaferCenterR);
   if (debug) {
     edm::LogVerbatim("HGCalGeom") << "LocateCell " << lay << ":" << (lay - hgpar_->firstLayer_) << ":" << layertype
                                   << ":" << rotx << ":" << waferU << ":" << waferV << ":" << indx << ":"
                                   << (itr == hgpar_->typesInLayers_.end()) << ":" << type << " Flags " << reco << ":"
                                   << all;
   }
   auto ktr = hgpar_->waferInfoMap_.end();
   int place(HGCalCell::cellPlacementOld);
   if (waferHexagon8File()) {
     if (cassetteMode()) {
       ktr = hgpar_->waferInfoMap_.find(indx);
       if (ktr != hgpar_->waferInfoMap_.end())
         place = HGCalCell::cellPlacementIndex(1, HGCalTypes::layerFrontBack(layertype), (ktr->second).orient);
     }
     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 (cassetteMode() && (ktr != hgpar_->waferInfoMap_.end())) {
       auto cshift = hgcassette_.getShift(lay, -1, (ktr->second).cassette);
       std::ostringstream st1;
       if (debug)
         st1 << "Cassette " << (ktr->second).cassette << " Shift " << cshift.first << ":" << cshift.second
             << " Original " << x << ":" << y;
       if (!reco) {
         x -= ((HGCalParameters::k_ScaleToDDD)*cshift.first);
         y += ((HGCalParameters::k_ScaleToDDD)*cshift.second);
       } else {
         x -= cshift.first;
         y += cshift.second;
       }
       if (debug) {
         st1 << " Final " << x << ":" << y;
         edm::LogVerbatim("HGCalGeom") << st1.str();
       }
     }
     if (debug)
       edm::LogVerbatim("HGCalGeom") << "With wafer " << x << ":" << y << " by adding " << xy.first << ":" << xy.second;
   }
   return (rotx ? getXY(lay, x, y, false) : std::make_pair(x, y));
 }

◆ locateCell() [3/4]

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

Definition at line 900 of file HGCalDDDConstants.cc.

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

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

◆ locateCell() [4/4]

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

Definition at line 904 of file HGCalDDDConstants.cc.

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

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

◆ locateCellHex()

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

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

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

Referenced by HGCalSimHitValidation::analyzeHits(), 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 (!trapezoidFile())
       r = std::max(range.first, std::min(r, range.second));
     x = r * std::cos(phi);
     y = r * std::sin(phi);
     int ll = lay - hgpar_->firstLayer_;
     x += hgpar_->xLayerHex_[ll];
     y += hgpar_->yLayerHex_[ll];
     if (irad < 0)
       x = -x;
     if (cassetteMode()) {
       int cassette = HGCalTileIndex::tileCassette(iphi, hgpar_->phiOffset_, hgpar_->nphiCassette_, hgpar_->cassettes_);
       auto cshift = hgcassette_.getShift(lay, -1, cassette);
       std::ostringstream st1;
       if (debug)
         st1 << "Cassette " << cassette << " Shift " << cshift.first << ":" << cshift.second << " Original " << x << ":"
             << y;
       x -= cshift.first;
       y += cshift.second;
       if (debug) {
         st1 << " Final " << x << ":" << y;
         edm::LogVerbatim("HGCalGeom") << st1.str();
       }
     }
   }
   if (!reco) {
     x *= HGCalParameters::k_ScaleToDDD;
     y *= HGCalParameters::k_ScaleToDDD;
   }
   return std::make_pair(x, y);
 }

◆ maskCell()

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

Definition at line 972 of file HGCalDDDConstants.cc.

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

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

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

◆ maxCells() [1/2]

int HGCalDDDConstants::maxCells ( bool reco ) const

Definition at line 1017 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 1027 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 115 of file HGCalDDDConstants.h.

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

Referenced by HGCalTopology::HGCalTopology().

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

HGCalDDDConstants::tileTrapezoid

bool tileTrapezoid() const

Definition: HGCalDDDConstants.h:144

HGCalParameters::nCellsFine_

int nCellsFine_

Definition: HGCalParameters.h:151

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

◆ maxModules()

int HGCalDDDConstants::maxModules ( ) const

inline

Definition at line 118 of file HGCalDDDConstants.h.

References modHalf_.

118 { return modHalf_; }

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:265

◆ maxModulesPerLayer()

int HGCalDDDConstants::maxModulesPerLayer ( ) const

inline

Definition at line 119 of file HGCalDDDConstants.h.

References maxWafersPerLayer_.

119 { return maxWafersPerLayer_; }

HGCalDDDConstants::maxWafersPerLayer_

int32_t maxWafersPerLayer_

Definition: HGCalDDDConstants.h:268

◆ maxRows()

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

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

References hgpar_, and HGCalParameters::slopeMin_.

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

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

HGCalParameters::slopeMin_

std::vector< double > slopeMin_

Definition: HGCalParameters.h:82

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

◆ modifyUV()

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

Definition at line 1082 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 1087 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 1094 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 1110 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 1114 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 1129 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 1162 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 1173 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 1184 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 1211 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 1229 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 1242 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 134 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::nSectors_.

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

134 { return hgpar_->nSectors_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:76

◆ sensorSizeOffset()

double HGCalDDDConstants::sensorSizeOffset ( bool reco ) const

Definition at line 1253 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSD::update().

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

◆ simToReco()

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

Definition at line 1257 of file HGCalDDDConstants.cc.

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

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

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

Referenced by numberCells().

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

◆ tileExist()

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

Definition at line 1327 of file HGCalDDDConstants.cc.

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

Referenced by assignCellTrap(), 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 1334 of file HGCalDDDConstants.cc.

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

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

◆ tilePhiEdge()

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

Definition at line 1340 of file HGCalDDDConstants.cc.

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

Referenced by assignCellTrap().

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

◆ tileRingEdge()

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

Definition at line 1350 of file HGCalDDDConstants.cc.

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

Referenced by assignCellTrap().

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

◆ tileRings()

std::pair< int, int > HGCalDDDConstants::tileRings ( int layer ) const

Definition at line 1360 of file HGCalDDDConstants.cc.

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

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

◆ tileSiPM()

int HGCalDDDConstants::tileSiPM ( int sipm ) const

inline

Definition at line 143 of file HGCalDDDConstants.h.

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

Referenced by HGCalNumberingScheme::getUnitID().

143 { 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 144 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 1369 of file HGCalDDDConstants.cc.

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

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

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

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

◆ volumes()

unsigned int HGCalDDDConstants::volumes ( ) const

inline

Definition at line 153 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::moduleLayR_.

Referenced by HGCalGeometryLoader::build().

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:96

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

◆ waferCount()

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 186 of file HGCalDDDConstants.h.

References waferMax_.

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

type

Definition: SiPixelVCal_PayloadInspector.cc:39

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:270

◆ waferFileIndex()

int HGCalDDDConstants::waferFileIndex ( unsigned int kk ) const

Definition at line 1629 of file HGCalDDDConstants.cc.

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

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

◆ waferFileInfo()

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

Definition at line 1638 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSD::setDetUnitId().

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

◆ waferFileInfoExist()

bool HGCalDDDConstants::waferFileInfoExist ( int kk ) const

inline

Definition at line 197 of file HGCalDDDConstants.h.

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

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

◆ waferFileInfoFromIndex()

std::tuple< int, int, int, int > HGCalDDDConstants::waferFileInfoFromIndex ( int kk ) const

Definition at line 1647 of file HGCalDDDConstants.cc.

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

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

◆ waferFileSize()

unsigned int HGCalDDDConstants::waferFileSize ( ) const

inline

Definition at line 193 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferInfoMap_.

Referenced by waferType(), and waferTypeRotation().

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

HGCalParameters::waferInfoMap_

waferInfo_map waferInfoMap_

Definition: HGCalParameters.h:190

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

◆ waferFromCopy()

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 1380 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 1405 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 1447 of file HGCalDDDConstants.cc.

References funct::abs(), cassetteMode(), 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(), hexside_, hexsideT_, HGCSiliconDetId::HGCalCoarseThick, hgcassette_, hgpar_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, nano_mu_digi_cff::layer, HGCalTypes::layerFrontBack(), layerType(), HGCalParameters::layerType_, 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];
   }
   if (debug)
     edm::LogVerbatim("HGCalGeom") << "waferFromPosition:: Layer " << layer << ":" << ll << " Rot " << rotx << " X " << x
                                   << ":" << xx << " Y " << y << ":" << yy << " side " << zside << " extend " << extend;
   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 (cassetteMode()) {
       int indx = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
       auto ktr = hgpar_->waferInfoMap_.find(indx);
       if (ktr != hgpar_->waferInfoMap_.end()) {
         auto cshift = hgcassette_.getShift(layer, -1, (ktr->second).cassette);
         if (debug)
           edm::LogVerbatim("HGCalGeom") << "Cassette " << (ktr->second).cassette << " Shift " << cshift.first << ":"
                                         << cshift.second;
         dx0 = -cshift.first;
         dy0 = cshift.second;
       }
     }
     double dx = std::abs(xx - dx0 - hgpar_->waferPosX_[k]);
     double dy = std::abs(yy - dy0 - hgpar_->waferPosY_[k]);
     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_);
           if (debug)
             edm::LogVerbatim("HGCalGeom") << "Position (" << x << ", " << y << ") Wafer type:partial:orient:cassette "
                                           << celltype << ":" << HGCalWaferType::getPartial(index, hgpar_->waferInfoMap_)
                                           << ":" << HGCalWaferType::getOrient(index, hgpar_->waferInfoMap_) << ":"
                                           << HGCalWaferType::getCassette(index, hgpar_->waferInfoMap_);
         } else {
           auto itr = hgpar_->typesInLayers_.find(HGCalWaferIndex::waferIndex(layer, waferU, waferV));
           celltype = ((itr == hgpar_->typesInLayers_.end()) ? HGCSiliconDetId::HGCalCoarseThick
                                                             : hgpar_->waferTypeL_[itr->second]);
         }
         if (debug)
           edm::LogVerbatim("HGCalGeom") << "WaferFromPosition:: Input " << layer << ":" << ll << ":"
                                         << hgpar_->firstLayer_ << ":" << rotx << ":" << x << ":" << y << ":"
                                         << hgpar_->xLayerHex_[ll] << ":" << hgpar_->yLayerHex_[ll] << ":" << xx << ":"
                                         << yy << " compared with " << hgpar_->waferPosX_[k] << ":"
                                         << hgpar_->waferPosY_[k] << " difference " << dx << ":" << dy << ":"
                                         << dx * tan30deg_ << ":" << (hexside_ - dy) << " comparator " << rmax_ << ":"
                                         << rmaxT_ << ":" << hexside_ << ":" << hexsideT_ << " wafer " << waferU << ":"
                                         << waferV << ":" << celltype;
         xx -= (dx0 + hgpar_->waferPosX_[k]);
         yy -= (dy0 + hgpar_->waferPosY_[k]);
         break;
       }
     }
   }
   if ((std::abs(waferU) <= hgpar_->waferUVMax_) && (celltype >= 0)) {
     int place(HGCalCell::cellPlacementOld), part(HGCalTypes::WaferFull);
     if (cassetteMode()) {
       int indx = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
       auto ktr = hgpar_->waferInfoMap_.find(indx);
       if (ktr != hgpar_->waferInfoMap_.end()) {
         place = HGCalCell::cellPlacementIndex(1, HGCalTypes::layerFrontBack(layertype), (ktr->second).orient);
         part = (ktr->second).part;
         if (debug)
           edm::LogVerbatim("HGCalGeom") << "waferFromPosition: frontback " << layertype << ":"
                                         << HGCalTypes::layerFrontBack(layertype) << " Orient " << (ktr->second).orient
                                         << " place " << place << " part " << part;
       }
     }
     cellHex(xx, yy, celltype, place, part, cellU, cellV, extend, debug);
     wt = (((celltype < 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 1577 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 168 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 171 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8CalibCell, 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) || (mode_ == HGCalGeometryMode::Hexagon8CalibCell));
   }

◆ waferHexagon8File()

bool HGCalDDDConstants::waferHexagon8File ( ) const

inline

Definition at line 176 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8CalibCell, 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) || (mode_ == HGCalGeometryMode::Hexagon8CalibCell));
   }

◆ waferHexagon8Module()

bool HGCalDDDConstants::waferHexagon8Module ( ) const

inline

Definition at line 180 of file HGCalDDDConstants.h.

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

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

◆ waferIndex()

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

private

Definition at line 2059 of file HGCalDDDConstants.cc.

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

Referenced by waferInLayerTest().

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

◆ waferInfo()

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

Definition at line 1584 of file HGCalDDDConstants.cc.

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

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

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

◆ waferInLayer()

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

Definition at line 1570 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 2071 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 1655 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 188 of file HGCalDDDConstants.h.

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

188 { return waferMax_[1]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:270

◆ waferMin()

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 189 of file HGCalDDDConstants.h.

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

189 { return waferMax_[0]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:270

◆ waferParameters()

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

Definition at line 1590 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 1597 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 1610 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 2123 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 2099 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 1670 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 1683 of file HGCalDDDConstants.cc.

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

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

◆ waferSepar()

double HGCalDDDConstants::waferSepar ( bool reco ) const

inline

Definition at line 202 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 205 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 210 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 1698 of file HGCalDDDConstants.cc.

References DetId::Forward, hgpar_, nano_mu_digi_cff::layer, HFNoseDetId::layer(), HGCSiliconDetId::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 1726 of file HGCalDDDConstants.cc.

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

                                                                                        {
   int type(HGCSiliconDetId::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 1745 of file HGCalDDDConstants.cc.

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

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

◆ waferTypeL()

int HGCalDDDConstants::waferTypeL ( int wafer ) const

inline

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

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

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

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

◆ waferTypeT()

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

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

References hgpar_, and HGCalParameters::waferUVMax_.

Referenced by HGCalTopology::HGCalTopology().

227 { return hgpar_->waferUVMax_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:257

HGCalParameters::waferUVMax_

int waferUVMax_

Definition: HGCalParameters.h:160

◆ waferVirtual()

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

Definition at line 1831 of file HGCalDDDConstants.cc.

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

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

◆ waferZ()

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

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

◆ fullAndPart_

const bool HGCalDDDConstants::fullAndPart_

private

Definition at line 262 of file HGCalDDDConstants.h.

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

◆ geomTools_

HGCalGeomTools HGCalDDDConstants::geomTools_

private

Definition at line 252 of file HGCalDDDConstants.h.

◆ hexside_

double HGCalDDDConstants::hexside_

private

Definition at line 263 of file HGCalDDDConstants.h.

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

◆ hexsideT_

double HGCalDDDConstants::hexsideT_

private

Definition at line 264 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and waferFromPosition().

◆ hgcassette_

HGCalCassette HGCalDDDConstants::hgcassette_

private

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

Referenced by HGCalDDDConstants(), and locateCell().

◆ hgcellUV_

std::unique_ptr<HGCalCellUV> HGCalDDDConstants::hgcellUV_

private

Definition at line 251 of file HGCalDDDConstants.h.

Referenced by cellHex(), and HGCalDDDConstants().

◆ hgpar_

const HGCalParameters* HGCalDDDConstants::hgpar_

private

Definition at line 257 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(), guardRingOffset(), HGCalDDDConstants(), isHalfCell(), isValidCell(), isValidCell8(), isValidHex(), isValidHex8(), isValidTrap(), lastLayer(), layerFromIndex(), layerIndex(), layersInit(), layerType(), levelTop(), localToGlobal8(), locateCell(), locateCellHex(), locateCellTrap(), maskCell(), maxCells(), maxCellUV(), maxRows(), minSlope(), modulesInit(), mouseBite(), numberCells(), numberCellsHexagon(), rangeR(), rangeRLayer(), rangeZ(), rowColumnWafer(), sectors(), sensorSizeOffset(), simToReco(), tileCount(), tileExist(), tileInfo(), tilePhiEdge(), tileRingEdge(), tileRings(), tileType(), volumes(), waferFileIndex(), waferFileInfo(), waferFileInfoExist(), waferFileInfoFromIndex(), waferFileSize(), waferFromCopy(), waferFromPosition(), waferIndex(), waferInfo(), waferInLayer(), waferInLayerTest(), waferPosition(), waferPositionNoRot(), wafers(), waferSepar(), waferSize(), waferToCopy(), waferType(), waferTypeL(), waferTypeRotation(), waferTypeT(), waferUVMax(), waferVirtual(), and waferZ().

◆ k_horizontalShift

constexpr double HGCalDDDConstants::k_horizontalShift = 1.0

staticprivate

Definition at line 253 of file HGCalDDDConstants.h.

◆ max_modules_layer_

Simrecovecs HGCalDDDConstants::max_modules_layer_

private

Definition at line 267 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and modules().

◆ maxWafersPerLayer_

int32_t HGCalDDDConstants::maxWafersPerLayer_

private

Definition at line 268 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModulesPerLayer().

◆ mode_

const HGCalGeometryMode::GeometryMode HGCalDDDConstants::mode_

private

Definition at line 261 of file HGCalDDDConstants.h.

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

◆ modHalf_

int32_t HGCalDDDConstants::modHalf_

private

Definition at line 265 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModules().

◆ rmax_

double HGCalDDDConstants::rmax_

private

Definition at line 263 of file HGCalDDDConstants.h.

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

◆ rmaxT_

double HGCalDDDConstants::rmaxT_

private

Definition at line 264 of file HGCalDDDConstants.h.

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

◆ sqrt3_

const double HGCalDDDConstants::sqrt3_

private

Definition at line 260 of file HGCalDDDConstants.h.

Referenced by cellHex(), and distFromEdgeHex().

◆ tan30deg_

constexpr double HGCalDDDConstants::tan30deg_ = 0.5773502693

staticprivate

Definition at line 258 of file HGCalDDDConstants.h.

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

◆ tol_

constexpr double HGCalDDDConstants::tol_ = 0.001

staticprivate

Definition at line 259 of file HGCalDDDConstants.h.

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

◆ tot_layers_

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

private

Definition at line 266 of file HGCalDDDConstants.h.

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

◆ tot_wafers_

int32_t HGCalDDDConstants::tot_wafers_

private

Definition at line 265 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants().

◆ waferIn_

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

private

Definition at line 271 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and isValidHex8().

◆ waferLayer_

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

private

Definition at line 269 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and wafers().

◆ waferMax_

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

private

Definition at line 270 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()

◆ cassetteMode()

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

◆ guardRingOffset()

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