#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) 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< int, int >	rowColumnWafer (const int wafer) const

int	scintType (const float dPhi) 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) 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) 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 138 of file HGCalDDDConstants.h.

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

private

Definition at line 137 of file HGCalDDDConstants.h.

Constructor & Destructor Documentation

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

Definition at line 22 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();
     
   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";
 
   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 115 of file HGCalDDDConstants.cc.

115 {}

Member Function Documentation

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

Definition at line 117 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 153 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 166 of file HGCalDDDConstants.cc.

References funct::abs(), PVValHelper::eta, HGCalParameters::etaMinBH_, getIndex(), hgpar_, createfilelist::int, HGCalParameters::k_ScaleToDDD, cmsBatch::log, M_PI, SiStripPI::max, min(), phi, alignCSCRings::r, scintType(), funct::sin(), mathSSE::sqrt(), funct::tan(), theta(), geometryCSVtoXML::xx, HGCalParameters::zLayerHex_, and geometryCSVtoXML::zz.

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

                                              {
   
   int ieta(-1), iphi(-1), type(-1);
   const auto & indx  = getIndex(layer,reco);
   if (indx.first < 0) return std::array<int,3>{ {ieta,iphi,type} };
   double xx    = (z > 0) ? x : -x;
   double zz    = (reco ? hgpar_->zLayerHex_[indx.first] : 
           HGCalParameters::k_ScaleToDDD*hgpar_->zLayerHex_[indx.first]);
   double r     = std::sqrt(x*x+y*y+zz*zz);
   double theta = (r == 0. ? 0. : std::acos(std::max(std::min(zz/r,1.0),-1.0)));
   double stheta= std::sin(theta);
   double phi   = (r*stheta == 0. ? 0. : std::atan2(y,xx));
   if (phi < 0) phi += (2.0*M_PI);
   double eta   = (std::abs(stheta) == 1.? 0. : -std::log(std::abs(std::tan(0.5*theta))) );
   ieta         = 1 + (int)((std::abs(eta)-hgpar_->etaMinBH_)/indx.second);
   iphi         = 1 + (int)(phi/indx.second);
   type         = scintType(indx.second);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "assignCellTrap Input " << x << ":" << y
                 << ":" << z << ":" << layer << ":" << reco
                 << " x|z|r " << xx << ":" << zz << ":" << r
                 << " theta|phi " << theta << ":" << stheta 
                 << ":" << phi << " o/p " << ieta << ":" 
                 << iphi << ":" << type;
 #endif
   return std::array<int,3>{ {ieta,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 1023 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
	)		const

private

Definition at line 1044 of file HGCalDDDConstants.cc.

References funct::abs(), runEdmFileComparison::found, hgpar_, 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));
   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];
       double xc = (1.5*(cellV-N)+1.0)*Rc;
       double yc = (2*cellU-cellV-N)*rc;
       if (((std::abs(xloc-xc) <= rc) && (std::abs(yloc-yc) <= 0.5*Rc)) ||
       ((std::abs(yloc-yc) <= Rc) && 
        (std::abs(xloc-xc) <= sqrt3_*std::abs(yloc-yc-Rc)))) {
     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 196 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) : 
     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 238 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 219 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 246 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 HGCalSD::isItinFidVolume().

                                                                             {
 
   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;
   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;
     }
   }
   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 287 of file HGCalDDDConstants.cc.

References funct::abs(), HGCalParameters::dPhiEtaBH_, PVValHelper::eta, HGCalParameters::etaMinBH_, getLayer(), hgpar_, createfilelist::int, HGCalParameters::k_ScaleToDDD, layerIndex(), cmsBatch::log, M_PI, SiStripPI::max, min(), phi, alignCSCRings::r, findQualityFiles::rr, funct::sin(), mathSSE::sqrt(), funct::tan(), theta(), geometryCSVtoXML::xx, HGCalParameters::zLayerHex_, and geometryCSVtoXML::zz.

