#include <HGCalDDDConstants.h>

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

std::pair< int, int >	assignCellHexagon (float x, float y) const

std::pair< int, int >	assignCellSquare (float x, float y, float h, float bl, float tl, float alpha, float cellSize) const

double	cellSizeHex (int type) const

std::pair< int, int >	findCell (int cell, int lay, int subSec, bool reco) const

std::pair< int, int >	findCellSquare (int cell, float h, float bl, float tl, float alpha, float cellSize) const

HGCalGeometryMode::GeometryMode	geomMode () const

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

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

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

HGCalParameters::hgtrform	getTrForm (unsigned int k) const

unsigned int	getTrFormN () const

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

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

bool	isHalfCell (int waferType, int cell) const

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

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

unsigned int	layers (bool reco) const

unsigned int	layersInit (bool reco) const

int	levelTop () const

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

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

int	maxCells (bool reco) const

int	maxCells (int lay, bool reco) const

int	maxCellsSquare (float h, float bl, float tl, float alpha, float cellSize) const

int	maxModules () 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

std::pair< int, int >	newCell (int cell, int layer, int sector, int subsector, int incrx, int incry, bool half) const

std::pair< int, int >	newCell (int cell, int layer, int subsector, int incrz, bool half) const

int	newCell (int kx, int ky, int lay, int subSec) const

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

int	numberCellsHexagon (int wafer) const

std::vector< int >	numberCellsSquare (float h, float bl, float tl, float alpha, float cellSize) 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

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

int	waferMax () const

int	waferMin () const

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

int	wafers () const

int	wafers (int layer, int type) const

int	waferToCopy (int wafer) const

int	waferTypeL (int wafer) const

int	waferTypeT (int wafer) 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	getParameterSquare (int lay, int subSec, bool reco, float &h, float &bl, float &tl, float &alpha) const

bool	waferInLayer (int wafer, int lay) const

Private Attributes
double	hexside_

const HGCalParameters *	hgpar_

Simrecovecs	max_modules_layer_

HGCalGeometryMode::GeometryMode	mode_

int32_t	modHalf_

double	rmax_

std::array< uint32_t, 2 >	tot_layers_

int32_t	tot_wafers_

std::map< int, HGCWaferParam >	waferLayer_

std::array< int, 4 >	waferMax_

Static Private Attributes
static double	tan30deg_ = 0.5773502693

Detailed Description

this class reads the constant section of the numbering xml-files of the high granulairy calorimeter

Date: 2014/03/20 00:06:50

Author: Sunanda Banerjee, SINP sunan.nosp@m.da.b.nosp@m.anerj.nosp@m.ee@c.nosp@m.ern.c.nosp@m.h

Definition at line 23 of file HGCalDDDConstants.h.

Member Typedef Documentation

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

private

Definition at line 108 of file HGCalDDDConstants.h.

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

private

Definition at line 107 of file HGCalDDDConstants.h.

Constructor & Destructor Documentation

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

