#include <HGCalDDDConstants.h>

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

std::array< int, 5 >	assignCellHex (float x, float y, int lay, bool reco) 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

double	cellThickness (int layer, 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

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

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

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

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

private

Definition at line 139 of file HGCalDDDConstants.h.

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 1136 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 1157 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, and mode_.

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

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

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

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

Definition at line 249 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 HFNoseSD::isItinFidVolume(), and HGCalSD::isItinFidVolume().

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

int HGCalDDDConstants::firstLayer ( ) const

inline

Definition at line 47 of file HGCalDDDConstants.h.

References HGCalParameters::firstLayer_, and hgpar_.

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

47 {return hgpar_->firstLayer_;}

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:151

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

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

48 {return mode_;}

HGCalDDDConstants::mode_

HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:145

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

private

Definition at line 1213 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 332 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 351 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 373 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 52 of file HGCalDDDConstants.h.

References hgpar_.

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

52 {return hgpar_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

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

inline

Definition at line 53 of file HGCalDDDConstants.h.

References HGCalParameters::getTrForm(), and hgpar_.

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

53 {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:141

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 54 of file HGCalDDDConstants.h.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor::all(), debug, getTrForms(), getTypeHex(), getTypeTrap(), hgpar_, isHalfCell(), isValidHex(), isValidHex8(), isValidTrap(), layerIndex(), layers(), layersInit(), locateCell(), locateCellHex(), locateCellTrap(), mod(), HGCalParameters::trformIndex_, and waferType().

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:71

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

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

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

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

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

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

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

Definition at line 410 of file HGCalDDDConstants.cc.

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

Referenced by getTrFormN(), 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 1232 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 415 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 getTrFormN(), HGCNumberingScheme::getUnitID(), and HGCalTopology::valid().

                                     {
   //Check validity for a layer|wafer|cell of pre-TDR version
   bool result(false), resultMod(false);
   int  cellmax(0);
   if ((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 465 of file HGCalDDDConstants.cc.

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

Referenced by getTrFormN(), 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);
   if (itr == hgpar_->typesInLayers_.end()) return false;
   auto jtr  = waferIn_.find(indx);
   if (!(jtr->second))                      return false;
   int  N = ((hgpar_->waferTypeL_[itr->second] == 0) ? hgpar_->nCellsFine_ :
         hgpar_->nCellsCoarse_);
   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 482 of file HGCalDDDConstants.cc.

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

Referenced by getTrFormN(), 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::layerIndex	(	int	lay,
		bool	reco
	)		const

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

                                                           {
   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 491 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(), getTrFormN(), 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 507 of file HGCalDDDConstants.cc.

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

Referenced by getTrFormN(), and HGCalDDDConstants().

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

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

inline

Definition at line 74 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::levelT_.

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

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

HGCalParameters::levelT_

std::vector< int > levelT_

Definition: HGCalParameters.h:114

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

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

Definition at line 511 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::getPosition(), and getTrFormN().

                                                         {
   // 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 537 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 601 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::getPosition(), and getTrFormN().

                                              {
   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 618 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(), HGCalGeometry::get8Corners(), HGCalGeometry::getCorners(), and getTrFormN().

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

int HGCalDDDConstants::maxCells ( bool reco ) const

Definition at line 643 of file HGCalDDDConstants.cc.

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

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

References modHalf_.

80 {return modHalf_;}

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:146

int HGCalDDDConstants::maxMoudlesPerLayer ( ) const

inline

Definition at line 81 of file HGCalDDDConstants.h.

References maxRows(), and maxWafersPerLayer_.

81 {return maxWafersPerLayer_;}

HGCalDDDConstants::maxWafersPerLayer_

int32_t maxWafersPerLayer_

Definition: HGCalDDDConstants.h:149

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

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

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

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

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

HGCalParameters::slopeMin_

std::vector< double > slopeMin_

Definition: HGCalParameters.h:117

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

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

Definition at line 709 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 714 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 728 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 733 of file HGCalDDDConstants.cc.

References 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 744 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 778 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 790 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 800 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(), and minSlope().

                                                                           {
   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") << "DDHGCalEEAlgo: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 835 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") << "DDHGCalEEAlgo: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 850 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 95 of file HGCalDDDConstants.h.

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

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

95 {return hgpar_->nSectors_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:55

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

Definition at line 862 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(), HGCalTriggerBackend::HGCalTriggerSimCluster< FECODEC, DATA >::run(), 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 97 of file HGCalDDDConstants.h.

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

Referenced by HGCalGeometryLoader::build().

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:64

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 109 of file HGCalDDDConstants.h.

References waferMax_.

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

type

Definition: HCALResponse.h:21

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:151

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 897 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 920 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 962 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 1046 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 1039 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 1261 of file HGCalDDDConstants.cc.

References hexside_, hgpar_, recoMuon::in, gen::k, HGCalParameters::k_CornerSize, rmax_, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, mathSSE::sqrt(), HGCalParameters::waferPosX_, and HGCalParameters::waferPosY_.

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

                                                                             {
 
   const double waferX = hgpar_->waferPosX_[wafer];
   const double waferY = hgpar_->waferPosY_[wafer];
   double xc[HGCalParameters::k_CornerSize], yc[HGCalParameters::k_CornerSize];
   xc[0] = waferX+rmax_; yc[0] = waferY-0.5*hexside_;
   xc[1] = waferX+rmax_; yc[1] = waferY+0.5*hexside_;
   xc[2] = waferX;       yc[2] = waferY+hexside_;
   xc[3] = waferX-rmax_; yc[3] = waferY+0.5*hexside_;
   xc[4] = waferX+rmax_; yc[4] = waferY-0.5*hexside_;
   xc[5] = waferX;       yc[5] = waferY-hexside_;
   bool cornerOne(false), cornerAll(true);
   for (unsigned int k=0; k<HGCalParameters::k_CornerSize; ++k) {
     double rpos = std::sqrt(xc[k]*xc[k]+yc[k]*yc[k]);
     if ((rpos >= hgpar_->rMinLayHex_[lay]) && 
     (rpos <= hgpar_->rMaxLayHex_[lay])) cornerOne = true;
     else                                    cornerAll = false;
   }
   bool in =  full ? cornerOne : cornerAll;
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "WaferInLayerTest: Layer " << lay
                 << " wafer " << wafer << " R-limits "
                 << hgpar_->rMinLayHex_[lay] << ":"
                 << hgpar_->rMaxLayHex_[lay] << " Corners "
                 << cornerOne << ":" << cornerAll << " In "
                 << in;
 #endif
   return in;
 }

int HGCalDDDConstants::waferMax ( ) const

inline

Definition at line 110 of file HGCalDDDConstants.h.

References waferMax_.

110 {return waferMax_[1];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:151

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 111 of file HGCalDDDConstants.h.

References waferMax_, and waferPosition().

111 {return waferMax_[0];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:151

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

Definition at line 1052 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 1067 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 1106 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 1120 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 114 of file HGCalDDDConstants.h.

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

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

HGCalParameters::sensorSeparation_

double sensorSeparation_

Definition: HGCalParameters.h:125

HGCalParameters::k_ScaleToDDD

static double k_ScaleToDDD

Definition: HGCalParameters.h:22

reco

fixed size matrix

Definition: AlignmentAlgorithmBase.h:43

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

double HGCalDDDConstants::waferSize ( bool reco ) const

inline

Definition at line 115 of file HGCalDDDConstants.h.

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

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

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

HGCalParameters::waferSize_

double waferSize_

Definition: HGCalParameters.h:123

HGCalParameters::k_ScaleToDDD

static double k_ScaleToDDD

Definition: HGCalParameters.h:22

reco

fixed size matrix

Definition: AlignmentAlgorithmBase.h:43

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

int HGCalDDDConstants::waferToCopy ( int wafer ) const

inline

Definition at line 118 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferCopy_.

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

HGCalParameters::waferCopy_

std::vector< int > waferCopy_

Definition: HGCalParameters.h:94

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

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

Definition at line 1085 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(), getTrFormN(), 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 122 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

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

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

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

HGCalParameters::waferTypeL_

std::vector< int > waferTypeL_

Definition: HGCalParameters.h:95

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

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

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

HGCalParameters::waferTypeT_

std::vector< int > waferTypeT_

Definition: HGCalParameters.h:96

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

int HGCalDDDConstants::waferUVMax ( ) const

inline

Definition at line 124 of file HGCalDDDConstants.h.

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

Referenced by HGCalTopology::HGCalTopology().

124 {return hgpar_->waferUVMax_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:141

HGCalParameters::waferUVMax_

int waferUVMax_

Definition: HGCalParameters.h:127

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

Definition at line 1099 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(), 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]);
 }