#include <HGCalDDDConstants.h>

Public Types
enum	CellType { CellType::UndefinedType = -1, CellType::CentralType = 0, CellType::BottomLeftEdge = 1, CellType::LeftEdge = 2, CellType::TopLeftEdge = 3, CellType::TopRightEdge = 4, CellType::RightEdge = 5, CellType::BottomRightEdge = 6, CellType::BottomCorner = 11, CellType::BottomLeftCorner = 12, CellType::TopLeftCorner = 13, CellType::TopCorner = 14, CellType::TopRightCorner = 15, CellType::BottomRightCorner = 16 }

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

CellType	cellType (int type, int waferU, int waferV) 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

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

	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 modU, int modV, int cellU, int cellV) 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 >	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 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 >	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

unsigned int	volumes () const

int	waferCount (const int type) 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 debug=false) const

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

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

int	waferMax () const

int	waferMin () const

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

std::pair< double, double >	waferPosition (int waferU, int waferV, bool reco) 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) const

int	waferTypeL (int wafer) 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 debug=false) const

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

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

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

Private Attributes
const float	dPhiMin = 0.02

double	hexside_

const HGCalParameters *	hgpar_

const double	k_horizontalShift = 1.0

Simrecovecs	max_modules_layer_

int32_t	maxWafersPerLayer_

HGCalGeometryMode::GeometryMode	mode_

int32_t	modHalf_

double	rmax_

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

Member Typedef Documentation

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

private

Definition at line 192 of file HGCalDDDConstants.h.

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

private

Definition at line 191 of file HGCalDDDConstants.h.

Member Enumeration Documentation

enum HGCalDDDConstants::CellType

strong

Enumerator
UndefinedType
CentralType
BottomLeftEdge
LeftEdge
TopLeftEdge
TopRightEdge
RightEdge
BottomRightEdge
BottomCorner
BottomLeftCorner
TopLeftCorner
TopCorner
TopRightCorner
BottomRightCorner

Definition at line 28 of file HGCalDDDConstants.h.

                       {
     UndefinedType = -1,
     CentralType = 0,
     BottomLeftEdge = 1,
     LeftEdge = 2,
     TopLeftEdge = 3,
     TopRightEdge = 4,
     RightEdge = 5,
     BottomRightEdge = 6,
     BottomCorner = 11,
     BottomLeftCorner = 12,
     TopLeftCorner = 13,
     TopCorner = 14,
     TopRightCorner = 15,
     BottomRightCorner = 16
   };

Constructor & Destructor Documentation

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