Definition at line 15 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, funct::cos(), gather_cfg::cout, getIndex(), getTrForm(), getTrFormN(), hexside_, hgpar_, mps_fire::i, k_ScaleFromDDD, HGCalParameters::hgtrform::lay, layers(), layersInit(), max_modules_layer_, maxCells(), HGCalParameters::mode_, mode_, modHalf_, modulesInit(), rmax_, sectors(), HGCalGeometryMode::Square, tan30deg_, tot_layers_, tot_wafers_, waferInLayer(), waferLayer_, waferMax_, HGCalParameters::waferR_, and wafers().

                                             : hgpar_(hp) {
   mode_ = hgpar_->mode_;
   if (mode_ == HGCalGeometryMode::Square) {
     rmax_    = 0;
     modHalf_ = sectors()*layers(true);
     for (int simreco = 0; simreco < 2; ++simreco ) {
       tot_layers_[simreco] = layersInit((bool)simreco);
     }
 
     edm::LogInfo("HGCalGeom") << "HGCalDDDConstants initialized for " << name
                   << " with " << layers(false) << ":" 
                   << layers(true) << " layers, " << sectors() 
                   << " sectors " << 2*modHalf_ << " modules and "
                   << "maximum of " << maxCells(false) << ":" 
                   << maxCells(true) << " cells";
 #ifdef EDM_ML_DEBUG
     std::cout << "HGCalDDDConstants initialized for " << name << " with " 
           << layers(false) << ":" << layers(true) << " layers, " 
           << sectors() << " sectors and maximum of " << maxCells(false)
           << ":" << maxCells(true) << " cells" << std::endl;
 #endif
   } else {
     rmax_     = k_ScaleFromDDD * (hgpar_->waferR_) * std::cos(30.0*CLHEP::deg);
     hexside_  = 2.0 * rmax_ * tan30deg_;
 #ifdef EDM_ML_DEBUG
     std::cout << "rmax_ " << rmax_ << ":" << hexside_ << " CellSize " 
           << 0.5*k_ScaleFromDDD*hgpar_->cellSize_[0] << ":" 
           << 0.5*k_ScaleFromDDD*hgpar_->cellSize_[1] << std::endl;
 #endif
     // init maps and constants
     modHalf_ = 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];
 #ifdef EDM_ML_DEBUG
       std::cout << "Layer " << layer << " with " << max_modules_layer_[simreco][layer] << ":" << modHalf_ << " modules\n";
 #endif
     }
       }
     }
     tot_wafers_ = wafers();
     
     edm::LogInfo("HGCalGeom") << "HGCalDDDConstants initialized for " << name
                   << " with " << layers(false) << ":" 
                   << layers(true) << " layers, " << wafers() 
                   << ":" << 2*modHalf_ << " wafers and "
                   << "maximum of " << maxCells(false) << ":" 
                   << maxCells(true) << " cells";
     
 #ifdef EDM_ML_DEBUG
     std::cout << "HGCalDDDConstants initialized for " << name << " with " 
           << layers(false) << ":" << layers(true) << " layers, " 
           << wafers() << " wafers and " << "maximum of " << maxCells(false)
           << ":" << maxCells(true) << " cells" << std::endl;
 #endif
     
   }  
   
   int wminT(9999999), wmaxT(0), kount1(0), kount2(0);
   for (unsigned int i=0; i<getTrFormN(); ++i) {
     int lay0 = getTrForm(i).lay;
     int wmin(9999999), wmax(0), kount(0);
     for (int wafer=0; wafer<sectors(); ++wafer) {
       if (waferInLayer(wafer,lay0,true)) {
     if (wafer < wmin) wmin = wafer;
     if (wafer > wmax) wmax = wafer;
     ++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;
     std::cout << "Index " << i << " Layer " << lay0 << ":" << lay1 
           << " Wafer " << wmin << ":" << wmax << ":" << kount << std::endl;
 #endif
     HGCWaferParam a1{ {wmin,wmax,kount} };
     waferLayer_[lay0] = a1;
   }
   waferMax_ = std::array<int,4>{ {wminT,wmaxT,kount1,kount2} };
 #ifdef EDM_ML_DEBUG
   std::cout << "Overall wafer statistics: " << wminT << ":" << wmaxT << ":"
         << kount1 << ":" << kount2 << std::endl;
 #endif
 }

HGCalDDDConstants::~HGCalDDDConstants ( )

Definition at line 108 of file HGCalDDDConstants.cc.

108 {}

Member Function Documentation

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

Definition at line 110 of file HGCalDDDConstants.cc.

References alpha, assignCellHexagon(), assignCellSquare(), getIndex(), getParameterSquare(), h, mps_fire::i, diffTreeTool::index, k_ScaleFromDDD, mode_, trackingPlots::reco, HGCalGeometryMode::Square, geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

Referenced by HGCNumberingScheme::assignCell(), HGCalGeometry::getClosestCell(), HGCNumberingScheme::getUnitID(), and newCell().

                                                       {
   std::pair<int,float> index = getIndex(lay, reco);
   std::pair<int,int> cellAssignment(-1,-1);
   int i = index.first;
   if (i < 0) return cellAssignment;
   if (mode_ == HGCalGeometryMode::Square) {
     float alpha, h, bl, tl;
     getParameterSquare(i,subSec,reco,h,bl,tl,alpha);
     cellAssignment = assignCellSquare(x, y, h, bl, tl, alpha, index.second);
   } else {
     float xx = (reco) ? x : k_ScaleFromDDD*x;
     float yy = (reco) ? y : k_ScaleFromDDD*y;
     cellAssignment = assignCellHexagon(xx,yy);
   }
   return cellAssignment;
 }

std::pair< int, int > HGCalDDDConstants::assignCellHexagon	(	float	x,
		float	y
	)		const

Definition at line 171 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellHex(), HGCalParameters::cellSize_, hgpar_, k_ScaleFromDDD, rmax_, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

Referenced by assignCell().

                                            {
   double xx(x), yy(y);
   //First the wafer
   int wafer = cellHex(xx, yy, rmax_, hgpar_->waferPosX_, hgpar_->waferPosY_);
   // Now the cell
   xx -= hgpar_->waferPosX_[wafer];
   yy -= hgpar_->waferPosY_[wafer];
   int cell(0);
   if (hgpar_->waferTypeT_[wafer] == 1) 
     cell  = cellHex(xx, yy, 0.5*k_ScaleFromDDD*hgpar_->cellSize_[0], hgpar_->cellFineX_, hgpar_->cellFineY_);
   else
     cell  = cellHex(xx, yy, 0.5*k_ScaleFromDDD*hgpar_->cellSize_[1], hgpar_->cellCoarseX_, hgpar_->cellCoarseY_);
   return std::pair<int,int>(wafer,cell);
 }

std::pair< int, int > HGCalDDDConstants::assignCellSquare	(	float	x,
		float	y,
		float	h,
		float	bl,
		float	tl,
		float	alpha,
		float	cellSize
	)		const

Definition at line 128 of file HGCalDDDConstants.cc.

References a, b, h, and k_horizontalShift.

Referenced by assignCell().

                                                      {
 
   float a     = (alpha==0) ? (2*h/(tl-bl)) : (h/(tl-bl));
   float b     = 2*h*bl/(tl-bl);
  
   float x0(x);
   int phiSector = (x0 > 0) ? 1 : 0;
   if      (alpha < 0) {x0 -= 0.5*(tl+bl); phiSector = 0;}
   else if (alpha > 0) {x0 += 0.5*(tl+bl); phiSector = 1;}
   
     //determine the i-y
   int ky    = floor((y+h)/cellSize);
   if (ky*cellSize> y+h) ky--;
   if (ky<0)             return std::pair<int,int>(-1,-1);
   if ((ky+1)*cellSize < (y+h) ) ky++;
   int max_ky_allowed=floor(2*h/cellSize);
   if (ky>max_ky_allowed-1) return std::pair<int,int>(-1,-1);
     
   //determine the i-x
   //notice we substitute y by the top of the candidate cell to reduce the dead zones
   int kx    = floor(fabs(x0)/cellSize);
   if (kx*cellSize > fabs(x0) ) kx--;
   if (kx<0)                    return std::pair<int,int>(-1,-1);
   if ((kx+1)*cellSize < fabs(x0)) kx++;
   int max_kx_allowed=floor( ((ky+1)*cellSize+b+k_horizontalShift*cellSize)/(a*cellSize) );
   if (kx>max_kx_allowed-1) return std::pair<int,int>(-1,-1);
   
   //count cells summing in rows until required height
   //notice the bottom of the cell must be used
   int icell(0);
   for (int iky=0; iky<ky; ++iky) {
     int cellsInRow( floor( ((iky+1)*cellSize+b+k_horizontalShift*cellSize)/(a*cellSize) ) );
     icell += cellsInRow;
   }
   icell += kx;
 
   //return result
   return std::pair<int,int>(phiSector,icell);
 }

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

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

Referenced by assignCellHexagon(), getTrForm(), and waferFromPosition().

                                                         {
   int num(0);
   const double tol(0.00001);
   double cellY = 2.0*cellR*tan30deg_;
   for (unsigned int k=0; k<posX.size(); ++k) {
     double dx = std::abs(xx - posX[k]);
     double dy = std::abs(yy - posY[k]);
     if (dx <= (cellR+tol) && dy <= (cellY+tol)) {
       double xmax = (dy<=0.5*cellY) ? cellR : (cellR-(dy-0.5*cellY)/tan30deg_);
       if (dx <= (xmax+tol)) {
     num = k;
     break;
       }
     }
   }
   return num;
 }

double HGCalDDDConstants::cellSizeHex ( int type ) const

Definition at line 187 of file HGCalDDDConstants.cc.

References HGCalParameters::cellSize_, hgpar_, and k_ScaleFromDDD.

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

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

std::pair< int, int > HGCalDDDConstants::findCell	(	int	cell,
		int	lay,
		int	subSec,
		bool	reco
	)		const

Definition at line 193 of file HGCalDDDConstants.cc.

References alpha, findCellSquare(), getIndex(), getParameterSquare(), h, mps_fire::i, diffTreeTool::index, mode_, and HGCalGeometryMode::Square.

Referenced by locateCell(), and newCell().

                                             {
 
   std::pair<int,float> index = getIndex(lay, reco);
   int i = index.first;
   if (i < 0) return std::pair<int,int>(-1,-1);
   if (mode_ != HGCalGeometryMode::Square) {
     return std::pair<int,int>(-1,-1);
   } else {
     float alpha, h, bl, tl;
     getParameterSquare(i,subSec,reco,h,bl,tl,alpha);
     return findCellSquare(cell, h, bl, tl, alpha, index.second);
   }
 }

std::pair< int, int > HGCalDDDConstants::findCellSquare	(	int	cell,
		float	h,
		float	bl,
		float	tl,
		float	alpha,
		float	cellSize
	)		const

Definition at line 208 of file HGCalDDDConstants.cc.

References a, b, and k_horizontalShift.

Referenced by findCell(), and simToReco().

                                                    {
 
   //check if cell number is meaningful
   if(cell<0) return std::pair<int,int>(-1,-1);
     
   //parameterization of the boundary of the trapezoid
   float a     = (alpha==0) ? (2*h/(tl-bl)) : (h/(tl-bl));
   float b     = 2*h*bl/(tl-bl);
   int kx(cell), ky(0);
   int kymax( floor((2*h)/cellSize) );
   int testCell(0);
   for (int iky=0; iky<kymax; ++iky) {
 
     //check if adding all the cells in this row is above the required cell
     //notice the top of the cell is used to maximize space
     int cellsInRow(floor(((iky+1)*cellSize+b+k_horizontalShift*cellSize)/(a*cellSize)));
     if (testCell+cellsInRow > cell) break;
     testCell += cellsInRow;
     ky++;
     kx -= cellsInRow;
   }
 
   return std::pair<int,int>(kx,ky);
 }

HGCalGeometryMode::GeometryMode HGCalDDDConstants::geomMode ( ) const

inline

Definition at line 40 of file HGCalDDDConstants.h.

References isValid(), isValidCell(), layers(), layersInit(), locateCell(), locateCellHex(), mod(), and mode_.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalGeometry::getClosestCell(), HGCNumberingScheme::getUnitID(), HGCalTopology::HGCalTopology(), HGCSD::update(), and SimG4HGCalValidation::update().

40 {return mode_;}

HGCalDDDConstants::mode_

HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:112

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

Definition at line 781 of file HGCalDDDConstants.cc.

References HGCalParameters::depthIndex_, HGCalParameters::depthLayerF_, hgpar_, HGCalParameters::layerIndex_, mode_, HGCalParameters::moduleCellR_, HGCalParameters::moduleCellS_, and HGCalGeometryMode::Square.

Referenced by assignCell(), findCell(), getTrForm(), HGCalDDDConstants(), locateCell(), maxCells(), maxRows(), modules(), modulesInit(), newCell(), numberCells(), simToReco(), waferInLayer(), and waferZ().

                                                                        {
 
   if (lay<1 || lay>(int)(hgpar_->layerIndex_.size())) return std::pair<int,float>(-1,0);
   if (reco && lay>(int)(hgpar_->depthIndex_.size()))  return std::pair<int,float>(-1,0);
   int   indx(0);
   float cell(0);
   if (mode_ == HGCalGeometryMode::Square) {
     indx = (reco ? hgpar_->depthIndex_[lay-1] : hgpar_->layerIndex_[lay-1]);
     cell = (reco ? hgpar_->moduleCellR_[indx] : hgpar_->moduleCellS_[indx]);
   } else {
     indx = (reco ? hgpar_->depthLayerF_[lay-1] : hgpar_->layerIndex_[lay-1]);
     cell = (reco ? hgpar_->moduleCellR_[0] : hgpar_->moduleCellS_[0]);
   }
   return std::pair<int,float>(indx,cell);
 }

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

Definition at line 236 of file HGCalDDDConstants.cc.

References HGCalParameters::getModule(), hgpar_, reco::if(), and HGCalParameters::waferTypeL_.

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

                                               {
 
   HGCalParameters::hgtrap mytr;
   if (hexType) {
     unsigned int type = (indx < hgpar_->waferTypeL_.size()) ? 
       hgpar_->waferTypeL_[indx] : 3;
     if (type > 0) --type;
     mytr = hgpar_->getModule(type, true);
   }  else {
     if (reco) mytr = hgpar_->getModule(indx,true);
     else      mytr = hgpar_->getModule(indx,false);
   }
   return mytr;
 }

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

Definition at line 253 of file HGCalDDDConstants.cc.

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

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

void HGCalDDDConstants::getParameterSquare	(	int	lay,
		int	subSec,
		bool	reco,
		float &	h,
		float &	bl,
		float &	tl,
		float &	alpha
	)		const

private

Definition at line 797 of file HGCalDDDConstants.cc.

References alpha, hgpar_, HGCalParameters::moduleAlphaR_, HGCalParameters::moduleAlphaS_, HGCalParameters::moduleBlR_, HGCalParameters::moduleBlS_, HGCalParameters::moduleHR_, HGCalParameters::moduleHS_, HGCalParameters::moduleTlR_, and HGCalParameters::moduleTlS_.

Referenced by assignCell(), findCell(), getTrForm(), locateCell(), maxCells(), and numberCells().

                                            {
   if (reco) {
     h    =  hgpar_->moduleHR_[lay];
     bl   =  hgpar_->moduleBlR_[lay];
     tl   =  hgpar_->moduleTlR_[lay];
     alpha=  hgpar_->moduleAlphaR_[lay];
     if ((subSec>0 && alpha<0) || (subSec<=0 && alpha>0)) alpha = -alpha;
   } else {
     h    =  hgpar_->moduleHS_[lay];
     bl   =  hgpar_->moduleBlS_[lay];
     tl   =  hgpar_->moduleTlS_[lay];
     alpha=  hgpar_->moduleAlphaS_[lay];
   }
 }

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

inline

Definition at line 94 of file HGCalDDDConstants.h.

References cellHex(), getIndex(), getParameterSquare(), HGCalParameters::getTrForm(), getTrForms(), hgpar_, RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, waferInLayer(), geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

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

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

HGCalParameters::getTrForm

hgtrform getTrForm(unsigned int k) const

Definition: HGCalParameters.cc:108

gen::k

int k[5][pyjets_maxn]

Definition: Cascade2Hadronizer.cc:79

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 93 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::trformIndex_.

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:67

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

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

Definition at line 261 of file HGCalDDDConstants.cc.

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

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

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

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

Definition at line 755 of file HGCalDDDConstants.cc.

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

Referenced by hgcal::RecHitTools::isHalfCell().

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

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

Definition at line 269 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, HGCalParameters::copiesInLayers_, gather_cfg::cout, hgpar_, createfilelist::int, isValidCell(), layers(), maxCells(), mod(), mode_, modmax, convertSQLiteXML::ok, sectors(), HGCalGeometryMode::Square, HGCalParameters::waferCopy_, and HGCalParameters::waferTypeT_.

Referenced by ntupleDataFormat._Object::_checkIsValid(), geomMode(), HGCNumberingScheme::getUnitID(), core.AutoHandle.AutoHandle::ReallyLoad(), and HGCalTopology::valid().

                                                                            {
 
   bool ok(false);
   int  cellmax(0), modmax(0);
   if (mode_ == HGCalGeometryMode::Square) {
     cellmax = maxCells(lay,reco);
     modmax  = sectors();
     ok      = ((lay > 0 && lay <= (int)(layers(reco))) && 
            (mod > 0 && mod <= modmax) &&
            (cell >=0 && cell <= cellmax));
   } else {
     int32_t copyNumber = hgpar_->waferCopy_[mod];
     ok = ((lay > 0 && lay <= (int)(layers(reco))));
     if (ok) {
       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);
       ok = (moditr != the_modules.end());
 #ifdef EDM_ML_DEBUG
       if (!ok) std::cout << "HGCalDDDConstants: Layer " << lay << ":" 
              << lay_idx << " Copy " << copyNumber << ":" << mod
              << " Flag " << ok << std::endl;
 #endif
       if (ok) {
     if (moditr->second >= 0) {
       cellmax = (hgpar_->waferTypeT_[mod]==1) ? 
         (int)(hgpar_->cellFineX_.size()) : (int)(hgpar_->cellCoarseX_.size());
       ok = (cell >=0 && cell <=  cellmax);
     } else {
       ok = isValidCell(lay_idx, mod, cell);
     }
       }
     }
   }
     
 #ifdef EDM_ML_DEBUG
   if (!ok) std::cout << "HGCalDDDConstants: Layer " << lay << ":" 
              << (lay > 0 && (lay <= (int)(layers(reco)))) << " Module "
              << mod << ":" << modmax << ":" 
              << (mod > 0 && mod <= modmax) << " Cell " << cell << ":"
              << cellmax << ":" << (cell >=0 && cell <= cellmax)
              << ":" << maxCells(reco) << std::endl; 
 #endif
   return ok;
 }

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

