#include <HGCalDDDConstants.h>

Public Types
typedef std::array< std::vector< int32_t >, 2 >	simrecovecs

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	waferToCopy (int wafer) const

int	waferTypeL (int wafer) const

int	waferTypeT (int wafer) const

double	waferZ (int layer, bool reco) const

	~HGCalDDDConstants ()

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_

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<std::vector<int32_t>, 2> HGCalDDDConstants::simrecovecs

Definition at line 27 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, hexside_, hgpar_, k_ScaleFromDDD, layers(), layersInit(), max_modules_layer_, maxCells(), mode_, HGCalParameters::mode_, modHalf_, modulesInit(), rmax_, sectors(), HGCalGeometryMode::Square, tan30deg_, tot_layers_, tot_wafers_, 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() 
                   << " 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
     
   }  
   
 }

HGCalDDDConstants::~HGCalDDDConstants ( )

Definition at line 80 of file HGCalDDDConstants.cc.

80 {}

Member Function Documentation

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

Definition at line 82 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 143 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 100 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 721 of file HGCalDDDConstants.cc.

References funct::abs(), 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 159 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 173 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 188 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 42 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().

42 {return mode_;}

HGCalDDDConstants::mode_

HGCalGeometryMode::GeometryMode mode_

Definition: HGCalDDDConstants.h:108

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

Definition at line 742 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(), 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 216 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 233 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 758 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 92 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(), and HGCalGeometry::getSummary().

92 {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:105

unsigned int HGCalDDDConstants::getTrFormN ( ) const

inline

Definition at line 91 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::trformIndex_.

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

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

HGCalParameters::trformIndex_

std::vector< uint32_t > trformIndex_

Definition: HGCalParameters.h:69

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:105

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

Definition at line 241 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 716 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 249 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 295 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 165 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 169 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 50 of file HGCalDDDConstants.h.

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

Referenced by HGCSD::update().

50 {return hgpar_->levelT_;}

HGCalParameters::levelT_

int levelT_

Definition: HGCalParameters.h:110

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:105

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

Definition at line 320 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 355 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 372 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 382 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 404 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 55 of file HGCalDDDConstants.h.

References maxRows(), and modHalf_.

55 {return modHalf_;}

HGCalDDDConstants::modHalf_

int32_t modHalf_

Definition: HGCalDDDConstants.h:109

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

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

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

Referenced by HGCSD::update().

57 {return hgpar_->slopeMin_;}

HGCalParameters::slopeMin_

double slopeMin_

Definition: HGCalParameters.h:112

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:105

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

Definition at line 441 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 446 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 456 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 481 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 493 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 511 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 547 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 534 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 559 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 70 of file HGCalDDDConstants.h.

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

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

70 {return hgpar_->nSectors_;}

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:105

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

References popcon2dropbox::copy(), hgpar_, HGCalParameters::moduleLayR_, waferFromCopy(), waferFromPosition(), waferInLayer(), waferPosition(), wafers(), x, and y.

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

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

HGCalParameters::moduleLayR_

std::vector< int > moduleLayR_

Definition: HGCalParameters.h:62

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:105

int HGCalDDDConstants::waferFromCopy ( int copy ) const

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

References funct::abs(), HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellHex(), HGCalParameters::cellSize_, gather_cfg::cout, 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 676 of file HGCalDDDConstants.cc.

References getIndex().

Referenced by HGCalGeometryLoader::build(), HGCalGeometry::getSummary(), getTrForm(), 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 775 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 683 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 706 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::waferToCopy ( int wafer ) const

inline

Definition at line 80 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferCopy_.

80 {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:105

int HGCalDDDConstants::waferTypeL ( int wafer ) const

inline

Definition at line 84 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeL_.

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

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

HGCalDDDConstants::hgpar_

const HGCalParameters * hgpar_

Definition: HGCalDDDConstants.h:105

HGCalParameters::waferTypeL_

std::vector< int > waferTypeL_

Definition: HGCalParameters.h:93

int HGCalDDDConstants::waferTypeT ( int wafer ) const

inline

Definition at line 82 of file HGCalDDDConstants.h.

References hgpar_, and HGCalParameters::waferTypeT_.

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

82 {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:105

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

Definition at line 699 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];
 }