Definition at line 24 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, funct::cos(), getIndex(), getTrForm(), getTrFormN(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hexside_, hgpar_, mps_fire::i, HGCalParameters::k_ScaleFromDDD, HGCalParameters::hgtrform::lay, layers(), layersInit(), SiStripPI::max, max_modules_layer_, maxCells(), maxWafersPerLayer_, HGCalParameters::mode_, mode_, modHalf_, modulesInit(), rmax_, sectors(), tan30deg_, tot_layers_, tot_wafers_, HGCalParameters::waferCopy_, waferIn_, HGCalWaferIndex::waferIndex(), waferInLayer(), waferLayer_, waferMax_, HGCalParameters::waferR_, wafers(), HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

     : hgpar_(hp), sqrt3_(std::sqrt(3.0)) {
   mode_ = hgpar_->mode_;
   if ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull) ||
       (mode_ == HGCalGeometryMode::Hexagon8) ||
       (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     rmax_ = (HGCalParameters::k_ScaleFromDDD * (hgpar_->waferR_) *
              std::cos(30._deg));
     hexside_ = 2.0 * rmax_ * tan30deg_;
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom")
         << "rmax_ " << rmax_ << ":" << hexside_ << " 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";
 #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 ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull) ||
       (mode_ == HGCalGeometryMode::Hexagon8) ||
       (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     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 ((mode_ == HGCalGeometryMode::Hexagon8) ||
             (mode_ == HGCalGeometryMode::Hexagon8Full)) {
           int kndx = HGCalWaferIndex::waferIndex(
               lay0, HGCalWaferIndex::waferU(hgpar_->waferCopy_[wafer]),
               HGCalWaferIndex::waferV(hgpar_->waferCopy_[wafer]));
           waferIn_[kndx] = waferIn;
         }
         if (waferIn) {
           int waferU =
               (((mode_ == HGCalGeometryMode::Hexagon) ||
                 (mode_ == HGCalGeometryMode::HexagonFull))
                    ? 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 ( )

Definition at line 122 of file HGCalDDDConstants.cc.

122 {}

Member Function Documentation

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

Definition at line 124 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellHex(), HGCalParameters::cellSize_, getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, HGCalParameters::k_ScaleFromDDD, mode_, trackingPlots::reco, rmax_, findQualityFiles::size, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, geometryCSVtoXML::xx, 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 ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     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);
   }
 }

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

Definition at line 163 of file HGCalDDDConstants.cc.

References HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalParameters::k_ScaleToDDD, mode_, trackingPlots::reco, waferFromPosition(), waferType(), geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

Referenced by HGCalGeometry::getClosestCell().

                                                                      {
   int waferU(0), waferV(0), waferType(-1), cellU(0), cellV(0);
   if ((mode_ == HGCalGeometryMode::Hexagon8) ||
       (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     double xx = (reco) ? HGCalParameters::k_ScaleToDDD * x : x;
     double yy = (reco) ? HGCalParameters::k_ScaleToDDD * y : y;
     double wt(1.0);
     waferFromPosition(xx, yy, lay, waferU, waferV, cellU, cellV, waferType, wt);
   }
   return std::array<int, 5>{{waferU, waferV, waferType, cellU, cellV}};
 }

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

Definition at line 176 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, createfilelist::int, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, M_PI, SiStripPI::max, min(), phi, alignCSCRings::r, HGCalParameters::radiusLayer_, HGCalParameters::scintType(), mathSSE::sqrt(), and geometryCSVtoXML::xx.

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::min(std::max(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}};
 }

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

Definition at line 204 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, runTauDisplay::dr, hgpar_, mode_, alignCSCRings::r, HGCalParameters::radiusLayer_, and HGCalGeometryMode::Trapezoid.

                                                 {
   double dr(0), df(0);
   if (mode_ == HGCalGeometryMode::Trapezoid) {
     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);
 }

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

References funct::abs(), PVValHelper::dx, PVValHelper::dy, gen::k, pileupDistInMC::num, tan30deg_, and TrackerOfflineValidation_Dqm_cff::xmax.

Referenced by assignCell(), waferFromPosition(), and waferUVMax().

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

void HGCalDDDConstants::cellHex	(	double	xloc,
		double	yloc,
		int	cellType,
		int &	cellU,
		int &	cellV,
		bool	debug = `false`
	)		const

private

Definition at line 1419 of file HGCalDDDConstants.cc.

References funct::abs(), debug, runEdmFileComparison::found, hgpar_, SiStripPI::max, min(), N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, rmax_, edm::shift, and sqrt3_.

                                         {
   int N = (cellType == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_;
   double Rc = 2 * rmax_ / (3 * N);
   double rc = 0.5 * Rc * 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 const 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) <= rc) && (std::abs(xloc - xc) <= Rc) &&
             ((std::abs(xloc - xc) <= 0.5 * Rc) ||
              (std::abs(yloc - yc) <= sqrt3_ * (Rc - 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;
   }
 }

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

Definition at line 217 of file HGCalDDDConstants.cc.

References getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hgpar_, locateCell(), mode_, HGCalParameters::rMinLayHex_, mathSSE::sqrt(), and geometryCSVtoXML::xy.

Referenced by HGCalGeometry::newCell().

                                                                          {
   const auto& indx = getIndex(lay, true);
   if (indx.first >= 0) {
     if ((mode_ == HGCalGeometryMode::Hexagon8) ||
         (mode_ == HGCalGeometryMode::Hexagon8Full) ||
         (mode_ == HGCalGeometryMode::Hexagon) ||
         (mode_ == HGCalGeometryMode::HexagonFull)) {
       const auto& xy = (((mode_ == HGCalGeometryMode::Hexagon8) ||
                          (mode_ == HGCalGeometryMode::Hexagon8Full))
                             ? locateCell(lay, waferU, waferV, cellU, cellV,
                                          reco, true, 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;
   }
 }

double HGCalDDDConstants::cellSizeHex ( int type ) const

Definition at line 262 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, hgpar_, HGCalParameters::k_ScaleFromDDD, mode_, and HGCalGeometryMode::Trapezoid.

Referenced by HGCalGeometryLoader::build(), and hgcal::RecHitTools::getRadiusToSide().

                                                     {
   int indx = (((mode_ == HGCalGeometryMode::Hexagon8) ||
                (mode_ == HGCalGeometryMode::Hexagon8Full))
                   ? ((type >= 1) ? 1 : 0)
                   : ((type == 1) ? 1 : 0));
   double cell =
       ((mode_ == HGCalGeometryMode::Trapezoid)
            ? 0.5 * hgpar_->cellSize_[indx]
            : 0.5 * HGCalParameters::k_ScaleFromDDD * hgpar_->cellSize_[indx]);
   return cell;
 }

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

inline

Definition at line 54 of file HGCalDDDConstants.h.

References cellThickness(), cellType(), distFromEdgeHex(), distFromEdgeTrap(), etaPhiFromPosition(), 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]);
   }

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

Definition at line 241 of file HGCalDDDConstants.cc.

References HGCalParameters::cellThickness_, HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hgpar_, maxType, minType, mode_, HGCalParameters::typesInLayers_, HGCalWaferIndex::waferIndex(), and HGCalParameters::waferTypeL_.

Referenced by cellSizeTrap(), and hgcal::RecHitTools::getSiThickness().

                                                           {
   double thick(-1);
   if ((mode_ == HGCalGeometryMode::Hexagon8) ||
       (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     auto itr = hgpar_->typesInLayers_.find(
         HGCalWaferIndex::waferIndex(layer, waferU, waferV));
     int type = ((itr == hgpar_->typesInLayers_.end()
                      ? maxType
                      : hgpar_->waferTypeL_[itr->second]));
     thick = 10000.0 * hgpar_->cellThickness_[type];  // cm to micron
   } else if ((mode_ == HGCalGeometryMode::Hexagon) ||
              (mode_ == HGCalGeometryMode::HexagonFull)) {
     int type = (((waferU >= 0) && (waferU < (int)(hgpar_->waferTypeL_.size())))
                     ? hgpar_->waferTypeL_[waferU]
                     : minType);
     thick = 100.0 * type;  // type = 1,2,3 for 100,200,300 micron
   }
   return thick;
 }

HGCalDDDConstants::CellType HGCalDDDConstants::cellType	(	int	type,
		int	waferU,
		int	waferV
	)		const

Definition at line 274 of file HGCalDDDConstants.cc.

References BottomCorner, BottomLeftCorner, BottomLeftEdge, BottomRightCorner, BottomRightEdge, CentralType, hgpar_, LeftEdge, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, RightEdge, TopCorner, TopLeftCorner, TopLeftEdge, TopRightCorner, TopRightEdge, and UndefinedType.

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

                                                                          {
   // type=0: in the middle; 1..6: the edges clocwise from bottom left;
   //     =11..16: the corners clockwise from bottom
   int N = (type == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_;
   if (cellU == 0) {
     if (cellV == 0)
       return HGCalDDDConstants::CellType::BottomLeftCorner;
     else if (cellV - cellU == N - 1)
       return HGCalDDDConstants::CellType::BottomCorner;
     else
       return HGCalDDDConstants::CellType::BottomLeftEdge;
   } else if (cellV == 0) {
     if (cellU - cellV == N)
       return HGCalDDDConstants::CellType::TopLeftCorner;
     else
       return HGCalDDDConstants::CellType::LeftEdge;
   } else if (cellU - cellV == N) {
     if (cellU == 2 * N - 1)
       return HGCalDDDConstants::CellType::TopCorner;
     else
       return HGCalDDDConstants::CellType::TopLeftEdge;
   } else if (cellU == 2 * N - 1) {
     if (cellV == 2 * N - 1)
       return HGCalDDDConstants::CellType::TopRightCorner;
     else
       return HGCalDDDConstants::CellType::TopRightEdge;
   } else if (cellV == 2 * N - 1) {
     if (cellV - cellU == N - 1)
       return HGCalDDDConstants::CellType::BottomRightCorner;
     else
       return HGCalDDDConstants::CellType::RightEdge;
   } else if (cellV - cellU == N - 1) {
     return HGCalDDDConstants::CellType::BottomRightEdge;
   } else if ((cellU > 2 * N - 1) || (cellV > 2 * N - 1) ||
              (cellV >= (cellU + N)) || (cellU > (cellV + N))) {
     return HGCalDDDConstants::CellType::UndefinedType;
   } else {
     return HGCalDDDConstants::CellType::CentralType;
   }
 }

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

Definition at line 316 of file HGCalDDDConstants.cc.

References funct::abs(), PVValHelper::dx, PVValHelper::dy, hexside_, hgpar_, createfilelist::int, gen::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, rmax_, sqrt3_, tan30deg_, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, x, geometryCSVtoXML::xx, y, and geometryCSVtoXML::yy.

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

                                                                             {
   // Assming the point is within a hexagonal plane of the wafer, calculate
   // the shortest distance from the edge
   if (z < 0) x = -x;
   double dist(0);
   // Input x, y in Geant4 unit and transformed to CMSSW standard
   double xx = HGCalParameters::k_ScaleFromDDD * x;
   double yy = HGCalParameters::k_ScaleFromDDD * y;
   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;
 }

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

Definition at line 360 of file HGCalDDDConstants.cc.

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

Referenced by cellSizeTrap(), and 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());
   if (irad < hgpar_->iradMinBH_[indx])
     irad = hgpar_->iradMinBH_[indx];
   else if (irad > hgpar_->iradMaxBH_[indx])
     irad = 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);
 }

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

Referenced by cellSizeTrap().

int HGCalDDDConstants::firstLayer ( ) const

inline

Definition at line 65 of file HGCalDDDConstants.h.

References HGCalParameters::firstLayer_, and hgpar_.

Referenced by HGCalRecHitValidation::dqmBeginRun(), HGCalDigiValidation::dqmBeginRun(), HGCalSimHitValidation::dqmBeginRun(), HGCalTriggerGeometryV9Imp1::fillInvalidTriggerCells(), HGCalTopology::HGCalTopology(), and HGCalGeometry::neighborZ().

65 { return hgpar_->firstLayer_; }

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:150

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

Definition at line 66 of file HGCalDDDConstants.h.

References getLayer(), getModule(), getModules(), gen::k, and mode_.

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

66 { return mode_; }

HGCalDDDConstants::mode_

HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:197

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

private

Definition at line 1477 of file HGCalDDDConstants.cc.

References HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hgpar_, layerIndex(), mode_, HGCalParameters::moduleCellR_, HGCalParameters::moduleCellS_, and HGCalParameters::scintCellSize().

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

                                                                         {
   int indx = layerIndex(lay, reco);
   if (indx < 0) return std::make_pair(-1, 0);
   float cell(0);
   if ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     cell = (reco ? hgpar_->moduleCellR_[0] : hgpar_->moduleCellS_[0]);
   } else {
     if ((mode_ == HGCalGeometryMode::Hexagon8) ||
         (mode_ == HGCalGeometryMode::Hexagon8Full)) {
       cell = (reco ? hgpar_->moduleCellR_[0] : hgpar_->moduleCellS_[0]);
     } else {
       cell = hgpar_->scintCellSize(lay);
     }
   }
   return std::make_pair(indx, cell);
 }

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

Definition at line 397 of file HGCalDDDConstants.cc.

References funct::abs(), HGCalParameters::firstLayer_, HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, gen::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layerGroup_, layerIndex(), mode_, trackingPlots::reco, HGCalParameters::zLayerHex_, and geometryCSVtoXML::zz.

Referenced by distFromEdgeTrap(), geomMode(), and HGCalGeometry::getClosestCell().

                                                          {
   // 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 (((mode_ == HGCalGeometryMode::Hexagon) ||
        (mode_ == HGCalGeometryMode::HexagonFull)) &&
       reco) {
     int indx = layerIndex(lay, false);
     if (indx >= 0) lay = hgpar_->layerGroup_[indx];
   } else {
     lay += (hgpar_->firstLayer_ - 1);
   }
   return lay;
 }

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