Definition at line 315 of file HGCalDDDConstants.cc.

References HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, gather_cfg::cout, hgpar_, convertSQLiteXML::ok, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, findQualityFiles::rr, mathSSE::sqrt(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, x, and y.

Referenced by geomMode(), and isValid().

                                                                       {
 
   // Calculate the position of the cell
   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   ok = ((rr >= hgpar_->rMinLayHex_[lay-1]) &
            (rr <= hgpar_->rMaxLayHex_[lay-1]));
 #ifdef EDM_ML_DEBUG
   if (!ok) 
     std::cout << "Input " << lay << ":" << wafer << ":" << cell << " Position "
           << x << ":" << y << ":" << rr << " Compare Limits " 
           << hgpar_->rMinLayHex_[lay-1] << ":" <<hgpar_->rMaxLayHex_[lay-1]
           << " Flag " << ok << std::endl;
 #endif
   return ok;
 }

unsigned int HGCalDDDConstants::layers ( bool reco ) const

Definition at line 340 of file HGCalDDDConstants.cc.

References createfilelist::int, and tot_layers_.

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

                                                       {
   return tot_layers_[(int)reco];
 }

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

Definition at line 344 of file HGCalDDDConstants.cc.

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

Referenced by geomMode(), and HGCalDDDConstants().

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

int HGCalDDDConstants::levelTop ( ) const

inline

Definition at line 48 of file HGCalDDDConstants.h.

References hgpar_, HGCalParameters::levelT_, maxCells(), and maxCellsSquare().

Referenced by HGCSD::update().

48 {return hgpar_->levelT_;}

HGCalParameters::levelT_

int levelT_

Definition: HGCalParameters.h:108

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

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

Definition at line 348 of file HGCalDDDConstants.cc.

References alpha, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, findCell(), getIndex(), getParameterSquare(), h, hgpar_, mps_fire::i, diffTreeTool::index, k_ScaleFromDDD, mode_, HGCalGeometryMode::Square, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferTypeT_, x, and y.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTBAnalyzer::analyzeSimHits(), geomMode(), HGCalGeometry::getCorners(), HGCNumberingScheme::getLocalCoords(), HGCalGeometry::getPosition(), and newCell().

                                                         {
   // type refers to subsector # for square cell and wafer # for hexagon cell
   float x(999999.), y(999999.);
   std::pair<int,float> index = getIndex(lay, reco);
   int i = index.first;
   if (i < 0) return std::pair<float,float>(x,y);
   if (mode_ == HGCalGeometryMode::Square) {
     std::pair<int,int> kxy = findCell(cell, lay, type, reco);
     float alpha, h, bl, tl;
     getParameterSquare(i,type,reco,h,bl,tl,alpha);
     float cellSize = index.second;
     x              = (kxy.first+0.5)*cellSize;
     if      (alpha < 0) x -= 0.5*(tl+bl);
     else if (alpha > 0) x -= 0.5*(tl+bl);
     if (type != 1) x = -x;
     y              = ((kxy.second+0.5)*cellSize-h);
   } else {
     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           /= k_ScaleFromDDD;
       y           /= k_ScaleFromDDD;
     }
   }
   return std::pair<float,float>(x,y);
 }

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

