#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

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

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	maxMoudlesPerLayer () 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 24 of file HGCalDDDConstants.h.

Member Typedef Documentation

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

private

Definition at line 157 of file HGCalDDDConstants.h.

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

private

Definition at line 156 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 31 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 25 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.0*CLHEP::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 119 of file HGCalDDDConstants.cc.

119 {}

Member Function Documentation

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

Definition at line 121 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 157 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 170 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, createfilelist::int, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, 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} };
 }

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 1322 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 1343 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 199 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 241 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 46 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::pair<double,double>(hgpar_->radiusLayer_[type][irad-1],
                     hgpar_->radiusLayer_[type][irad]);
   }

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

Definition at line 222 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];
   } 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;
   }
   return thick;
 }

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

Definition at line 251 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 282 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 327 of file HGCalDDDConstants.cc.

References funct::abs(), getLayer(), hgpar_, createfilelist::int, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, layerIndex(), 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 58 of file HGCalDDDConstants.h.

References HGCalParameters::firstLayer_, and hgpar_.

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

58 {return hgpar_->firstLayer_;}

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:152

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

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

59 {return mode_;}

HGCalDDDConstants::mode_

HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:162

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

private

Definition at line 1399 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 365 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_;
   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 = 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 384 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 406 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 63 of file HGCalDDDConstants.h.

References hgpar_.

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

63 {return hgpar_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

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

inline

Definition at line 64 of file HGCalDDDConstants.h.

References HGCalParameters::getTrForm(), and hgpar_.

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

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

HGCalParameters::getTrForm

hgtrform getTrForm(unsigned int k) const

Definition: HGCalParameters.cc:121

gen::k

int k[5][pyjets_maxn]

Definition: Cascade2Hadronizer.cc:79

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 65 of file HGCalDDDConstants.h.

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

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:72

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

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

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

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

Referenced by HGCalGeometryLoader::build(), 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 422 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 69 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().

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

type

Definition: HCALResponse.h:21

HGCalParameters::nCellsCoarse_

int nCellsCoarse_

Definition: HGCalParameters.h:123

HGCalParameters::nCellsFine_

int nCellsFine_

Definition: HGCalParameters.h:122

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

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

Definition at line 443 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 1418 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 448 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 499 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 534 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 543 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 551 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(), 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 547 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(), isValidHex(), maxCells(), SimG4HGCalValidation::update(), and wafers().

                                                       {
   return tot_layers_[(int)reco];
 }

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

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

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

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

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

HGCalParameters::levelT_

std::vector< int > levelT_

Definition: HGCalParameters.h:115

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

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

Definition at line 567 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 593 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 657 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 674 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 699 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(), 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 809 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 819 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 90 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 95 of file HGCalDDDConstants.h.

References modHalf_.

95 {return modHalf_;}

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:163

int HGCalDDDConstants::maxMoudlesPerLayer ( ) const

inline

Definition at line 96 of file HGCalDDDConstants.h.

References maxRows(), and maxWafersPerLayer_.

96 {return maxWafersPerLayer_;}

HGCalDDDConstants::maxWafersPerLayer_

int32_t maxWafersPerLayer_

Definition: HGCalDDDConstants.h:166

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

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

                                                        {
 
   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 98 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().

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

HGCalParameters::slopeMin_

std::vector< double > slopeMin_

Definition: HGCalParameters.h:118

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

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

Definition at line 875 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 881 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 886 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 900 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 905 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 916 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 950 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 962 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 972 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::pair<double,double>(rmin,rmax);
 }

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

Definition at line 1007 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::pair<double,double>(zmin,zmax);
 }

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

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

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

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

111 {return hgpar_->nSectors_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:56

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

Definition at line 1034 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(), sectors(), HGCalTriggerNtupleHGCTriggerCells::simhits(), and HGCalTriggerNtupleHGCDigis::simhits().

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

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

Referenced by HGCalGeometryLoader::build().

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:65

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 125 of file HGCalDDDConstants.h.

References waferMax_.

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

type

Definition: HCALResponse.h:21

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:168

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 1069 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 1092 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 1134 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 1218 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 1211 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 1447 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 126 of file HGCalDDDConstants.h.

References waferMax_.

126 {return waferMax_[1];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:168

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 127 of file HGCalDDDConstants.h.

References waferMax_, and waferPosition().

127 {return waferMax_[0];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:168

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

Definition at line 1224 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 1239 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 1292 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 1306 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 130 of file HGCalDDDConstants.h.

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

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

HGCalParameters::sensorSeparation_

double sensorSeparation_

Definition: HGCalParameters.h:126

HGCalParameters::k_ScaleToDDD

static double k_ScaleToDDD

Definition: HGCalParameters.h:23

reco

fixed size matrix

Definition: AlignmentAlgorithmBase.h:43

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

double HGCalDDDConstants::waferSize ( bool reco ) const

inline

Definition at line 131 of file HGCalDDDConstants.h.

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

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

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

HGCalParameters::waferSize_

double waferSize_

Definition: HGCalParameters.h:124

HGCalParameters::k_ScaleToDDD

static double k_ScaleToDDD

Definition: HGCalParameters.h:23

reco

fixed size matrix

Definition: AlignmentAlgorithmBase.h:43

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

int HGCalDDDConstants::waferToCopy ( int wafer ) const

inline

Definition at line 134 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferCopy_.

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

HGCalParameters::waferCopy_

std::vector< int > waferCopy_

Definition: HGCalParameters.h:95

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

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

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

References hgpar_, and HGCalParameters::waferTypeL_.

Referenced by HGCalTriggerNtupleHGCTriggerCells::fill(), HGCalVFESummationImpl::triggerCellSums(), and waferType().

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

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

HGCalParameters::waferTypeL_

std::vector< int > waferTypeL_

Definition: HGCalParameters.h:96

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

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

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

HGCalParameters::waferTypeT_

std::vector< int > waferTypeT_

Definition: HGCalParameters.h:97

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

int HGCalDDDConstants::waferUVMax ( ) const

inline

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

140 {return hgpar_->waferUVMax_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:158

HGCalParameters::waferUVMax_

int waferUVMax_

Definition: HGCalParameters.h:128

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

Definition at line 1271 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 1285 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]);
 }