Definition at line 420 of file HGCalDDDConstants.cc.

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

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

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

Definition at line 440 of file HGCalDDDConstants.cc.

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

Referenced by geomMode().

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

const HGCalParameters* HGCalDDDConstants::getParameter ( ) const

inline

Definition at line 71 of file HGCalDDDConstants.h.

References getPhiBins(), getREtaRange(), and hgpar_.

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

71 { return hgpar_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

int HGCalDDDConstants::getPhiBins ( int lay ) const

Definition at line 447 of file HGCalDDDConstants.cc.

References hgpar_, mode_, HGCalParameters::scintCells(), and HGCalGeometryMode::Trapezoid.

Referenced by getParameter().

                                                {
   return ((mode_ == HGCalGeometryMode::Trapezoid) ? hgpar_->scintCells(lay)
                                                   : 0);
 }

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

inline

Definition at line 74 of file HGCalDDDConstants.h.

References hgpar_, mode_, HGCalParameters::radiusLayer_, HGCalParameters::scintType(), and HGCalGeometryMode::Trapezoid.

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

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

Definition at line 452 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, layerIndex(), mode_, and HGCalGeometryMode::Trapezoid.

Referenced by getParameter().

                                                                {
   int irmin(0), irmax(0);
   if (mode_ == HGCalGeometryMode::Trapezoid) {
     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);
 }

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

inline

Definition at line 79 of file HGCalDDDConstants.h.

References HGCalParameters::getTrForm(), and hgpar_.

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

                                                           {
     return hgpar_->getTrForm(k);
   }

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 82 of file HGCalDDDConstants.h.

References getTrForms(), getTypeHex(), getTypeTrap(), hgpar_, and HGCalParameters::trformIndex_.

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:70

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

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

Definition at line 464 of file HGCalDDDConstants.cc.

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

Referenced by HGCalTrackCollectionProducer::beginLuminosityBlock(), and getTrFormN().

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

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

Definition at line 480 of file HGCalDDDConstants.cc.

References HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, hgpar_, mode_, HGCalParameters::typesInLayers_, HGCalWaferIndex::waferIndex(), and HGCalParameters::waferTypeL_.

Referenced by HGCalGeometryLoader::build(), HGCalTriggerGeometryV9Imp2::detIdWaferType(), HGCalTriggerGeometryV9Imp1::detIdWaferType(), getTrFormN(), and HGCalTopology::neighbors().

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

int HGCalDDDConstants::getTypeTrap ( int layer ) const

Definition at line 471 of file HGCalDDDConstants.cc.

References hgpar_, mode_, HGCalParameters::scintType(), and HGCalGeometryMode::Trapezoid.

Referenced by HGCalTriggerGeometryV9Imp1::fillInvalidTriggerCells(), HGCalTriggerGeometryV9Imp1::getCellsFromTriggerCell(), HGCalTriggerGeometryV9Imp1::getNeighborsFromTriggerCell(), and getTrFormN().

                                                   {
   // Get the module type for scinitllator
   if (mode_ == HGCalGeometryMode::Trapezoid) {
     return hgpar_->scintType(layer);
   } else {
     return -1;
   }
 }

int HGCalDDDConstants::getUVMax ( int type ) const

inline

Definition at line 86 of file HGCalDDDConstants.h.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor::all(), debug, hgpar_, isHalfCell(), isValidHex(), isValidHex8(), isValidTrap(), lastLayer(), layerIndex(), layers(), layersInit(), locateCell(), locateCellHex(), locateCellTrap(), mod(), HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, and waferType().

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

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

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

Definition at line 494 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseHalf_, HGCalParameters::cellFineHalf_, and hgpar_.

Referenced by getUVMax(), and hgcal::RecHitTools::isHalfCell().

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

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

private

Definition at line 1495 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, 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(), and waferUVMax().

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

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

Definition at line 500 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::copiesInLayers_, HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, createfilelist::int, isValidCell(), layers(), maxCells(), mod(), mode_, mps_fire::result, findQualityFiles::size, HGCalParameters::waferCopy_, and HGCalParameters::waferTypeT_.

Referenced by HGCNumberingScheme::getUnitID(), getUVMax(), and HGCalTopology::valid().

                                                     {
   // Check validity for a layer|wafer|cell of pre-TDR version
   bool result(false), resultMod(false);
   int cellmax(0);
   if ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     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)
                          ? (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;
 }

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

Definition at line 549 of file HGCalDDDConstants.cc.

References hgpar_, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::typesInLayers_, waferIn_, HGCalWaferIndex::waferIndex(), and HGCalParameters::waferTypeL_.

Referenced by HGCalTopology::addHGCSiliconId(), getUVMax(), and HGCalTopology::valid().

                                                      {
   // 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;
   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;
   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 (((cellV - cellU) < N) && ((cellU - cellV) <= N));
   } else {
     return false;
   }
 }

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