Definition at line 383 of file HGCalDDDConstants.cc.

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

Referenced by geomMode(), HGCalGeometry::getCorners(), and HGCalGeometry::getPosition().

                                              {
   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 /= k_ScaleFromDDD;
     y /= k_ScaleFromDDD;
   }
   return std::pair<float,float>(x,y);
 }

int HGCalDDDConstants::maxCells ( bool reco ) const

Definition at line 400 of file HGCalDDDConstants.cc.

References HGCalParameters::depth_, hgpar_, mps_fire::i, HGCalParameters::layer_, and layers().

Referenced by HGCalDDDConstants(), HGCalTopology::HGCalTopology(), isValid(), levelTop(), HGCalGeometry::newCell(), and newCell().

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

References alpha, HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, getIndex(), getParameterSquare(), h, hgpar_, mps_fire::i, diffTreeTool::index, gen::k, maxCellsSquare(), mode_, HGCalGeometryMode::Square, waferInLayer(), and HGCalParameters::waferTypeT_.

                                                         {
 
   std::pair<int,float> index = getIndex(lay, reco);
   int i = index.first;
   if (i < 0) return 0;
   if (mode_ == HGCalGeometryMode::Square) {
     float h, bl, tl, alpha;
     getParameterSquare(i,0,reco,h,bl,tl,alpha);
     return maxCellsSquare(h, bl, tl, alpha, index.second);
   } else {
     unsigned int cells(0);
     for (unsigned int k=0; k<hgpar_->waferTypeT_.size(); ++k) {
       if (waferInLayer(k,index.first)) {
     unsigned int cell = (hgpar_->waferTypeT_[k]==1) ? 
       (hgpar_->cellFineX_.size()) : (hgpar_->cellCoarseX_.size());
     if (cell > cells) cells = cell;
       }
     }
     return (int)(cells);
   }
 }

