#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 lay, bool reco, bool extend=false, bool debug=false) const

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

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

bool	cellInLayer (int waferU, int waferV, int cellU, int cellV, int lay, 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< int, int >	getREtaRange (int lay) const

HGCalParameters::hgtrform	getTrForm (unsigned int k) const

unsigned int	getTrFormN () const

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

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

int	getTypeTrap (int layer) const

int	getUVMax (int type) const

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

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

bool	isHalfCell (int waferType, int cell) const

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

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

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

bool	isValidTrap (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	levelTop (int ind=0) const

std::pair< float, float >	localToGlobal8 (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 lay, int waferU, int waferV, int cellU, int cellV, bool reco, bool all, bool norot=false, bool debug=false) const

std::pair< float, float >	locateCell (const HGCSiliconDetId &, bool debug=false) const

std::pair< float, float >	locateCell (const HGCScintillatorDetId &, bool debug=false) const

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

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

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

int	maxCells (bool reco) const

int	maxCells (int lay, bool reco) const

int	maxCellUV () const

int	maxModules () const

int	maxModulesPerLayer () const

int	maxRows (int lay, bool reco) const

double	minSlope () const

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

int	modules (int lay, bool reco) const

int	modulesInit (int lay, bool reco) const

double	mouseBite (bool reco) const

int	numberCells (bool reco) const

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

int	numberCellsHexagon (int wafer) const

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

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

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

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

std::pair< int, int >	rowColumnWafer (const int wafer) const

int	sectors () const

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

int	tileCount (int layer, int ring) const

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

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

unsigned int	volumes () const

int	waferCount (const int type) const

int	waferFileIndex (unsigned int kk) const

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

bool	waferFileInfoExist (int kk) const

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

unsigned int	waferFileSize () const

int	waferFromCopy (int copy) const

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

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

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

bool	waferHexagon6 () const

bool	waferHexagon8 () 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=false) 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=false) const

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

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

int	waferTypeL (int wafer) const

std::pair< int, int >	waferTypeRotation (int layer, int waferU, int waferV, bool fromFile=false, bool debug=false) 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 ()

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 &cellU, int &cellV, bool extend=false, bool debug=false) 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=false) const

Private Attributes
const float	dPhiMin = 0.02

const bool	fullAndPart_

HGCalGeomTools	geomTools_

double	hexside_

double	hexsideT_

const HGCalParameters *	hgpar_

const double	k_horizontalShift = 1.0

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 double	tan30deg_ = 0.5773502693

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

Member Typedef Documentation

◆ HGCWaferParam

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

private

Definition at line 273 of file HGCalDDDConstants.h.

◆ Simrecovecs

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

private

Definition at line 272 of file HGCalDDDConstants.h.

Constructor & Destructor Documentation

◆ HGCalDDDConstants()

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

Definition at line 28 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, funct::cos(), fullAndPart_, getIndex(), getTrForm(), getTrFormN(), hexside_, hexsideT_, hgpar_, mps_fire::i, HGCalParameters::k_ScaleFromDDD, HGCalParameters::hgtrform::lay, phase1PixelTopology::layer, layers(), layersInit(), SiStripPI::max, max_modules_layer_, maxCells(), maxWafersPerLayer_, mode_, modHalf_, modulesInit(), Skims_PA_cff::name, rmax_, rmaxT_, sectors(), HGCalParameters::sensorSeparation_, 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_(((mode_ == HGCalGeometryMode::Hexagon8File) || (mode_ == HGCalGeometryMode::Hexagon8Module))) {
 #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_;
 #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
   }
   // 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 ( )

Definition at line 124 of file HGCalDDDConstants.cc.

124 {}

Member Function Documentation

◆ assignCell()

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

Definition at line 126 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 >= (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	lay,
		bool	reco,
		bool	extend = `false`,
		bool	debug = `false`
	)		const

Definition at line 165 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, and geometryCSVtoXML::yy.

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, 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 180 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, createfilelist::int, LEDCalibrationChannels::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, phase1PixelTopology::layer, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, M_PI, phi, alignCSCRings::r, HGCalParameters::radiusLayer_, HGCalParameters::scintType(), mathSSE::sqrt(), x, geometryCSVtoXML::xx, y, and z.

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}};
   double xx = (z > 0) ? x : -x;
   double r = (reco ? std::sqrt(x * x + y * y) : 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);
   type = hgpar_->scintType(layer);
   auto ir = std::lower_bound(hgpar_->radiusLayer_[type].begin(), hgpar_->radiusLayer_[type].end(), r);
   irad = (int)(ir - hgpar_->radiusLayer_[type].begin());
   irad = std::clamp(irad, hgpar_->iradMinBH_[indx.first], hgpar_->iradMaxBH_[indx.first]);
   iphi = 1 + (int)(phi / indx.second);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "assignCellTrap Input " << x << ":" << y << ":" << z << ":" << layer << ":" << reco
                                 << " x|r " << xx << ":" << r << " phi " << phi << " o/p " << irad << ":" << iphi << ":"
                                 << type;
 #endif
   return std::array<int, 3>{{irad, iphi, type}};
 }

◆ cellEtaPhiTrap()

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

Definition at line 203 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, hgcalPerformanceValidation::df, flavorHistoryFilter_cfi::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 1502 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 &	cellU,
		int &	cellV,
		bool	extend = `false`,
		bool	debug = `false`
	)		const

private