Definition at line 583 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, and HGCalParameters::iradMinBH_.

Referenced by HGCalTopology::addHGCSCintillatorId(), getUVMax(), 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]) && (iphi > 0) &&
           (iphi <= hgpar_->scintCells(layer)));
 }

int HGCalDDDConstants::lastLayer ( bool reco ) const

Definition at line 592 of file HGCalDDDConstants.cc.

References HGCalParameters::firstLayer_, hgpar_, and tot_layers_.

Referenced by getUVMax(), and HGCalGeometry::neighborZ().

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

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

Definition at line 600 of file HGCalDDDConstants.cc.

References HGCalParameters::depthIndex_, HGCalParameters::depthLayerF_, HGCalParameters::firstLayer_, HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, HGCalParameters::layerIndex_, and mode_.

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

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

unsigned int HGCalDDDConstants::layers ( bool reco ) const

Definition at line 596 of file HGCalDDDConstants.cc.

References createfilelist::int, and tot_layers_.

Referenced by HGCalTBAnalyzer::analyze(), HGCalDigiClient::beginRun(), HGCalRecHitsClient::beginRun(), HGCalSimHitsClient::beginRun(), HGCalTimingAnalyzer::beginRun(), HGCalTBAnalyzer::beginRun(), HGCalRecHitValidation::dqmBeginRun(), HGCalDigiValidation::dqmBeginRun(), HGCalSimHitValidation::dqmBeginRun(), HGCalTriggerTools::eventSetup(), HGCalTriggerGeometryHexImp2::fillInvalidTriggerCells(), HGCalTriggerGeometryHexLayerBasedImp1::fillInvalidTriggerCells(), HGCalTriggerGeometryV9Imp1::fillInvalidTriggerCells(), getUVMax(), HGCalDDDConstants(), HGCalTopology::HGCalTopology(), HGCalTriggerGeometryHexLayerBasedImp1::initialize(), HGCalTriggerGeometryV9Imp1::initialize(), HGCalTriggerGeometryV9Imp2::initialize(), isValidHex(), maxCells(), SimG4HGCalValidation::update(), and wafers().

                                                       {
   return tot_layers_[(int)reco];
 }

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

Definition at line 612 of file HGCalDDDConstants.cc.

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

Referenced by getUVMax(), and HGCalDDDConstants().

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

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

inline

Definition at line 105 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::levelT_, and maskCell().

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

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

HGCalParameters::levelT_

std::vector< int > levelT_

Definition: HGCalParameters.h:113

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

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