int HGCalDDDConstants::maxCellsSquare	(	float	h,
		float	bl,
		float	tl,
		float	alpha,
		float	cellSize
	)		const

Definition at line 432 of file HGCalDDDConstants.cc.

References a, b, and k_horizontalShift.

Referenced by levelTop(), and maxCells().

                                                          {
 
   float a     = (alpha==0) ? (2*h/(tl-bl)) : (h/(tl-bl));
   float b     = 2*h*bl/(tl-bl);
   
   int   ncells(0);
   //always use the top of the cell to maximize space
   int   kymax = floor((2*h)/cellSize);
   for (int iky=0; iky<kymax; ++iky) {
     int cellsInRow=floor(((iky+1)*cellSize+b+k_horizontalShift*cellSize)/(a*cellSize));
     ncells += cellsInRow;
   }
 
   return ncells;
 }

int HGCalDDDConstants::maxModules ( ) const

inline

Definition at line 53 of file HGCalDDDConstants.h.

References maxRows(), and modHalf_.

53 {return modHalf_;}

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:113

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

Definition at line 449 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, mps_fire::i, diffTreeTool::index, gen::k, mode_, HGCalParameters::moduleHR_, HGCalParameters::moduleHS_, trackingPlots::reco, HGCalGeometryMode::Square, HGCalParameters::waferCopy_, and waferInLayer().

Referenced by maxModules(), and newCell().

                                                        {
 
   int kymax(0);
   std::pair<int,float> index = getIndex(lay, reco);
   int i = index.first;
   if (i < 0) return kymax;
   if (mode_ == HGCalGeometryMode::Square) {
     float h = (reco) ? hgpar_->moduleHR_[i] : hgpar_->moduleHS_[i];
     kymax   = floor((2*h)/index.second);
   } else {
     for (unsigned int k=0; k<hgpar_->waferCopy_.size(); ++k) {
       if (waferInLayer(k,i)) {
     int ky = ((hgpar_->waferCopy_[k])/100)%100;
     if (ky > kymax) kymax = ky;
       }
     }
   }
   return kymax;
 }

