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

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_

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

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

private

Definition at line 104 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(), mode_, HGCalParameters::mode_, modHalf_, modulesInit(), rmax_, sectors(), HGCalGeometryMode::Square, tan30deg_, tot_layers_, tot_wafers_, waferInLayer(), waferLayer_, 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
     
   }  
   
   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;
       }
     }
 #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;
   }
 }

HGCalDDDConstants::~HGCalDDDConstants ( )

Definition at line 98 of file HGCalDDDConstants.cc.

98 {}

Member Function Documentation

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

Definition at line 100 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 161 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 118 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 750 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 177 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 183 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 198 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:109

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

Definition at line 771 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 226 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 243 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.push_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 787 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 91 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().

91 {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:106

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 90 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::trformIndex_.

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:69

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:106

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

Definition at line 251 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.push_back(hgpar_->getTrForm(k));
   return mytrs;
 }

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

Definition at line 745 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 259 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 305 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 330 of file HGCalDDDConstants.cc.

References createfilelist::int, and tot_layers_.

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

                                                       {
   return tot_layers_[(int)reco];
 }

unsigned int HGCalDDDConstants::layersInit ( bool reco ) const

Definition at line 334 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:110

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:106

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

Definition at line 338 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 373 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 390 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 400 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 422 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:110

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

Definition at line 439 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:112

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:106

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

Definition at line 459 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 464 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 474 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 499 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 511 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 529 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.push_back((int)(cell));
     }
       }
     }
   }
   return ncell;
 }

int HGCalDDDConstants::numberCellsHexagon ( int wafer ) const

Definition at line 565 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 552 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.push_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 577 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:106

HGCalParameters::nSectors_

int nSectors_

Definition: HGCalParameters.h:53

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

Definition at line 589 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 HGCalTBAnalyzer::analyzeSimHits(), CaloTruthAccumulator::fillSimHits(), HGCalTriggerBackend::HGCalTriggerSimCluster< FECODEC, DATA >::run(), sectors(), 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(), waferInLayer(), waferPosition(), and wafers().

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

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:62

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:106

int HGCalDDDConstants::waferFromCopy ( int copy ) const

Definition at line 634 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 659 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 694 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 804 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;
 }

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

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

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

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

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

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

References hgpar_, and HGCalParameters::waferCopy_.

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

HGCalParameters::waferCopy_

std::vector< int > waferCopy_

Definition: HGCalParameters.h:92

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:106

int HGCalDDDConstants::waferTypeL ( int wafer ) const

inline

Definition at line 83 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

Referenced by hgcal::RecHitTools::getSiThickness(), and HGCalUncalibRecHitRecWeightsAlgo< HGCDataFrame >::makeRecHit().

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

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:106

HGCalParameters::waferTypeL_

std::vector< int > waferTypeL_

Definition: HGCalParameters.h:93

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

Definition at line 81 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeT_.

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

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

HGCalParameters::waferTypeT_

std::vector< int > waferTypeT_

Definition: HGCalParameters.h:94

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:106

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

Definition at line 717 of file HGCalDDDConstants.cc.

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

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

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