Definition at line 616 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, mps_fire::i, HGCalParameters::k_ScaleToDDD, mode_, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, x, and y.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTBAnalyzer::analyzeSimHits(), cellInLayer(), HGCalNumberingScheme::checkPosition(), HGCalGeometry::get8Corners(), HGCalGeometry::getCorners(), HGCNumberingScheme::getLocalCoords(), HGCalGeometry::getNewCorners(), HGCalGeometry::getPosition(), and getUVMax().

                                                                        {
   // 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 ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     x = hgpar_->waferPosX_[type];
     y = hgpar_->waferPosY_[type];
     if (hgpar_->waferTypeT_[type] == 1) {
       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);
 }

std::pair< float, float > HGCalDDDConstants::locateCell	(	int	lay,
		int	waferU,
		int	waferV,
		int	cellU,
		int	cellV,
		bool	reco,
		bool	all,
		bool	debug = `false`
	)		const

Definition at line 643 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseIndex_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineIndex_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, debug, hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::typesInLayers_, HGCalWaferIndex::waferIndex(), waferPosition(), HGCalParameters::waferTypeL_, x, geometryCSVtoXML::xy, and y.

                                                               {
 
   float 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]);
 #ifdef EDM_ML_DEBUG
   if (debug)
     edm::LogVerbatim("HGCalGeom")
         << "LocateCell " << lay << ":" << waferU << ":" << waferV << ":" << indx
         << ":" << (itr == hgpar_->typesInLayers_.end()) << ":" << type;
 #endif
   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
     if (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
     if (debug)
       edm::LogVerbatim("HGCalGeom")
           << "Coarse " << cellU << ":" << cellV << ":" << kndx << ":" << x
           << ":" << y << ":" << (ktr != hgpar_->cellCoarseIndex_.end());
 #endif
   }
   if (!reco) {
     x *= HGCalParameters::k_ScaleToDDD;
     y *= HGCalParameters::k_ScaleToDDD;
   }
   if (all) {
     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);
 }

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

Definition at line 708 of file HGCalDDDConstants.cc.

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

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

                                                                           {
   float x(0), y(0);
   if (hgpar_->waferTypeT_[wafer] == 1) {
     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);
 }

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

Definition at line 725 of file HGCalDDDConstants.cc.

References funct::abs(), funct::cos(), getIndex(), hgpar_, HGCalParameters::k_ScaleToDDD, SiStripPI::max, min(), phi, alignCSCRings::r, HGCalParameters::radiusLayer_, rangeR(), HGCalParameters::scintType(), funct::sin(), x, y, z, and HGCalParameters::zLayerHex_.

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

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

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

Definition at line 750 of file HGCalDDDConstants.cc.

References DetId::det(), plotBeamSpotDB::first, DetId::Forward, getUVMax(), HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, hgpar_, triggerObjects_cff::id, HGCalParameters::k_CornerSize, RecoTauDiscriminantConfiguration::mask, mode_, N, edm::second(), findQualityFiles::v, HGCalWaferIndex::waferIndex(), and HGCalParameters::waferTypes_.

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

                                                                       {
   bool mask(false);
   if (corners > 2 && corners < (int)(HGCalParameters::k_CornerSize)) {
     if ((mode_ == HGCalGeometryMode::Hexagon8) ||
         (mode_ == HGCalGeometryMode::Hexagon8Full)) {
       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()) {
         int ncor = (itr->second).first;
         int fcor = (itr->second).second;
         if (ncor < corners) {
           mask = true;
         } else {
           if (ncor == 4) {
             switch (fcor) {
               case (0): {
                 mask = (v >= N);
                 break;
               }
               case (1): {
                 mask = (u >= N);
                 break;
               }
               case (2): {
                 mask = (u <= v);
                 break;
               }
               case (3): {
                 mask = (v < N);
                 break;
               }
               case (4): {
                 mask = (u < N);
                 break;
               }
               default: {
                 mask = (u > v);
                 break;
               }
             }
           } else {
             switch (fcor) {
               case (0): {
                 if (ncor == 3) {
                   mask = !((u > 2 * v) && (v < N));
                 } else {
                   mask = ((u >= N) && (v >= N) && ((u + v) > (3 * N - 2)));
                 }
                 break;
               }
               case (1): {
                 if (ncor == 3) {
                   mask = !((u + v) < N);
                 } else {
                   mask = ((u >= N) && (u > v) && ((2 * u - v) > 2 * N));
                 }
                 break;
               }
               case (2): {
                 if (ncor == 3) {
                   mask = !((u < N) && (v > u) && (v > (2 * u - 1)));
                 } else {
                   mask = ((u > 2 * v) && (v < N));
                 }
                 break;
               }
               case (3): {
                 if (ncor == 3) {
                   mask = !((v >= u) && ((2 * v - u) > (2 * N - 2)));
                 } else {
                   mask = ((u + v) < N);
                 }
                 break;
               }
               case (4): {
                 if (ncor == 3) {
                   mask = !((u >= N) && (v >= N) && ((u + v) > (3 * N - 2)));
                 } else {
                   mask = ((u < N) && (v > u) && (v > (2 * u - 1)));
                 }
                 break;
               }
               default: {
                 if (ncor == 3) {
                   mask = !((u >= N) && (u > v) && ((2 * u - v) > 2 * N));
                 } else {
                   mask = ((v >= u) && ((2 * v - u) > (2 * N - 2)));
                 }
                 break;
               }
             }
           }
 #ifdef EDM_ML_DEBUG
           edm::LogVerbatim("HGCalGeom")
               << "Corners: " << ncor << ":" << fcor << " N " << N << " u " << u
               << " v " << v << " Mask " << mask;
 #endif
         }
       }
     }
   }
   return mask;
 }

int HGCalDDDConstants::maxCells ( bool reco ) const

Definition at line 877 of file HGCalDDDConstants.cc.

References postprocess-scan-build::cells, HGCalParameters::depth_, hgpar_, mps_fire::i, HGCalParameters::layer_, and layers().

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

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

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