double HGCalDDDConstants::minSlope ( ) const

inline

Definition at line 55 of file HGCalDDDConstants.h.

References hgpar_, modules(), modulesInit(), newCell(), numberCells(), numberCellsHexagon(), numberCellsSquare(), rowColumnWafer(), and HGCalParameters::slopeMin_.

Referenced by HGCSD::update().

55 {return hgpar_->slopeMin_;}

HGCalParameters::slopeMin_

double slopeMin_

Definition: HGCalParameters.h:110

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

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

Definition at line 469 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;
   return max_modules_layer_[(int)reco][lay];
 }

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

Definition at line 474 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, diffTreeTool::index, gen::k, waferInLayer(), and HGCalParameters::waferPosX_.

Referenced by HGCalDDDConstants(), and minSlope().

                                                            {
   int nmod(0);
   std::pair<int,float> index = getIndex(lay, reco);
   if (index.first < 0) return nmod;
   for (unsigned int k=0; k<hgpar_->waferPosX_.size(); ++k) {
     if (waferInLayer(k,index.first)) ++nmod;
   }
   return nmod;
 }

std::pair< int, int > HGCalDDDConstants::newCell	(	int	cell,
		int	layer,
		int	sector,
		int	subsector,
		int	incrx,
		int	incry,
		bool	half
	)		const

Definition at line 484 of file HGCalDDDConstants.cc.

References findCell(), hgpar_, maxCells(), maxRows(), and HGCalParameters::nSectors_.

Referenced by HGCalTopology::changeXY(), HGCalTopology::changeZ(), and minSlope().

                                                       {
 
   int subSec = half ? subsector : 0;
   std::pair<int,int> kxy = findCell(cell, layer, subSec, true);
   int kx = kxy.first + incrx;
   int ky = kxy.second + incry;
   if (ky < 0 || ky > maxRows(layer, true)) {
     cell = maxCells(true);
     return std::pair<int,int>(cell,sector*subsector);
   } else if (kx < 0) {
     kx        =-kx;
     subsector =-subsector;
   } else if (kx > maxCells(layer, true)) {
     kx       -= maxCells(layer, true);
     sector   += subsector;
     subsector =-subsector;
     if (sector < 1)                      sector = hgpar_->nSectors_;
     else if (sector > hgpar_->nSectors_) sector = 1;
   }
   cell = newCell(kx, ky, layer, subSec);
   return std::pair<int,int>(cell,sector*subsector);
 }

std::pair< int, int > HGCalDDDConstants::newCell	(	int	cell,
		int	layer,
		int	subsector,
		int	incrz,
		bool	half
	)		const

Definition at line 509 of file HGCalDDDConstants.cc.

References assignCell(), layers(), locateCell(), and geometryCSVtoXML::xy.

                                                       {
  
   int layer = lay + incrz;
   if (layer <= 0 || layer > (int)(layers(true))) return std::pair<int,int>(cell,0);
   int subSec = half ? subsector : 0;
   std::pair<float,float> xy = locateCell(cell, lay, subSec, true);
   std::pair<int,int>     kcell = assignCell(xy.first, xy.second, layer, subSec,
                         true);
   return std::pair<int,int>(kcell.second,layer);
 }

int HGCalDDDConstants::newCell	(	int	kx,
		int	ky,
		int	lay,
		int	subSec
	)		const

Definition at line 521 of file HGCalDDDConstants.cc.

References a, alpha, b, getIndex(), hgpar_, mps_fire::i, diffTreeTool::index, k_horizontalShift, maxCells(), HGCalParameters::moduleAlphaS_, HGCalParameters::moduleBlR_, HGCalParameters::moduleHR_, and HGCalParameters::moduleTlR_.

                                                                         {
 
   std::pair<int,float> index = getIndex(lay, true);
   int i = index.first;
   if (i < 0) return maxCells(true);
   float alpha    = (subSec == 0) ? hgpar_->moduleAlphaS_[i] : subSec;
   float cellSize = index.second;
   float a        = (alpha==0) ? 
     (2*hgpar_->moduleHR_[i]/(hgpar_->moduleTlR_[i]-hgpar_->moduleBlR_[i])) :
     (hgpar_->moduleHR_[i]/(hgpar_->moduleTlR_[i]-hgpar_->moduleBlR_[i]));
   float b        = 2*hgpar_->moduleHR_[i]*hgpar_->moduleBlR_[i]/
     (hgpar_->moduleTlR_[i]-hgpar_->moduleBlR_[i]);
   int icell(kx);
   for (int iky=0; iky<ky; ++iky)
     icell += floor(((iky+1)*cellSize+b+k_horizontalShift*cellSize)/(a*cellSize));
   return icell;
 }

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

Definition at line 539 of file HGCalDDDConstants.cc.

References alpha, HGCalParameters::cellCoarseX_, HGCalParameters::cellFineX_, getIndex(), getParameterSquare(), h, hgpar_, mps_fire::i, diffTreeTool::index, gen::k, mode_, numberCellsSquare(), HGCalGeometryMode::Square, waferInLayer(), and HGCalParameters::waferTypeT_.

Referenced by minSlope().

                                                                       {
 
   std::pair<int,float> index = getIndex(lay, reco);
   int i = index.first;
   std::vector<int> ncell;
   if (i >= 0) {
     if (mode_ == HGCalGeometryMode::Square) {
       float h, bl, tl, alpha;
       getParameterSquare(i,0,reco,h,bl,tl,alpha);
       return numberCellsSquare(h, bl, tl, alpha, index.second);
     } else {
       for (unsigned int k=0; k<hgpar_->waferTypeT_.size(); ++k) {
     if (waferInLayer(k,i)) {
       unsigned int cell = (hgpar_->waferTypeT_[k]==1) ? 
         (hgpar_->cellFineX_.size()) : (hgpar_->cellCoarseX_.size());
       ncell.emplace_back((int)(cell));
     }
       }
     }
   }
   return ncell;
 }