Referenced by HGCScintSD::isItinFidVolume().

                                                                              {
 
   int lay      = getLayer(z,false);
   double xx    = (z < 0) ? -x : x;
   int indx     = layerIndex(lay,false);
   double zz    = HGCalParameters::k_ScaleToDDD*hgpar_->zLayerHex_[indx];
   double r     = std::sqrt(x*x+y*y+zz*zz);
   double theta = (r == 0. ? 0. : std::acos(std::max(std::min(zz/r,1.0),-1.0)));
   double stheta= std::sin(theta);
   double phi   = (r*stheta == 0. ? 0. : std::atan2(y,xx));
   if (phi < 0) phi += (2.0*M_PI);
   double eta   = (std::abs(stheta) == 1.0 ? 0. : -std::log(std::abs(std::tan(0.5*theta))) );
   double cell  = hgpar_->dPhiEtaBH_[indx];
   int ieta     = 1 + (int)((std::abs(eta)-hgpar_->etaMinBH_)/cell);
   int iphi     = 1 + (int)(phi/cell);
   double rr    = std::sqrt(x*x+y*y);
   double dphi  = std::max(0.0,(0.5*cell-std::abs(phi-(iphi-0.5)*cell)));
   double dist  = ((eta > hgpar_->etaMinBH_+(ieta-0.5)*cell) ?
           (rr - zz/std::sinh(hgpar_->etaMinBH_+ieta*cell)) :
           (zz/std::sinh(hgpar_->etaMinBH_+(ieta-1)*cell) - rr));
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DistFromEdgeTrap: Global " << x << ":"
                 << y << ":" << z << " Layer " << lay 
                 << " Index " << indx << " xx|zz " << xx << ":"
                 << zz << " Eta " << eta << ":"<< ieta << ":" 
                 << (hgpar_->etaMinBH_+(ieta-0.5)*cell) 
                 << " Phi " << phi << ":" << iphi << ":" 
                 << (iphi-0.5)*cell << " cell " << cell << " R "
                 << rr << " Dphi " << dphi << " Dist " << dist
                 << ":" << rr*dphi << ":" 
                 << rr-zz/std::sinh(hgpar_->etaMinBH_+ieta*cell)
                 << ":" << zz/std::sinh(hgpar_->etaMinBH_+(ieta-1)*cell)-rr;
 #endif
   return std::min(rr*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 HGCalTopology::HGCalTopology().

47 {return hgpar_->firstLayer_;}

HGCalParameters::firstLayer_

int firstLayer_

Definition: HGCalParameters.h:138

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

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(), HGCalSD::update(), HGCSD::update(), and SimG4HGCalValidation::update().

48 {return mode_;}

HGCalDDDConstants::mode_

HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:143

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

private

Definition at line 1072 of file HGCalDDDConstants.cc.

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

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_->dPhiEtaBH_[indx];
     }
   }
   return std::make_pair(indx,cell);
 }

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

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

                                                          {
 
   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 341 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 363 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:139

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

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 54 of file HGCalDDDConstants.h.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor::all(), 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:64

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

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

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

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

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

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

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

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

                                                   {
 
   if (mode_ == HGCalGeometryMode::Trapezoid) {
     return ((hgpar_->nPhiBinBH_[layerIndex(layer,true)] == hgpar_->nCellsFine_)
         ? 0 : 1);
   } else {
     return -1;
   }
 }

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

Definition at line 401 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 1091 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 406 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().

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

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

References HGCalParameters::firstModule_, getIndex(), hgpar_, HGCalParameters::iEtaMinBH_, and HGCalParameters::lastModule_.

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

                                                                        {
   const auto & indx  = getIndex(layer,true);
   if (indx.first < 0) return false;
   return ((ieta >= hgpar_->iEtaMinBH_[indx.first]) &&
       (ieta <= (hgpar_->iEtaMinBH_[indx.first]+
             hgpar_->lastModule_[indx.first]-
             hgpar_->firstModule_[indx.first])) &&
       (iphi > 0) && (iphi <= hgpar_->nPhiBinBH_[indx.first]));
 }

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

Definition at line 486 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(), getTrFormN(), and getTypeTrap().

                                                           {
   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 482 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(), getTrFormN(), HGCalDDDConstants(), HGCalTopology::HGCalTopology(), HGCalTriggerGeometryHexLayerBasedImp1::initialize(), isValidHex(), maxCells(), SimG4HGCalValidation::update(), and wafers().

                                                       {
   return tot_layers_[(int)reco];
 }

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

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

References hgpar_, and HGCalParameters::levelT_.

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

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

HGCalParameters::levelT_

std::vector< int > levelT_

Definition: HGCalParameters.h:107

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

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

Definition at line 502 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(), 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
	)		const

Definition at line 528 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseIndex_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineIndex_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, 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]);
   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];
     }
   } else {
     auto ktr = hgpar_->cellCoarseIndex_.find(kndx);
     if (ktr != hgpar_->cellCoarseIndex_.end()) {
       x = hgpar_->cellCoarseX_[ktr->second];
       y = hgpar_->cellCoarseY_[ktr->second];
     }
   }
   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;
   }
   return std::make_pair(x,y);
 }

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

Definition at line 564 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::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 581 of file HGCalDDDConstants.cc.

References funct::abs(), funct::cos(), PVValHelper::eta, HGCalParameters::etaMinBH_, JetChargeProducer_cfi::exp, getIndex(), hgpar_, HGCalParameters::k_ScaleToDDD, phi, alignCSCRings::r, funct::sin(), funct::tan(), x, y, z, and HGCalParameters::zLayerHex_.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalGeometryLoader::build(), HGCalGeometry::getCorners(), and getTrFormN().

                                                         {
   
   float x(0), y(0);
   const auto & indx = getIndex(lay,reco);
   if (indx.first >= 0) {
     ieta        = std::abs(ieta);
     double eta  = hgpar_->etaMinBH_ + (ieta-0.5)*indx.second;
     double phi  = (iphi-0.5)*indx.second;
     double z    = hgpar_->zLayerHex_[indx.first];
     double r    = z*std::tan(2.0*std::atan(std::exp(-eta)));
     x           = r*std::cos(phi);
     y           = r*std::sin(phi);
   }
   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 602 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 612 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::defineFull_, getIndex(), HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, hgpar_, gen::k, SiStripPI::max, mode_, N, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::nPhiBinBH_, 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_->nPhiBinBH_[index.first];
   } else {
     return 0;
   }
 }