Definition at line 886 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, postprocess-scan-build::cells, HGCalParameters::defineFull_, HGCalParameters::firstLayer_, getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hgpar_, gen::k, SiStripPI::max, mode_, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::scintCells(), HGCalGeometryMode::Trapezoid, HGCalParameters::typesInLayers_, HGCalParameters::waferCopy_, 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 ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     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)
                                 ? (hgpar_->cellFineX_.size())
                                 : (hgpar_->cellCoarseX_.size());
         if (cell > cells) cells = cell;
       }
     }
     return (int)(cells);
   } else if ((mode_ == HGCalGeometryMode::Hexagon8) ||
              (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     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())
                         ? 2
                         : hgpar_->waferTypeL_[itr->second]);
         int N = (type == 0) ? hgpar_->nCellsFine_ : hgpar_->nCellsCoarse_;
         cells = std::max(cells, 3 * N * N);
       }
     }
     return cells;
   } else if (mode_ == HGCalGeometryMode::Trapezoid) {
     return hgpar_->scintCells(index.first + hgpar_->firstLayer_);
   } else {
     return 0;
   }
 }

int HGCalDDDConstants::maxCellUV ( ) const

inline

Definition at line 107 of file HGCalDDDConstants.h.

References hgpar_, maxCells(), mode_, HGCalParameters::nCellsFine_, and HGCalGeometryMode::Trapezoid.

Referenced by HGCalTopology::HGCalTopology().

                         {
     return ((mode_ == HGCalGeometryMode::Trapezoid) ? hgpar_->nCellsFine_
                                                     : 2 * hgpar_->nCellsFine_);
   }

int HGCalDDDConstants::maxModules ( ) const

inline

Definition at line 113 of file HGCalDDDConstants.h.

References modHalf_.

113 { return modHalf_; }

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:198

int HGCalDDDConstants::maxModulesPerLayer ( ) const

inline

Definition at line 114 of file HGCalDDDConstants.h.

References maxRows(), and maxWafersPerLayer_.

114 { return maxWafersPerLayer_; }

HGCalDDDConstants::maxWafersPerLayer_

int32_t maxWafersPerLayer_

Definition: HGCalDDDConstants.h:201

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

Definition at line 924 of file HGCalDDDConstants.cc.

References HGCalParameters::defineFull_, getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hgpar_, mps_fire::i, gen::k, mode_, HGCalParameters::waferCopy_, waferInLayerTest(), and HGCalParameters::waferUVMaxLayer_.

Referenced by maxModulesPerLayer().

                                                        {
   int kymax(0);
   const auto& index = getIndex(lay, reco);
   int i = index.first;
   if (i < 0) return kymax;
   if ((mode_ == HGCalGeometryMode::Hexagon) ||
       (mode_ == HGCalGeometryMode::HexagonFull)) {
     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 ((mode_ == HGCalGeometryMode::Hexagon8) ||
              (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     kymax = 1 + 2 * hgpar_->waferUVMaxLayer_[index.first];
   }
   return kymax;
 }

double HGCalDDDConstants::minSlope ( ) const

inline

Definition at line 116 of file HGCalDDDConstants.h.

References RemoveAddSevLevel::flag, hgpar_, modifyUV(), modules(), modulesInit(), mouseBite(), numberCells(), numberCellsHexagon(), rangeR(), rangeZ(), rowColumnWafer(), and HGCalParameters::slopeMin_.

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

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

HGCalParameters::slopeMin_

std::vector< double > slopeMin_

Definition: HGCalParameters.h:116

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

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

Definition at line 944 of file HGCalDDDConstants.cc.

Referenced by minSlope(), and 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));
 }

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

Definition at line 951 of file HGCalDDDConstants.cc.

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

Referenced by minSlope(), and wafers().

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

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

Definition at line 958 of file HGCalDDDConstants.cc.

References HGCalParameters::defineFull_, HGCalParameters::firstModule_, getIndex(), hgpar_, gen::k, HGCalParameters::lastModule_, mode_, HGCalGeometryMode::Trapezoid, waferInLayerTest(), and HGCalParameters::waferPosX_.

Referenced by HGCalDDDConstants(), and minSlope().

                                                            {
   int nmod(0);
   const auto& index = getIndex(lay, reco);
   if (index.first < 0) return nmod;
   if (mode_ != HGCalGeometryMode::Trapezoid) {
     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;
 }

double HGCalDDDConstants::mouseBite ( bool reco ) const

Definition at line 973 of file HGCalDDDConstants.cc.

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

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

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

int HGCalDDDConstants::numberCells ( bool reco ) const

Definition at line 978 of file HGCalDDDConstants.cc.

References postprocess-scan-build::cells, HGCalParameters::depth_, hgpar_, gen::k, HGCalParameters::layer_, and trackingPlots::reco.

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

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

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

Definition at line 989 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::defineFull_, HGCalParameters::firstModule_, getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, mps_fire::i, gen::k, mode_, numberCellsHexagon(), HGCalParameters::scintCells(), HGCalGeometryMode::Trapezoid, HGCalParameters::waferCopy_, 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 ((mode_ == HGCalGeometryMode::Hexagon) ||
         (mode_ == HGCalGeometryMode::HexagonFull)) {
       for (unsigned int k = 0; k < hgpar_->waferTypeT_.size(); ++k) {
         if (waferInLayerTest(k, i, hgpar_->defineFull_)) {
           unsigned int cell = (hgpar_->waferTypeT_[k] == 1)
                                   ? (hgpar_->cellFineX_.size())
                                   : (hgpar_->cellCoarseX_.size());
           ncell.emplace_back((int)(cell));
         }
       }
     } else if (mode_ == HGCalGeometryMode::Trapezoid) {
       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;
 }

int HGCalDDDConstants::numberCellsHexagon ( int wafer ) const

Definition at line 1022 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, hgpar_, and HGCalParameters::waferTypeT_.

Referenced by HGCalTriggerGeometryHexImp1::fillMaps(), minSlope(), HGCalGeometry::newCell(), and numberCells().

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

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

Definition at line 1033 of file HGCalDDDConstants.cc.

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

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

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

Definition at line 1047 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_, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zLayerHex_, and geometryCSVtoXML::zz.

Referenced by HGCalNumberingScheme::checkPosition(), HGCDigitizer::checkPosition(), locateCellTrap(), minSlope(), 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);
 }

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