int HGCalDDDConstants::numberCellsHexagon ( int wafer ) const

Definition at line 575 of file HGCalDDDConstants.cc.

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

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

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

std::vector< int > HGCalDDDConstants::numberCellsSquare	(	float	h,
		float	bl,
		float	tl,
		float	alpha,
		float	cellSize
	)		const

Definition at line 562 of file HGCalDDDConstants.cc.

References a, b, and k_horizontalShift.

Referenced by minSlope(), and numberCells().

                                                     {
 
   float a     = (alpha==0) ? (2*h/(tl-bl)) : (h/(tl-bl));
   float b     = 2*h*bl/(tl-bl);
   int   kymax = floor((2*h)/cellSize);
   std::vector<int> ncell;
   for (int iky=0; iky<kymax; ++iky)
     ncell.emplace_back(floor(((iky+1)*cellSize+b+k_horizontalShift*cellSize)/(a*cellSize)));
   return ncell;
 }

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

Definition at line 587 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::pair<int,int>(row,col);
 }

int HGCalDDDConstants::sectors ( ) const

inline

Definition at line 68 of file HGCalDDDConstants.h.

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

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

68 {return hgpar_->nSectors_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:51

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

Definition at line 599 of file HGCalDDDConstants.cc.

References a, b, HGCalParameters::cellFactor_, gather_cfg::cout, particleFlowClusterECALTimeSelected_cfi::depth, findCellSquare(), getIndex(), hgpar_, mps_fire::i, diffTreeTool::index, k_horizontalShift, HGCalParameters::layerGroup_, HGCalParameters::layerGroupM_, HGCalParameters::layerGroupO_, mod(), mode_, HGCalParameters::moduleAlphaS_, HGCalParameters::moduleBlS_, HGCalParameters::moduleHS_, HGCalParameters::moduleTlS_, HGCalGeometryMode::Square, and HGCalParameters::waferTypeL_.

Referenced by HGCalTimingAnalyzer::analyzeSimHits(), HGCalTBAnalyzer::analyzeSimHits(), CaloTruthAccumulator::fillSimHits(), HGCalTriggerBackend::HGCalTriggerSimCluster< FECODEC, DATA >::run(), sectors(), HGCalTriggerNtupleHGCTriggerCells::simhits(), and HGCalTriggerNtupleHGCDigis::simhits().

                                          {
   
   std::pair<int,float> index = getIndex(lay, false);
   int i = index.first;
   if (i < 0) {
     return std::pair<int,int>(-1,-1);
   }
   int kx(-1), depth(-1);
   if (mode_ == HGCalGeometryMode::Square) {
     float h  = hgpar_->moduleHS_[i];
     float bl = hgpar_->moduleBlS_[i];
     float tl = hgpar_->moduleTlS_[i];
     float cellSize = hgpar_->cellFactor_[i]*index.second;
   
     std::pair<int,int> kxy = findCellSquare(cell, h, bl, tl, hgpar_->moduleAlphaS_[i], index.second);
     depth       = hgpar_->layerGroup_[i];
     if (depth<0) return std::pair<int,int>(-1,-1);
     kx          = kxy.first/hgpar_->cellFactor_[i];
     int ky      = kxy.second/hgpar_->cellFactor_[i];
 
     float a     = (half) ? (h/(tl-bl)) : (2*h/(tl-bl));
     float b     = 2*h*bl/(tl-bl);
     for (int iky=0; iky<ky; ++iky)
       kx += floor(((iky+1)*cellSize+b+k_horizontalShift*cellSize)/(a*cellSize));
 #ifdef EDM_ML_DEBUG
     std::cout << "simToReco: input " << cell << ":" << lay << ":" << half
           << " kxy " << kxy.first << ":" << kxy.second << " output "
           << kx << ":" << depth << " cell factor=" 
           << hgpar_->cellFactor_[i] << std::endl;
 #endif
   } else {
     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::pair<int,int>(kx,depth);
 }

unsigned int HGCalDDDConstants::volumes ( ) const

inline

Definition at line 70 of file HGCalDDDConstants.h.

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

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

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:60

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

int HGCalDDDConstants::waferCount ( const int type ) const

inline

Definition at line 76 of file HGCalDDDConstants.h.

References waferMax_.

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

type

Definition: HCALResponse.h:21

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:117

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 644 of file HGCalDDDConstants.cc.

References gather_cfg::cout, hgpar_, gen::k, convertSQLiteXML::ok, and HGCalParameters::waferCopy_.

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

                                                    {
   const int ncopies = hgpar_->waferCopy_.size();
   int  wafer(ncopies);
 #ifdef EDM_ML_DEBUG
   bool ok(false);
 #endif
   for (int k=0; k<ncopies; ++k) {
     if (copy == hgpar_->waferCopy_[k]) {
       wafer = k;
 #ifdef EDM_ML_DEBUG
       ok = true;
 #endif
       break;
     }
   }
 #ifdef EDM_ML_DEBUG
   if (!ok) {
     std::cout << "Cannot find " << copy << " in a list of " << ncopies << "\n";
     for (int k=0; k<ncopies; ++k) std::cout << " " << hgpar_->waferCopy_[k];
     std::cout << std::endl;
   }
 #endif
   return wafer;
 }

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

Definition at line 669 of file HGCalDDDConstants.cc.

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

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

                                           {
 
   double xx(k_ScaleFromDDD*x), yy(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 <= (2.*rmax_-dy/tan30deg_))) {
     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*k_ScaleFromDDD*hgpar_->cellSize_[0], 
                hgpar_->cellFineX_, hgpar_->cellFineY_);
     else
       icell  = cellHex(xx, yy, 0.5*k_ScaleFromDDD*hgpar_->cellSize_[1],
                hgpar_->cellCoarseX_, hgpar_->cellCoarseY_);
   }
 #ifdef EDM_ML_DEBUG
   std::cout << "Position " << x << ":" << y << " Wafer " << wafer << ":" 
         << size_ << " XX " << xx << ":" << yy << " Cell " << icell 
         << " Type " << celltyp << std::endl;
 #endif
 }

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