int HGCalDDDConstants::maxCellUV ( ) const

inline

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

References modHalf_.

79 {return modHalf_;}

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:144

int HGCalDDDConstants::maxMoudlesPerLayer ( ) const

inline

Definition at line 80 of file HGCalDDDConstants.h.

References maxRows(), and maxWafersPerLayer_.

80 {return maxWafersPerLayer_;}

HGCalDDDConstants::maxWafersPerLayer_

int32_t maxWafersPerLayer_

Definition: HGCalDDDConstants.h:147

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

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

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

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

82 {return hgpar_->slopeMin_;}

HGCalParameters::slopeMin_

double slopeMin_

Definition: HGCalParameters.h:109

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

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

Definition at line 668 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 673 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 687 of file HGCalDDDConstants.cc.

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

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

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

int HGCalDDDConstants::numberCells ( bool reco ) const

Definition at line 692 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 703 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_, HGCalParameters::nPhiBinBH_, numberCellsHexagon(), 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_->nPhiBinBH_[i];
       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 737 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 749 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< int, int > HGCalDDDConstants::rowColumnWafer ( const int wafer ) const

Definition at line 759 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::scintType ( const float dPhi ) const

inline

Definition at line 92 of file HGCalDDDConstants.h.

References dPhiMin.

Referenced by assignCellTrap().

93 { return ((dPhi < dPhiMin) ? 0 : 1); }

HGCalDDDConstants::dPhiMin

const float dPhiMin

Definition: HGCalDDDConstants.h:136

particleFlow_cfi.dPhi

dPhi

Definition: particleFlow_cfi.py:78

int HGCalDDDConstants::sectors ( ) const

inline

Definition at line 94 of file HGCalDDDConstants.h.

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

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

94 {return hgpar_->nSectors_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:48

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

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

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

Referenced by HGCalGeometryLoader::build().

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:57

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 107 of file HGCalDDDConstants.h.

References waferMax_.

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

type

Definition: HCALResponse.h:21

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:149

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 806 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 829 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(), 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
	)		const

Definition at line 871 of file HGCalDDDConstants.cc.

References funct::abs(), cellHex(), HGCalParameters::cellThickness_, PVValHelper::dx, PVValHelper::dy, 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]);
     xx      -= hgpar_->waferPosX_[k];
     yy      -= hgpar_->waferPosY_[k];
     break;
       }
     }
   }
   if (std::abs(waferU) <= hgpar_->waferUVMax_) {
     cellHex(xx, yy, celltype, cellU, cellV);
     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 934 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 927 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 1120 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 108 of file HGCalDDDConstants.h.

References waferMax_.

108 {return waferMax_[1];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:149

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 109 of file HGCalDDDConstants.h.

References waferMax_, and waferPosition().

109 {return waferMax_[0];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:149

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

Definition at line 940 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 955 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 993 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 1007 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 112 of file HGCalDDDConstants.h.

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

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

HGCalParameters::sensorSeparation_

double sensorSeparation_

Definition: HGCalParameters.h:115

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

double HGCalDDDConstants::waferSize ( bool reco ) const

inline

Definition at line 113 of file HGCalDDDConstants.h.

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

Referenced by HGCalSD::update().

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

HGCalParameters::waferSize_

double waferSize_

Definition: HGCalParameters.h:113

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

int HGCalDDDConstants::waferToCopy ( int wafer ) const

inline

Definition at line 116 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferCopy_.

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

HGCalParameters::waferCopy_

std::vector< int > waferCopy_

Definition: HGCalParameters.h:87

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

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

Definition at line 973 of file HGCalDDDConstants.cc.

References HGCalGeometryMode::Hexagon, HGCalGeometryMode::Hexagon8, HGCalGeometryMode::Hexagon8Full, HGCalGeometryMode::HexagonFull, mode_, HGCSiliconDetId::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 = 1 + HGCSiliconDetId(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 120 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

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

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

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

HGCalParameters::waferTypeL_

std::vector< int > waferTypeL_

Definition: HGCalParameters.h:88

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

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

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

HGCalParameters::waferTypeT_

std::vector< int > waferTypeT_

Definition: HGCalParameters.h:89

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

int HGCalDDDConstants::waferUVMax ( ) const

inline

Definition at line 122 of file HGCalDDDConstants.h.

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

Referenced by HGCalTopology::HGCalTopology().

122 {return hgpar_->waferUVMax_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:139

HGCalParameters::waferUVMax_

int waferUVMax_

Definition: HGCalParameters.h:117

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

Definition at line 986 of file HGCalDDDConstants.cc.

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

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTBAnalyzer::analyzeRecHits(), HGCalTBAnalyzer::analyzeSimHits(), HGCalTriggerTools::getLayerZ(), 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]);
 }