Definition at line 1083 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::k_ScaleToDDD, HGCalParameters::waferThick_, and HGCalParameters::zLayerHex_.

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

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

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

Definition at line 1098 of file HGCalDDDConstants.cc.

References cuy::col, popcon2dropbox::copy(), hgpar_, and HGCalParameters::waferCopy_.

Referenced by minSlope().

                                                                    {
   int row(0), col(0);
   if (wafer < (int)(hgpar_->waferCopy_.size())) {
     int copy = hgpar_->waferCopy_[wafer];
     col = copy % 100;
     if ((copy / 10000) % 10 != 0) col = -col;
     row = (copy / 100) % 100;
     if ((copy / 100000) % 10 != 0) row = -row;
   }
   return std::make_pair(row, col);
 }

int HGCalDDDConstants::sectors ( ) const

inline

Definition at line 128 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::nSectors_, and simToReco().

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

128 { return hgpar_->nSectors_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:54

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

Definition at line 1110 of file HGCalDDDConstants.cc.

References egammaForCoreTracking_cff::depth, getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, mps_fire::i, HGCalParameters::layerGroup_, HGCalParameters::layerGroupM_, HGCalParameters::layerGroupO_, mod(), mode_, findQualityFiles::size, and HGCalParameters::waferTypeL_.

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

                                                                   {
   if ((mode_ != HGCalGeometryMode::Hexagon) &&
       (mode_ != HGCalGeometryMode::HexagonFull)) {
     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);
   }
 }

unsigned int HGCalDDDConstants::volumes ( ) const

inline

Definition at line 130 of file HGCalDDDConstants.h.

References popcon2dropbox::copy(), debug, hgpar_, HGCalParameters::moduleLayR_, waferFromCopy(), waferFromPosition(), waferFullInLayer(), and waferInLayer().

Referenced by HGCalGeometryLoader::build().

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:63

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 139 of file HGCalDDDConstants.h.

References waferMax_.

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

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 1143 of file HGCalDDDConstants.cc.

References hgpar_, gen::k, mps_fire::result, and HGCalParameters::waferCopy_.

Referenced by HGCNumberingScheme::getUnitID(), and volumes().

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

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

Definition at line 1167 of file HGCalDDDConstants.cc.

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

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

                                                               {
   // 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_ = (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)
       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
 }

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	debug = `false`
	)		const

Definition at line 1211 of file HGCalDDDConstants.cc.

References funct::abs(), cellHex(), HGCalParameters::cellThickness_, debug, PVValHelper::dx, PVValHelper::dy, EDM_ML_DEBUG, hexside_, hgpar_, gen::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::nCellsFine_, rmax_, tan30deg_, HGCalParameters::typesInLayers_, HGCalParameters::waferCopy_, HGCalWaferIndex::waferIndex(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferThick_, HGCalParameters::waferTypeL_, HGCalWaferIndex::waferU(), HGCalParameters::waferUVMax_, HGCalWaferIndex::waferV(), globals_cff::x1, geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

                                                   {
 
   double xx(HGCalParameters::k_ScaleFromDDD * x);
   double yy(HGCalParameters::k_ScaleFromDDD * y);
   waferU = waferV = 1 + hgpar_->waferUVMax_;
   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]);
         auto itr = hgpar_->typesInLayers_.find(
             HGCalWaferIndex::waferIndex(layer, waferU, waferV));
         celltype = ((itr == hgpar_->typesInLayers_.end())
                         ? 2
                         : hgpar_->waferTypeL_[itr->second]);
 #ifdef EDM_ML_DEBUG
         if (debug)
           edm::LogVerbatim("HGCalGeom")
               << "WaferFromPosition:: Input " << xx << ":" << yy
               << " compared with " << hgpar_->waferPosX_[k] << ":"
               << hgpar_->waferPosY_[k] << " difference " << dx << ":" << dy
               << ":" << dx * tan30deg_ << ":" << (hexside_ - dy)
               << " comparator " << rmax_ << ":" << hexside_ << " wafer "
               << waferU << ":" << waferV << ":" << celltype;
 #endif
         xx -= hgpar_->waferPosX_[k];
         yy -= hgpar_->waferPosY_[k];
         break;
       }
     }
   }
   if (std::abs(waferU) <= hgpar_->waferUVMax_) {
     cellHex(xx, yy, celltype, cellU, cellV
 #ifdef EDM_ML_DEBUG
             ,
             debug
 #endif
     );
     wt = ((celltype < 2)
               ? (hgpar_->cellThickness_[celltype] / hgpar_->waferThick_)
               : 1.0);
   } else {
     cellU = cellV = 2 * hgpar_->nCellsFine_;
     wt = 1.0;
     celltype = -1;
   }
 #ifdef EDM_ML_DEBUG
   if (celltype < 0) {
     double x1(HGCalParameters::k_ScaleFromDDD * x);
     double y1(HGCalParameters::k_ScaleFromDDD * y);
     edm::LogVerbatim("HGCalGeom")
         << "waferFromPosition: 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_;
     }
   }
 #endif
 }

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

Definition at line 1294 of file HGCalDDDConstants.cc.

References getIndex(), and waferInLayerTest().

Referenced by volumes().

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

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

Definition at line 1288 of file HGCalDDDConstants.cc.

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

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

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

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

private

Definition at line 1522 of file HGCalDDDConstants.cc.