Definition at line 1521 of file HGCalDDDConstants.cc.

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

                                                                                                    {
   int N = (cellType == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_;
   double Rc = 2 * rmax_ / (3 * N);
   double rc = 0.5 * Rc * sqrt3_;
   double RcT = (extend) ? (2 * rmaxT_ / (3 * N)) : Rc;
   double rcT = 0.5 * RcT * sqrt3_;
   double v0 = ((xloc / Rc - 1.0) / 1.5);
   int cv0 = (v0 > 0) ? (N + (int)(v0 + 0.5)) : (N - (int)(-v0 + 0.5));
   double u0 = (0.5 * yloc / rc + 0.5 * cv0);
   int cu0 = (u0 > 0) ? (N / 2 + (int)(u0 + 0.5)) : (N / 2 - (int)(-u0 + 0.5));
   cu0 = std::max(0, std::min(cu0, 2 * N - 1));
   cv0 = std::max(0, std::min(cv0, 2 * N - 1));
   if (cv0 - cu0 >= N)
     cv0 = cu0 + N - 1;
 #ifdef EDM_ML_DEBUG
   if (debug)
     edm::LogVerbatim("HGCalGeom") << "cellHex: input " << xloc << ":" << yloc << ":" << cellType << " parameter " << rc
                                   << ":" << Rc << " u0 " << u0 << ":" << cu0 << " v0 " << v0 << ":" << cv0;
 #endif
   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) < N) && ((cellU - cellV) <= N) && (cellU >= 0) && (cellV >= 0) && (cellU < 2 * N) &&
           (cellV < 2 * N)) {
         double xc = (1.5 * (cellV - N) + 1.0) * Rc;
         double yc = (2 * cellU - cellV - N) * rc;
         if ((std::abs(yloc - yc) <= rcT) && (std::abs(xloc - xc) <= RcT) &&
             ((std::abs(xloc - xc) <= 0.5 * RcT) || (std::abs(yloc - yc) <= sqrt3_ * (RcT - std::abs(xloc - xc))))) {
 #ifdef EDM_ML_DEBUG
           if (debug)
             edm::LogVerbatim("HGCalGeom")
                 << "cellHex: local " << xc << ":" << yc << " difference " << std::abs(xloc - xc) << ":"
                 << std::abs(yloc - yc) << ":" << sqrt3_ * (Rc - std::abs(yloc - yc)) << " comparator " << rc << ":"
                 << Rc << " (u,v) = (" << cellU << "," << cellV << ")";
 #endif
           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,
		bool	reco
	)		const

Definition at line 213 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, locateCell(), HGCalParameters::rMinLayHex_, mathSSE::sqrt(), waferHexagon6(), waferHexagon8(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), and geometryCSVtoXML::xy.

Referenced by HGCalGeometry::newCell().

                                                                                                           {
   const auto& indx = getIndex(lay, true);
   if (indx.first >= 0) {
     if (waferHexagon8() || waferHexagon6()) {
       const auto& xy = ((waferHexagon8()) ? locateCell(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 242 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 40 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 229 of file HGCalDDDConstants.cc.

References HGCalParameters::cellThickness_, hgpar_, phase1PixelTopology::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 249 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 256 of file HGCalDDDConstants.cc.

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

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

                                                                             {
   // Assming the point is within a hexagonal plane of the wafer, calculate
   // the shortest distance from the edge
   if (z < 0)
     x = -x;
   double dist(0);
   // Input x, y in Geant4 unit and transformed to CMSSW standard
   double xx = HGCalParameters::k_ScaleFromDDD * x;
   double yy = HGCalParameters::k_ScaleFromDDD * y;
   if (waferHexagon8()) {
     int ll = layerIndex(getLayer(z, false), false);
     xx -= hgpar_->xLayerHex_[ll];
     yy -= hgpar_->yLayerHex_[ll];
   }
   int sizew = (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 302 of file HGCalDDDConstants.cc.

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

Referenced by HGCScintSD::isItinFidVolume().

                                                                              {
   // Assming the point is within the eta-phi plane of the scintillator tile,
   // calculate the shortest distance from the edge
   int lay = getLayer(z, false);
   double xx = (z < 0) ? -x : x;
   int indx = layerIndex(lay, false);
   double r = HGCalParameters::k_ScaleFromDDD * std::sqrt(x * x + y * y);
   double phi = (r == 0. ? 0. : std::atan2(y, xx));
   if (phi < 0)
     phi += (2.0 * M_PI);
   int type = hgpar_->scintType(lay);
   double cell = hgpar_->scintCellSize(lay);
   // Compare with the center of the tile find distances along R and also phi
   // Take the smaller value
   auto ir = std::lower_bound(hgpar_->radiusLayer_[type].begin(), hgpar_->radiusLayer_[type].end(), r);
   int irad = (int)(ir - hgpar_->radiusLayer_[type].begin());
   irad = std::clamp(irad, hgpar_->iradMinBH_[indx], hgpar_->iradMaxBH_[indx]);
   int iphi = 1 + (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 55 of file HGCalDDDConstants.h.

References HGCalParameters::firstLayer_, and hgpar_.

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

55 { return hgpar_->firstLayer_; }

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:173

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ geomMode()

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

Definition at line 56 of file HGCalDDDConstants.h.

References mode_.

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

56 { return mode_; }

HGCalDDDConstants::mode_

const HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:277

◆ getIndex()

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

private

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

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

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

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

◆ getLayerOffset()

int HGCalDDDConstants::getLayerOffset ( ) const

inline

Definition at line 58 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::layerOffset_.

Referenced by HGCalNumberingScheme::getUnitID().

58 { return hgpar_->layerOffset_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

HGCalParameters::layerOffset_

int layerOffset_

Definition: HGCalParameters.h:175

◆ getModule()

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

Definition at line 352 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 368 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 61 of file HGCalDDDConstants.h.

References hgpar_.

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

61 { return hgpar_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ getPhiBins()

int HGCalDDDConstants::getPhiBins ( int lay ) const

Definition at line 375 of file HGCalDDDConstants.cc.

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

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

HGCalDDDConstants::tileTrapezoid

bool tileTrapezoid() const

Definition: HGCalDDDConstants.h:139

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

HGCalParameters::scintCells

int scintCells(const int layer) const

Definition: HGCalParameters.h:66

◆ getRadiusLayer()

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

inline

Definition at line 64 of file HGCalDDDConstants.h.

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

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

◆ getREtaRange()

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

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

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

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

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

HGCalParameters::getTrForm

hgtrform getTrForm(unsigned int k) const

Definition: HGCalParameters.cc:108

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

dqmdumpme.k

k

Definition: dqmdumpme.py:60

◆ getTrFormN()

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 69 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::trformIndex_.

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:90

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ getTrForms()

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

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

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

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

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

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

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

type

Definition: SiPixelVCal_PayloadInspector.cc:39

HGCalParameters::nCellsCoarse_

int nCellsCoarse_

Definition: HGCalParameters.h:143

HGCalParameters::nCellsFine_

int nCellsFine_

Definition: HGCalParameters.h:142

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ getXY()

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

Definition at line 415 of file HGCalDDDConstants.cc.

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

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

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

◆ isHalfCell()

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

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

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, HGCSiliconDetId::HGCalFine, hgpar_, createfilelist::int, 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 < (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 1635 of file HGCalDDDConstants.cc.

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

Referenced by isValidHex8().

                                                                                                           {
   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_;
   bool result = ((rr >= 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;
 #endif
   if (result && ((mode_ == HGCalGeometryMode::Hexagon8File) || (mode_ == HGCalGeometryMode::Hexagon8Module))) {
     int N = (type == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_;
     auto partn = waferTypeRotation(lay, waferU, waferV, false, false);
     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;
 #endif
   }
   return result;
 }

◆ isValidHex()

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

Definition at line 450 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::copiesInLayers_, HGCSiliconDetId::HGCalFine, hgpar_, createfilelist::int, 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 <= (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 >= (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) ? (int)(hgpar_->cellFineX_.size())
                                                                                   : (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 <= (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 = `false`
	)		const

Definition at line 492 of file HGCalDDDConstants.cc.

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

Referenced by HGCalTopology::addHGCSiliconId(), isValidHex8(), 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())
     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())
       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))
       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)
           return false;
       } else {
         if (ktr->second.first < HGCalTypes::WaferCornerMin)
           return false;
       }
     }
   }
   return true;
 }

◆ isValidHex8() [2/2]

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

Definition at line 535 of file HGCalDDDConstants.cc.

References hgpar_, isValidCell8(), isValidHex8(), phase1PixelTopology::layer, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::typesInLayers_, HGCalWaferIndex::waferIndex(), and HGCalParameters::waferTypeL_.

                                                                                                                {
   // First check validity for a layer|wafer| of post TDR version
   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))
     return false;
   if (((cellV - cellU) >= N) || ((cellU - cellV) > N))
     return false;
 
   return isValidCell8(layer, modU, modV, cellU, cellV, type);
 }

◆ isValidTrap()

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

Definition at line 556 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, LEDCalibrationChannels::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, and phase1PixelTopology::layer.

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

                                                                        {
   // Check validity for a layer|eta|phi of scintillator
   const auto& indx = getIndex(layer, true);
   if (indx.first < 0)
     return false;
   return ((irad >= hgpar_->iradMinBH_[indx.first]) && (irad <= (hgpar_->iradMaxBH_[indx.first] + 1)) && (iphi > 0) &&
           (iphi <= hgpar_->scintCells(layer)));
 }

◆ lastLayer()

int HGCalDDDConstants::lastLayer ( bool reco ) const

Definition at line 565 of file HGCalDDDConstants.cc.

References HGCalParameters::firstLayer_, hgpar_, and tot_layers_.

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

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

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:173

reco

fixed size matrix

Definition: AlignmentAlgorithmBase.h:46

HGCalDDDConstants::tot_layers_

std::array< uint32_t, 2 > tot_layers_

Definition: HGCalDDDConstants.h:282

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ layerFromIndex()

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

private

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

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

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

                                                           {
   int ll = lay - hgpar_->firstLayer_;
   if (ll < 0 || ll >= (int)(hgpar_->layerIndex_.size()))
     return -1;
   if (waferHexagon6()) {
     if (reco && ll >= (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 567 of file HGCalDDDConstants.cc.

References createfilelist::int, and tot_layers_.

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

567 { return tot_layers_[(int)reco]; }

createfilelist.int

int

Definition: createfilelist.py:10

reco

fixed size matrix

Definition: AlignmentAlgorithmBase.h:46

HGCalDDDConstants::tot_layers_

std::array< uint32_t, 2 > tot_layers_

Definition: HGCalDDDConstants.h:282

◆ layersInit()

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

Definition at line 582 of file HGCalDDDConstants.cc.

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

Referenced by HGCalDDDConstants().

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

◆ levelTop()

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

inline

Definition at line 100 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::levelT_.

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

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

HGCalParameters::levelT_

std::vector< int > levelT_

Definition: HGCalParameters.h:135

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ localToGlobal8()

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

Definition at line 586 of file HGCalDDDConstants.cc.

References debug, HGCalParameters::firstLayer_, getXY(), hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::layerType_, phase1PixelTopology::localX(), pixelTopology::localY(), HGCalTypes::WaferCenterR, waferPositionNoRot(), HGCalWaferIndex::waferU(), HGCalWaferIndex::waferV(), x, geometryCSVtoXML::xy, and y.

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;
   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 606 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(), and HGCalGeometry::getPosition().

                                                                                                 {
   // 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	lay,
		int	waferU,
		int	waferV,
		int	cellU,
		int	cellV,
		bool	reco,
		bool	all,
		bool	norot = `false`,
		bool	debug = `false`
	)		const

Definition at line 637 of file HGCalDDDConstants.cc.

References python.cmstools::all(), HGCalParameters::cellCoarseIndex_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineIndex_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, debug, HGCalParameters::firstLayer_, getXY(), hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::layerType_, HGCalParameters::typesInLayers_, HGCalTypes::WaferCenterR, HGCalWaferIndex::waferIndex(), 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]);
   bool rotx = (norot) ? false
                       : ((!hgpar_->layerType_.empty()) &&
                          (hgpar_->layerType_[lay - hgpar_->firstLayer_] == HGCalTypes::WaferCenterR));
   if (debug) {
     edm::LogVerbatim("HGCalGeom") << "LocateCell " << lay << ":" << (lay - hgpar_->firstLayer_) << ":" << rotx << ":"
                                   << waferU << ":" << waferV << ":" << indx << ":"
                                   << (itr == hgpar_->typesInLayers_.end()) << ":" << type << " Flags " << reco << ":"
                                   << all;
   }
   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];
     }
     if (debug)
       edm::LogVerbatim("HGCalGeom") << "Fine " << cellU << ":" << cellV << ":" << kndx << ":" << x << ":" << y << ":"
                                     << (ktr != hgpar_->cellFineIndex_.end());
   } else {
     auto ktr = hgpar_->cellCoarseIndex_.find(kndx);
     if (ktr != hgpar_->cellCoarseIndex_.end()) {
       x = hgpar_->cellCoarseX_[ktr->second];
       y = hgpar_->cellCoarseY_[ktr->second];
     }
     if (debug)
       edm::LogVerbatim("HGCalGeom") << "Coarse " << cellU << ":" << cellV << ":" << kndx << ":" << x << ":" << y << ":"
                                     << (ktr != 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 (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 = `false`
	)		const

Definition at line 686 of file HGCalDDDConstants.cc.

References debug, geomTools_, getXY(), hgpar_, phase1PixelTopology::layer, HGCalParameters::layerCenter_, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, dttmaxenums::R, alignCSCRings::r, diffTwoXMLs::r1, HGCalParameters::sensorSeparation_, HGCalGeomTools::shiftXY(), sqrt3_, HGCalParameters::waferSize_, and geometryCSVtoXML::xy.

                                                                                                {
   int lay(id.layer());
   double r = 0.5 * (hgpar_->waferSize_ + hgpar_->sensorSeparation_);
   double R = 2.0 * r / sqrt3_;
   int ncells = (id.type() == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_;
   int n2 = ncells / 2;
   auto xyoff = geomTools_.shiftXY(hgpar_->layerCenter_[lay - 1], (2.0 * r));
   double xpos = xyoff.first + ((-2 * id.waferU() + id.waferV()) * r);
   double ypos = xyoff.second + (1.5 * id.waferV() * R);
 #ifdef EDM_ML_DEBUG
   if (debug)
     edm::LogVerbatim("HGCalGeom") << "LocateCell " << id << " Lay " << lay << " r:R " << r << ":" << R << " N "
                                   << ncells << ":" << n2 << " Off " << xyoff.first << ":" << xyoff.second << " Pos "
                                   << xpos << ":" << ypos;
 #endif
   double R1 = hgpar_->waferSize_ / (3.0 * ncells);
   double r1 = 0.5 * R1 * sqrt3_;
   xpos += ((1.5 * (id.cellV() - ncells) + 1.0) * R1);
   ypos += ((id.cellU() - 0.5 * id.cellV() - n2) * 2 * r1);
 #ifdef EDM_ML_DEBUG
   if (debug)
     edm::LogVerbatim("HGCalGeom") << "LocateCell r1:R1 " << r1 << ":" << R1 << " dx:dy "
                                   << ((1.5 * (id.cellV() - ncells) + 1.0) * R1) << ":"
                                   << ((id.cellU() - 0.5 * id.cellV() - n2) * 2 * r1) << " Pos " << xpos << ":" << ypos;
 #endif
   std::pair<double, double> xy = getXY(id.layer(), xpos, ypos, true);
   return std::make_pair(xy.first * id.zside(), xy.second);
 }

◆ locateCell() [4/4]

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

Definition at line 715 of file HGCalDDDConstants.cc.

References angle_units::operators::convertRadToDeg(), funct::cos(), debug, hgpar_, LEDCalibrationChannels::iphi, phase1PixelTopology::layer, phi, alignCSCRings::r, HGCalParameters::radiusLayer_, HGCalParameters::scintCellSize(), funct::sin(), and ecaldqm::zside().

                                                                                                     {
   int lay(id.layer()), iphi(id.iphi()), ir(id.iradiusAbs());
   double phi = (iphi - 0.5) * hgpar_->scintCellSize(lay);
   int type = (id.type() > 0) ? 1 : 0;
   double r = (((ir + 1) < static_cast<int>(hgpar_->radiusLayer_[type].size()))
                   ? (0.5 * (hgpar_->radiusLayer_[type][ir] + hgpar_->radiusLayer_[type][ir - 1]))
                   : (1.5 * hgpar_->radiusLayer_[type][ir] - 0.5 * hgpar_->radiusLayer_[type][ir - 1]));
 #ifdef EDM_ML_DEBUG
   if (debug)
     edm::LogVerbatim("HGCalGeom") << "LocateCell lay:ir:iphi:type " << lay << ":" << ir << ":" << iphi << ":" << type
                                   << " r:phi " << r << ":" << convertRadToDeg(phi) << " x:y "
                                   << (r * cos(phi) * id.zside()) << ":" << (r * sin(phi));
 #endif
   return std::make_pair(r * cos(phi) * id.zside(), r * sin(phi));
 }

◆ locateCellHex()

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

Definition at line 731 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	lay,
		int	ieta,
		int	iphi,
		bool	reco
	)		const

Definition at line 747 of file HGCalDDDConstants.cc.

References funct::abs(), funct::cos(), getIndex(), hgpar_, LEDCalibrationChannels::iphi, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleToDDD, SiStripPI::max, SiStripPI::min, mode_, phi, alignCSCRings::r, HGCalParameters::radiusLayer_, FastTimerService_cff::range, rangeR(), HGCalParameters::scintType(), funct::sin(), HGCalGeometryMode::TrapezoidFile, HGCalGeometryMode::TrapezoidModule, x, y, z, and HGCalParameters::zLayerHex_.

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

                                                                                                     {
   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);
 #ifdef EDM_ML_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 << " R " << r << ":" << range.first << ":" << range.second;
 #endif
     if ((mode_ != HGCalGeometryMode::TrapezoidFile) && (mode_ != HGCalGeometryMode::TrapezoidModule))
       r = std::max(range.first, std::min(r, range.second));
     x = r * std::cos(phi);
     y = r * std::sin(phi);
     if (irad < 0)
       x = -x;
   }
   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 777 of file HGCalDDDConstants.cc.

References DetId::det(), DetId::Forward, getUVMax(), HGCalWaferMask::goodCell(), hgpar_, triggerObjects_cff::id, HGCalParameters::k_CornerSize, HGCalWaferMask::k_OffsetRotation, phase1PixelTopology::layer, gpuClustering::pixelStatus::mask, HGCalWaferMask::maskCell(), N, edm::second(), findQualityFiles::v, waferHexagon8(), HGCalWaferIndex::waferIndex(), 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 <= (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);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "MaskCell: Layer " << layer << " Wafer " << waferU << ":" << waferV << " Index "
                                     << wl << ":" << (itr != hgpar_->waferTypes_.end());
 #endif
       if (itr != hgpar_->waferTypes_.end()) {
         if ((itr->second).second <= HGCalWaferMask::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 - HGCalWaferMask::k_OffsetRotation)));
       }
     }
   }
   return mask;
 }

◆ maxCells() [1/2]

int HGCalDDDConstants::maxCells ( bool reco ) const

Definition at line 817 of file HGCalDDDConstants.cc.

References 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 827 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, 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 (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 102 of file HGCalDDDConstants.h.

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

Referenced by HGCalTopology::HGCalTopology().

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

HGCalDDDConstants::tileTrapezoid

bool tileTrapezoid() const

Definition: HGCalDDDConstants.h:139

HGCalParameters::nCellsFine_

int nCellsFine_

Definition: HGCalParameters.h:142

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ maxModules()

int HGCalDDDConstants::maxModules ( ) const

inline

Definition at line 105 of file HGCalDDDConstants.h.

References modHalf_.

105 { return modHalf_; }

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:281

◆ maxModulesPerLayer()

int HGCalDDDConstants::maxModulesPerLayer ( ) const

inline

Definition at line 106 of file HGCalDDDConstants.h.

References maxWafersPerLayer_.

106 { return maxWafersPerLayer_; }

HGCalDDDConstants::maxWafersPerLayer_

int32_t maxWafersPerLayer_

Definition: HGCalDDDConstants.h:284

◆ maxRows()

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

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

References hgpar_, and HGCalParameters::slopeMin_.

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

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

HGCalParameters::slopeMin_

std::vector< double > slopeMin_

Definition: HGCalParameters.h:138

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ modifyUV()

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

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

References first, getIndex(), createfilelist::int, and max_modules_layer_.

Referenced by wafers().

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

◆ modulesInit()

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

Definition at line 894 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 910 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 914 of file HGCalDDDConstants.cc.

References 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 929 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((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 962 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 < (int)(hgpar_->waferTypeT_.size())) {
     if (hgpar_->waferTypeT_[wafer] - 1 == HGCSiliconDetId::HGCalFine)
       return (int)(hgpar_->cellFineX_.size());
     else
       return (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 973 of file HGCalDDDConstants.cc.

References RemoveAddSevLevel::flag, HGCSiliconDetId::HGCalCoarseThick, hgpar_, 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 984 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(), 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 1011 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 1029 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 1042 of file HGCalDDDConstants.cc.

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

                                                                    {
   int row(0), col(0);
   if (wafer < (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 121 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::nSectors_.

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

121 { return hgpar_->nSectors_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:74

◆ simToReco()

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

Definition at line 1053 of file HGCalDDDConstants.cc.

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

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

                                                                                           {
   if (!waferHexagon6()) {
     return std::make_pair(cell, lay);
   } else {
     const auto& index = getIndex(lay, false);
     int i = index.first;
     if (i < 0) {
       edm::LogWarning("HGCalGeom") << "Wrong Layer # " << lay << " not in the list ***** ERROR *****";
       return std::make_pair(-1, -1);
     }
     if (mod >= (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 1082 of file HGCalDDDConstants.cc.

References b, HGCalParameters::firstLayer_, hgpar_, dqmdumpme::k, lastLayer(), phase1PixelTopology::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);
   }
   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;
     }
     for (int rin = ringmin; rin <= ringmax; ++rin) {
       int indx = HGCalTileIndex::tileIndex(lay, rin + 1, 0);
       auto itr = hgpar_->tileInfoMap_.find(indx);
       if (itr != hgpar_->tileInfoMap_.end()) {
         for (int k = 0; k < 4; ++k) {
           std::bitset<24> b(itr->second.hex[k]);
           kount += b.count();
         }
       }
     }
   }
   return (3 * kount);
 }

◆ tileExist()

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

inline

Definition at line 124 of file HGCalDDDConstants.h.

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

Referenced by HGCalGeometryLoader::build().

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

◆ tileRings()

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

inline

Definition at line 130 of file HGCalDDDConstants.h.

References HGCalParameters::firstLayer_, hgpar_, phase1PixelTopology::layer, mode_, HGCalParameters::tileRingRange_, and HGCalGeometryMode::TrapezoidFile.

                                                {
     if (mode_ == HGCalGeometryMode::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 138 of file HGCalDDDConstants.h.

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

Referenced by HGCalNumberingScheme::getUnitID().

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

HGCalTypes::SiPMLarge

Definition: HGCalTypes.h:90

HGCalTypes::SiPMSmall

Definition: HGCalTypes.h:90

◆ tileTrapezoid()

bool HGCalDDDConstants::tileTrapezoid ( ) const

inline

Definition at line 139 of file HGCalDDDConstants.h.

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

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

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

◆ tileType()

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

inline

Definition at line 143 of file HGCalDDDConstants.h.

References hgpar_, phase1PixelTopology::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);
   }

◆ 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:83

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ waferCount()

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 176 of file HGCalDDDConstants.h.

References waferMax_.

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

type

Definition: SiPixelVCal_PayloadInspector.cc:39

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:286

◆ waferFileIndex()

int HGCalDDDConstants::waferFileIndex ( unsigned int kk ) const

inline

Definition at line 183 of file HGCalDDDConstants.h.

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

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

◆ waferFileInfo()

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

inline

Definition at line 191 of file HGCalDDDConstants.h.

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

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

◆ waferFileInfoExist()

bool HGCalDDDConstants::waferFileInfoExist ( int kk ) const

inline

Definition at line 206 of file HGCalDDDConstants.h.

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

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

GetRecoTauVFromDQM_MC_cff.kk

kk

Definition: GetRecoTauVFromDQM_MC_cff.py:84

HGCalParameters::waferInfoMap_

waferInfo_map waferInfoMap_

Definition: HGCalParameters.h:184

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ waferFileInfoFromIndex()

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

inline

Definition at line 199 of file HGCalDDDConstants.h.

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

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

◆ waferFileSize()

unsigned int HGCalDDDConstants::waferFileSize ( ) const

inline

Definition at line 182 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferInfoMap_.

Referenced by waferType(), and waferTypeRotation().

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

HGCalParameters::waferInfoMap_

waferInfo_map waferInfoMap_

Definition: HGCalParameters.h:184

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

◆ waferFromCopy()

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 1108 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 1133 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	layer,
		int &	waferU,
		int &	waferV,
		int &	cellU,
		int &	cellV,
		int &	celltype,
		double &	wt,
		bool	extend = `false`,
		bool	debug = `false`
	)		const

Definition at line 1175 of file HGCalDDDConstants.cc.

References funct::abs(), cellHex(), HGCalParameters::cellThickness_, debug, PVValHelper::dx, PVValHelper::dy, HGCalParameters::firstLayer_, HGCalWaferType::getType(), getXY(), HGCalGeometryMode::Hexagon8File, HGCalGeometryMode::Hexagon8Module, hexside_, hexsideT_, HGCSiliconDetId::HGCalCoarseThick, hgpar_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, phase1PixelTopology::layer, HGCalParameters::layerType_, mode_, HGCalParameters::nCellsFine_, rmax_, rmaxT_, tan30deg_, HGCalParameters::typesInLayers_, HGCalTypes::WaferCenterR, HGCalParameters::waferCopy_, 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_, and geometryCSVtoXML::yy.

                                                             {
   waferU = waferV = 1 + hgpar_->waferUVMax_;
   cellU = cellV = celltype = 0;
   if ((hgpar_->xLayerHex_.empty()) || (hgpar_->yLayerHex_.empty()))
     return;
   int ll = layer - hgpar_->firstLayer_;
   bool rotx = ((!hgpar_->layerType_.empty()) && (hgpar_->layerType_[ll] == HGCalTypes::WaferCenterR));
   double xx(0), yy(0);
   if (rotx) {
     std::pair<double, double> xy =
         getXY(layer, HGCalParameters::k_ScaleFromDDD * x, HGCalParameters::k_ScaleFromDDD * y, true);
     xx = xy.first - hgpar_->xLayerHex_[ll];
     yy = xy.second - hgpar_->yLayerHex_[ll];
   } else {
     xx = HGCalParameters::k_ScaleFromDDD * x - hgpar_->xLayerHex_[ll];
     yy = HGCalParameters::k_ScaleFromDDD * y - hgpar_->yLayerHex_[ll];
   }
 #ifdef EDM_ML_DEBUG
   if (debug)
     edm::LogVerbatim("HGCalGeom") << "waferFromPosition:: Layer " << layer << ":" << ll << " Rot " << rotx << " X " << x
                                   << ":" << xx << " Y " << y << ":" << yy;
 #endif
   double rmax = extend ? rmaxT_ : rmax_;
   double hexside = extend ? hexsideT_ : hexside_;
   for (unsigned int k = 0; k < hgpar_->waferPosX_.size(); ++k) {
     double 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))) {
         waferU = HGCalWaferIndex::waferU(hgpar_->waferCopy_[k]);
         waferV = HGCalWaferIndex::waferV(hgpar_->waferCopy_[k]);
         if ((mode_ == HGCalGeometryMode::Hexagon8File) || (mode_ == HGCalGeometryMode::Hexagon8Module)) {
           int index = HGCalWaferIndex::waferIndex(layer, waferU, waferV);
           celltype = HGCalWaferType::getType(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]);
         }
 #ifdef EDM_ML_DEBUG
         if (debug)
           edm::LogVerbatim("HGCalGeom") << "WaferFromPosition:: Input " << layer << ":" << ll << ":"
                                         << hgpar_->firstLayer_ << ":" << rotx << ":" << x << ":" << y << ":"
                                         << hgpar_->xLayerHex_[ll] << ":" << hgpar_->yLayerHex_[ll] << ":" << xx << ":"
                                         << yy << " compared with " << hgpar_->waferPosX_[k] << ":"
                                         << hgpar_->waferPosY_[k] << " difference " << dx << ":" << dy << ":"
                                         << dx * tan30deg_ << ":" << (hexside_ - dy) << " comparator " << rmax_ << ":"
                                         << rmaxT_ << ":" << hexside_ << ":" << hexsideT_ << " wafer " << waferU << ":"
                                         << waferV << ":" << celltype;
 #endif
         xx -= hgpar_->waferPosX_[k];
         yy -= hgpar_->waferPosY_[k];
         break;
       }
     }
   }
   if ((std::abs(waferU) <= hgpar_->waferUVMax_) && (celltype >= 0)) {
     cellHex(xx, yy, celltype, cellU, cellV, extend, debug);
     wt = (((celltype < 2) && (mode_ != HGCalGeometryMode::Hexagon8Module))
               ? (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;
     }
   }
 }

◆ waferFullInLayer()

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

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

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

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

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

◆ waferHexagon8()

bool HGCalDDDConstants::waferHexagon8 ( ) const

inline

Definition at line 170 of file HGCalDDDConstants.h.

References HGCalGeometryMode::Hexagon8, 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(), waferType(), waferTypeRotation(), and waferVirtual().

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

◆ waferIndex()

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

private

Definition at line 1686 of file HGCalDDDConstants.cc.

References hgpar_, phase1PixelTopology::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;
 }

◆ waferInLayer()

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

Definition at line 1268 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 1698 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 == (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

inline

Definition at line 210 of file HGCalDDDConstants.h.

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

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

177 { return waferMax_[1]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:286

◆ waferMin()

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 178 of file HGCalDDDConstants.h.

References waferMax_.

Referenced by HeterogeneousHGCalHEFCellPositionsFiller::set_conditions_().

178 { return waferMax_[0]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:286

◆ waferParameters()

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

Definition at line 1282 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 1289 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 < (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 = `false`
	)		const

Definition at line 1302 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 1750 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 = `false`
	)		const

private

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

References HGCalParameters::depth_, hgpar_, mps_fire::i, createfilelist::int, 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 = (int)(hgpar_->moduleLayR_.size());
   }
   return wafer;
 }

◆ wafers() [2/2]

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

Definition at line 1487 of file HGCalDDDConstants.cc.

References HGCalParameters::firstModule_, getIndex(), hgpar_, HGCalParameters::lastModule_, phase1PixelTopology::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 207 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 225 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 230 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 = `false`
	)		const

Definition at line 1321 of file HGCalDDDConstants.cc.

References DetId::Forward, hgpar_, HFNoseDetId::layer(), HGCSiliconDetId::layer(), phase1PixelTopology::layer, HFNoseDetId::type(), HGCSiliconDetId::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 = `false`
	)		const

Definition at line 1349 of file HGCalDDDConstants.cc.

References HGCSiliconDetId::HGCalCoarseThick, hgpar_, createfilelist::int, phase1PixelTopology::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 < (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 = `false`
	)		const

Definition at line 1368 of file HGCalDDDConstants.cc.

References first, hgpar_, HGCalGeomTools::k_allCorners, HGCalGeomTools::k_fiveCorners, HGCalGeomTools::k_fourCorners, HGCalWaferMask::k_OffsetRotation, HGCalGeomTools::k_threeCorners, phase1PixelTopology::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 < HGCalWaferMask::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 - HGCalWaferMask::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 240 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 = `false`,
		bool	debug = `false`
	)		const