Definition at line 704 of file HGCalDDDConstants.cc.

References getIndex().

Referenced by HGCalGeometryLoader::build(), HGCalGeometry::getSummary(), getTrForm(), HGCalDDDConstants(), maxCells(), maxRows(), modulesInit(), numberCells(), and volumes().

                                                                         {
 
   std::pair<int,float> indx = getIndex(lay, reco);
   if (indx.first < 0) return false;
   return waferInLayer(wafer,indx.first);
 }

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

private

Definition at line 814 of file HGCalDDDConstants.cc.

References HGCalGeometryMode::Hexagon, HGCalGeometryMode::HexagonFull, hgpar_, recoMuon::in, gen::k, HGCalParameters::mode_, rmax_, HGCalParameters::rMinLayHex_, findQualityFiles::rr, mathSSE::sqrt(), tan30deg_, HGCalParameters::waferPosX_, and HGCalParameters::waferPosY_.

                                                              {
 
   const double rr     = 2*rmax_*tan30deg_;
   const double waferX = hgpar_->waferPosX_[wafer];
   const double waferY = hgpar_->waferPosY_[wafer];
   double       xc[6], yc[6];
   xc[0] = waferX+rmax_; yc[0] = waferY-0.5*rr;
   xc[1] = waferX+rmax_; yc[1] = waferY+0.5*rr;
   xc[2] = waferX;       yc[2] = waferY+rr;
   xc[3] = waferX-rmax_; yc[3] = waferY+0.5*rr;
   xc[4] = waferX+rmax_; yc[4] = waferY-0.5*rr;
   xc[5] = waferX;       yc[5] = waferY-rr;
   bool cornerOne(false), cornerAll(true);
   for (int k=0; k<6; ++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(false);
   if (hgpar_->mode_ == HGCalGeometryMode::Hexagon)
     in = cornerAll;
   else if (hgpar_->mode_ == HGCalGeometryMode::HexagonFull)
     in = cornerOne;
   return in;
 }

int HGCalDDDConstants::waferMax ( ) const

inline

Definition at line 77 of file HGCalDDDConstants.h.

References waferMax_.

77 {return waferMax_[1];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:117

int HGCalDDDConstants::waferMin ( ) const

inline

Definition at line 78 of file HGCalDDDConstants.h.

References waferMax_, waferPosition(), and wafers().

78 {return waferMax_[0];}

HGCalDDDConstants::waferMax_

std::array< int, 4 > waferMax_

Definition: HGCalDDDConstants.h:117

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

Definition at line 711 of file HGCalDDDConstants.cc.

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

Referenced by HGCalGeometryLoader::build(), HGCMouseBite::exclude(), 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 /= k_ScaleFromDDD;
     yy /= k_ScaleFromDDD;
   }
   std::pair<double,double> xy(xx,yy);
   return xy;
 }

int HGCalDDDConstants::wafers ( ) const

Definition at line 734 of file HGCalDDDConstants.cc.

References HGCalParameters::depth_, hgpar_, mps_fire::i, layers(), and modules().

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

                                     {
 
   int wafer(0);
   for (unsigned int i = 0; i<layers(true); ++i) {
     int lay = hgpar_->depth_[i];
     wafer += modules(lay, true);
   }
   return wafer;
 }

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

Definition at line 744 of file HGCalDDDConstants.cc.

References waferLayer_.

                                                        {
 
   int  wafer(0);
   auto itr = waferLayer_.find(layer);
   if (itr != waferLayer_.end()) {
     unsigned ity = (type > 0 && type <= 2) ? type : 0;
     wafer = (itr->second)[ity];
   }
   return wafer;
 }

int HGCalDDDConstants::waferToCopy ( int wafer ) const

inline

Definition at line 82 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferCopy_.

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

HGCalParameters::waferCopy_

std::vector< int > waferCopy_

Definition: HGCalParameters.h:90

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

int HGCalDDDConstants::waferTypeL ( int wafer ) const

inline

Definition at line 86 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

Referenced by HGCalTriggerNtupleHGCTriggerCells::fill(), hgcal::RecHitTools::getSiThickness(), HGCalUncalibRecHitRecWeightsAlgo< HGCDataFrame >::makeRecHit(), HGCalTriggerCellThresholdCodecImpl::triggerCellSums(), and HGCalTriggerCellBestChoiceCodecImpl::triggerCellSums().

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

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

HGCalParameters::waferTypeL_

std::vector< int > waferTypeL_

Definition: HGCalParameters.h:91

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

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

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

HGCalParameters::waferTypeT_

std::vector< int > waferTypeT_

Definition: HGCalParameters.h:92

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:109

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

Definition at line 727 of file HGCalDDDConstants.cc.

References getIndex(), hgpar_, mps_fire::i, diffTreeTool::index, and HGCalParameters::zLayerHex_.

Referenced by HGCalSimHitValidation::analyzeHits(), HGCalTBAnalyzer::analyzeRecHits(), HGCalTBAnalyzer::analyzeSimHits(), CaloTruthAccumulator::beginLuminosityBlock(), and HGCalTriggerTools::getLayerZ().

                                                          {
   std::pair<int,float> index = getIndex(lay, reco);
   int i = index.first;
   if (i < 0) return 0;
   else       return hgpar_->zLayerHex_[i];
 }