References TCMET_cfi::corner, RemoveAddSevLevel::flag, HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hexside_, hgpar_, recoMuon::in, HGCalParameters::k_CornerSize, mode_, rmax_, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, HGCalGeomTools::waferCorner(), HGCalParameters::waferPosX_, and HGCalParameters::waferPosY_.

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

                                                                             {
   bool flag = ((mode_ == HGCalGeometryMode::Hexagon) ||
                (mode_ == HGCalGeometryMode::HexagonFull))
                   ? true
                   : false;
   std::pair<int, int> corner = HGCalGeomTools::waferCorner(
       hgpar_->waferPosX_[wafer], hgpar_->waferPosY_[wafer], rmax_, hexside_,
       hgpar_->rMinLayHex_[lay], hgpar_->rMaxLayHex_[lay], flag);
   bool in = (full ? (corner.first > 0)
                   : (corner.first == (int)(HGCalParameters::k_CornerSize)));
 #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;
 }

int HGCalDDDConstants::waferMax ( ) const

inline

Definition at line 142 of file HGCalDDDConstants.h.

References waferMax_.

142 { return waferMax_[1]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:203

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 143 of file HGCalDDDConstants.h.

References waferMax_, and waferPosition().

143 { return waferMax_[0]; }

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:203

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

Definition at line 1300 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), HGCMouseBite::exclude(), locateCell(), and waferMin().

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

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

Definition at line 1314 of file HGCalDDDConstants.cc.

References hgpar_, HGCalParameters::k_ScaleToDDD, HGCalWaferIndex::waferIndex(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::wafersInLayers_, 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);
 }

int HGCalDDDConstants::wafers ( ) const

Definition at line 1368 of file HGCalDDDConstants.cc.

References HGCalParameters::depth_, hgpar_, mps_fire::i, createfilelist::int, layers(), mode_, HGCalParameters::moduleLayR_, modules(), and HGCalGeometryMode::Trapezoid.

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

                                     {
   int wafer(0);
   if (mode_ != HGCalGeometryMode::Trapezoid) {
     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;
 }

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

Definition at line 1381 of file HGCalDDDConstants.cc.

References HGCalParameters::firstModule_, getIndex(), hgpar_, HGCalParameters::lastModule_, mode_, HGCalGeometryMode::Trapezoid, and waferLayer_.

                                                        {
   int wafer(0);
   if (mode_ != HGCalGeometryMode::Trapezoid) {
     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;
 }

double HGCalDDDConstants::waferSepar ( bool reco ) const

inline

Definition at line 147 of file HGCalDDDConstants.h.

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

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

double HGCalDDDConstants::waferSize ( bool reco ) const

inline

Definition at line 151 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::k_ScaleToDDD, wafers(), and HGCalParameters::waferSize_.

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

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

int HGCalDDDConstants::waferToCopy ( int wafer ) const

inline

Definition at line 157 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferCopy_.

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

int HGCalDDDConstants::waferType ( DetId const & id ) const

Definition at line 1331 of file HGCalDDDConstants.cc.

References DetId::Forward, HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, mode_, HGCSiliconDetId::type(), HFNoseDetId::type(), and waferTypeL().

Referenced by hgc_digi_utils::addCellMetadata(), assignCellHex(), getUVMax(), and HGCalUncalibRecHitRecWeightsAlgo< HGCDataFrame >::makeRecHit().

                                                       {
   int type(1);
   if ((mode_ == HGCalGeometryMode::Hexagon8) ||
       (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     type = ((id.det() != DetId::Forward) ? (1 + HGCSiliconDetId(id).type())
                                          : (1 + HFNoseDetId(id).type()));
   } else if ((mode_ == HGCalGeometryMode::Hexagon) ||
              (mode_ == HGCalGeometryMode::HexagonFull)) {
     type = waferTypeL(HGCalDetId(id).wafer());
   }
   return type;
 }

int HGCalDDDConstants::waferTypeL ( int wafer ) const

inline

Definition at line 169 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

Referenced by HGCalTriggerTools::sensorCellThicknessV8(), and waferType().

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

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

Definition at line 163 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeT_.

Referenced by HGCalGeometryLoader::build(), HGCalTriggerGeometryHexImp2::detIdWaferType(), HGCalTriggerGeometryHexLayerBasedImp1::detIdWaferType(), HGCalTriggerGeometryHexImp1::fillMaps(), HGCalGeometry::getClosestCell(), and hgcal::RecHitTools::isHalfCell().

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

int HGCalDDDConstants::waferUVMax ( ) const

inline

Definition at line 175 of file HGCalDDDConstants.h.

References cellHex(), debug, full, getIndex(), hgpar_, isValidCell(), RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, waferInLayerTest(), HGCalParameters::waferUVMax_, waferVirtual(), waferZ(), geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

Referenced by HGCalTopology::HGCalTopology().

175 { return hgpar_->waferUVMax_; }

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:193

HGCalParameters::waferUVMax_

int waferUVMax_

Definition: HGCalParameters.h:126

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

Definition at line 1344 of file HGCalDDDConstants.cc.

References HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hgpar_, mode_, HGCalWaferIndex::waferIndex(), and HGCalParameters::waferTypes_.

Referenced by waferUVMax().

                                                                             {
   bool type(false);
   if ((mode_ == HGCalGeometryMode::Hexagon8) ||
       (mode_ == HGCalGeometryMode::Hexagon8Full)) {
     int wl = HGCalWaferIndex::waferIndex(layer, waferU, waferV, false);
     type = (hgpar_->waferTypes_.find(wl) != hgpar_->waferTypes_.end());
   } else if ((mode_ == HGCalGeometryMode::Hexagon) ||
              (mode_ == HGCalGeometryMode::HexagonFull)) {
     int wl = HGCalWaferIndex::waferIndex(layer, waferU, 0, true);
     type = (hgpar_->waferTypes_.find(wl) != hgpar_->waferTypes_.end());
   }
   return type;
 }

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

Definition at line 1358 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTBAnalyzer::analyzeRecHits(), HGCalTBAnalyzer::analyzeSimHits(), HGCalNumberingScheme::checkPosition(), HGCalTriggerTools::getLayerZ(), hgcal::RecHitTools::getPositionLayer(), HGCalGeometry::neighborZ(), and waferUVMax().

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