Definition at line 1407 of file HGCalDDDConstants.cc.

References debug, TauDecayModes::dec, first, hgpar_, HGCalGeomTools::k_allCorners, HGCalGeomTools::k_fiveCorners, HGCalGeomTools::k_fourCorners, HGCalWaferMask::k_OffsetRotation, HGCalGeomTools::k_threeCorners, phase1PixelTopology::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().

                                                                         {
   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 < HGCalWaferMask::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 - HGCalWaferMask::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 236 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 248 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferUVMax_.

Referenced by HGCalTopology::HGCalTopology().

248 { return hgpar_->waferUVMax_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:274

HGCalParameters::waferUVMax_

int waferUVMax_

Definition: HGCalParameters.h:148

◆ waferVirtual()

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

Definition at line 1454 of file HGCalDDDConstants.cc.

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

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

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

const float HGCalDDDConstants::dPhiMin = 0.02

private

Definition at line 271 of file HGCalDDDConstants.h.

◆ fullAndPart_

const bool HGCalDDDConstants::fullAndPart_

private

Definition at line 278 of file HGCalDDDConstants.h.

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

◆ geomTools_

HGCalGeomTools HGCalDDDConstants::geomTools_

private

Definition at line 269 of file HGCalDDDConstants.h.

Referenced by locateCell().

◆ hexside_

double HGCalDDDConstants::hexside_

private

Definition at line 279 of file HGCalDDDConstants.h.

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

◆ hexsideT_

double HGCalDDDConstants::hexsideT_

private

Definition at line 280 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and waferFromPosition().

◆ hgpar_

const HGCalParameters* HGCalDDDConstants::hgpar_

private

Definition at line 274 of file HGCalDDDConstants.h.

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

◆ k_horizontalShift

const double HGCalDDDConstants::k_horizontalShift = 1.0

private

Definition at line 270 of file HGCalDDDConstants.h.

◆ max_modules_layer_

Simrecovecs HGCalDDDConstants::max_modules_layer_

private

Definition at line 283 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and modules().

◆ maxWafersPerLayer_

int32_t HGCalDDDConstants::maxWafersPerLayer_

private

Definition at line 284 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModulesPerLayer().

◆ mode_

const HGCalGeometryMode::GeometryMode HGCalDDDConstants::mode_

private

Definition at line 277 of file HGCalDDDConstants.h.

Referenced by geomMode(), HGCalDDDConstants(), isValidCell8(), locateCellTrap(), tileRings(), tileTrapezoid(), waferFromPosition(), waferHexagon6(), and waferHexagon8().

◆ modHalf_

int32_t HGCalDDDConstants::modHalf_

private

Definition at line 281 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and maxModules().

◆ rmax_

double HGCalDDDConstants::rmax_

private

Definition at line 279 of file HGCalDDDConstants.h.

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

◆ rmaxT_

double HGCalDDDConstants::rmaxT_

private

Definition at line 280 of file HGCalDDDConstants.h.

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

◆ sqrt3_

const double HGCalDDDConstants::sqrt3_

private

Definition at line 276 of file HGCalDDDConstants.h.

Referenced by cellHex(), distFromEdgeHex(), and locateCell().

◆ tan30deg_

constexpr double HGCalDDDConstants::tan30deg_ = 0.5773502693

staticprivate

Definition at line 275 of file HGCalDDDConstants.h.

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

◆ tot_layers_

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

private

Definition at line 282 of file HGCalDDDConstants.h.

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

◆ tot_wafers_

int32_t HGCalDDDConstants::tot_wafers_

private

Definition at line 281 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants().

◆ waferIn_

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

private

Definition at line 287 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and isValidHex8().

◆ waferLayer_

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

private

Definition at line 285 of file HGCalDDDConstants.h.

Referenced by HGCalDDDConstants(), and wafers().

◆ waferMax_

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

private

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

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

◆ getREtaRange()

◆ getTrForm()

◆ getTrFormN()

◆ getTrForms()

◆ getTypeHex()

◆ getTypeTrap()

◆ getUVMax()

◆ getXY()

◆ isHalfCell()

◆ isValidCell()

◆ isValidCell8()

◆ isValidHex()

◆ isValidHex8() [1/2]

◆ isValidHex8() [2/2]

◆ isValidTrap()

◆ lastLayer()

◆ layerFromIndex()

◆ layerIndex()

◆ layers()

◆ layersInit()

◆ levelTop()

◆ localToGlobal8()

◆ locateCell() [1/4]

◆ locateCell() [2/4]

◆ locateCell() [3/4]

◆ locateCell() [4/4]

◆ locateCellHex()

◆ locateCellTrap()

◆ maskCell()

◆ maxCells() [1/2]

◆ maxCells() [2/2]

◆ maxCellUV()

◆ maxModules()

◆ maxModulesPerLayer()

◆ maxRows()

◆ minSlope()

◆ modifyUV()

◆ modules()

◆ modulesInit()

◆ mouseBite()

◆ numberCells() [1/2]

◆ numberCells() [2/2]

◆ numberCellsHexagon() [1/2]