CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Classes | Public Member Functions | Private Member Functions | Private Attributes
HcalFlexiHardcodeGeometryLoader Class Reference

#include <HcalFlexiHardcodeGeometryLoader.h>

Classes

struct  HBHOCellParameters
 
struct  HECellParameters
 
struct  HFCellParameters
 

Public Member Functions

 HcalFlexiHardcodeGeometryLoader (const edm::ParameterSet &)
 
CaloSubdetectorGeometry * load (const HcalTopology &fTopology, const HcalDDDRecConstants &hcons)
 

Private Member Functions

void fillHBHO (CaloSubdetectorGeometry *fGeometry, const std::vector< HBHOCellParameters > &fCells, bool fHB)
 
void fillHE (CaloSubdetectorGeometry *fGeometry, const std::vector< HECellParameters > &fCells)
 
void fillHF (CaloSubdetectorGeometry *fGeometry, const std::vector< HFCellParameters > &fCells)
 
std::vector< HBHOCellParameters > makeHBCells (const HcalDDDRecConstants &hcons)
 
std::vector< HECellParameters > makeHECells (const HcalDDDRecConstants &hcons)
 
std::vector< HECellParameters > makeHECells_H2 ()
 
std::vector< HFCellParameters > makeHFCells (const HcalDDDRecConstants &hcons)
 
std::vector< HBHOCellParameters > makeHOCells ()
 

Private Attributes

double DEGREE2RAD
 
int MAX_HCAL_PHI
 

Detailed Description

Author
F.Ratnikov, UMd

Definition at line 17 of file HcalFlexiHardcodeGeometryLoader.h.

Constructor & Destructor Documentation

HcalFlexiHardcodeGeometryLoader::HcalFlexiHardcodeGeometryLoader ( const edm::ParameterSet &  )

Definition at line 18 of file HcalFlexiHardcodeGeometryLoader.cc.

References DEGREE2RAD, M_PI, and MAX_HCAL_PHI.

18  {
19 
20  MAX_HCAL_PHI = 72;
21  DEGREE2RAD = M_PI / 180.;
22 }
M_PI
#define M_PI
Definition: readTestVector.cc:25

Member Function Documentation

void HcalFlexiHardcodeGeometryLoader::fillHBHO ( CaloSubdetectorGeometry *  fGeometry,
const std::vector< HBHOCellParameters > &  fCells,
bool  fHB 
)
private

Definition at line 119 of file HcalFlexiHardcodeGeometryLoader.cc.

References funct::cos(), gather_cfg::cout, TauDecayModes::dec, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::depth, HcalDetId::depth(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::dphi, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::eta, PV3DBase< T, PVType, FrameType >::eta(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::etaMax, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::etaMin, CaloCellGeometry::getParmPtr(), HcalBarrel, HcalOuter, HcalDetId::ieta(), HcalDetId::iphi(), CaloSubdetectorGeometry::newCell(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::nPhi, CaloSubdetectorGeometry::parMgr(), CaloSubdetectorGeometry::parVecVec(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::phiFirst, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::phiStart, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::phiStep, DetId::rawId(), HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::rMax, HcalFlexiHardcodeGeometryLoader::HBHOCellParameters::rMin, funct::sin(), x, y, z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by load().

119  {
120 
121  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
122  const HcalFlexiHardcodeGeometryLoader::HBHOCellParameters& param = fCells[iCell];
123  for (int iPhi = param.phiFirst; iPhi <= param.nPhi; iPhi += param.phiStep) {
124  for (int iside = -1; iside <= 1; iside += 2) { // both detector sides are identical
125  HcalDetId hid (fHB ? HcalBarrel : HcalOuter, param.eta*iside, iPhi, param.depth);
126  float phiCenter = param.phiStart+(iPhi-0.5)*param.dphi; // middle of the cell
127  float etaCenter = 0.5*(param.etaMin + param.etaMax);
128  float x = param.rMin* cos (phiCenter);
129  float y = param.rMin* sin (phiCenter);
130  float z = iside * param.rMin * sinh(etaCenter);
131  // make cell geometry
132  GlobalPoint refPoint (x,y,z); // center of the cell's face
133  std::vector<CCGFloat> cellParams;
134  cellParams.reserve (5);
135  cellParams.push_back (0.5 * (param.etaMax - param.etaMin)); // deta_half
136  cellParams.push_back (0.5 * param.dphi); // dphi_half
137  cellParams.push_back (0.5 * (param.rMax - param.rMin) * cosh (etaCenter)); // dr_half
138  cellParams.push_back ( fabs( refPoint.eta() ) ) ;
139  cellParams.push_back ( fabs( refPoint.z() ) ) ;
140 #ifdef DebugLog
141  std::cout << "HcalFlexiHardcodeGeometryLoader::fillHBHO-> " << hid << " " << hid.rawId() << " " << std::hex << hid.rawId() << std::dec << " " << hid.ieta() << '/' << hid.iphi() << '/' << hid.depth() << refPoint << '/' << cellParams [0] << '/' << cellParams [1] << '/' << cellParams [2] << std::endl;
142 #endif
143  fGeometry->newCell(refPoint, refPoint, refPoint,
144  CaloCellGeometry::getParmPtr(cellParams,
145  fGeometry->parMgr(),
146  fGeometry->parVecVec()),
147  hid ) ;
148  }
149  }
150  }
151 }
CaloSubdetectorGeometry::newCell
virtual void newCell(const GlobalPoint &f1, const GlobalPoint &f2, const GlobalPoint &f3, const CCGFloat *parm, const DetId &detId)=0
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
CaloCellGeometry::getParmPtr
static const CCGFloat * getParmPtr(const std::vector< CCGFloat > &vd, ParMgr *mgr, ParVecVec &pvv)
Definition: CaloCellGeometry.cc:146
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
void HcalFlexiHardcodeGeometryLoader::fillHE ( CaloSubdetectorGeometry *  fGeometry,
const std::vector< HECellParameters > &  fCells 
)
private

Definition at line 276 of file HcalFlexiHardcodeGeometryLoader.cc.

References funct::cos(), gather_cfg::cout, TauDecayModes::dec, HcalFlexiHardcodeGeometryLoader::HECellParameters::depth, HcalDetId::depth(), HcalFlexiHardcodeGeometryLoader::HECellParameters::dphi, HcalFlexiHardcodeGeometryLoader::HECellParameters::eta, PV3DBase< T, PVType, FrameType >::eta(), HcalFlexiHardcodeGeometryLoader::HECellParameters::etaMax, HcalFlexiHardcodeGeometryLoader::HECellParameters::etaMin, CaloCellGeometry::getParmPtr(), HcalEndcap, HcalDetId::ieta(), HcalDetId::iphi(), JetComb::kPhi, CaloSubdetectorGeometry::newCell(), HcalFlexiHardcodeGeometryLoader::HECellParameters::nPhi, CaloSubdetectorGeometry::parMgr(), CaloSubdetectorGeometry::parVecVec(), perp(), HcalFlexiHardcodeGeometryLoader::HECellParameters::phiFirst, HcalFlexiHardcodeGeometryLoader::HECellParameters::phiStart, HcalFlexiHardcodeGeometryLoader::HECellParameters::phiStep, DetId::rawId(), funct::sin(), x, y, z, PV3DBase< T, PVType, FrameType >::z(), HcalFlexiHardcodeGeometryLoader::HECellParameters::zMax, and HcalFlexiHardcodeGeometryLoader::HECellParameters::zMin.

Referenced by load().

276  {
277 
278  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
279  const HcalFlexiHardcodeGeometryLoader::HECellParameters& param = fCells[iCell];
280  int kPhi(param.phiFirst);
281  for (int iPhi = param.phiFirst; iPhi <= param.nPhi; iPhi += param.phiStep, ++kPhi) {
282  for (int iside = -1; iside <= 1; iside += 2) { // both detector sides are identical
283  HcalDetId hid (HcalEndcap, param.eta*iside, iPhi, param.depth);
284  float phiCenter = param.phiStart + (kPhi-0.5)*param.dphi; // middle of the cell
285  float etaCenter = 0.5 * (param.etaMin + param.etaMax);
286 
287  float perp = param.zMin / sinh (etaCenter);
288  float x = perp * cos (phiCenter);
289  float y = perp * sin (phiCenter);
290  float z = iside * param.zMin;
291  // make cell geometry
292  GlobalPoint refPoint (x,y,z); // center of the cell's face
293  std::vector<CCGFloat> cellParams;
294  cellParams.reserve (5);
295  cellParams.push_back (0.5 * (param.etaMax - param.etaMin)); //deta_half
296  cellParams.push_back (0.5 * param.dphi); // dphi_half
297  cellParams.push_back (-0.5 * (param.zMax - param.zMin) / tanh (etaCenter)); // dz_half, "-" means edges in Z
298  cellParams.push_back ( fabs( refPoint.eta() ) ) ;
299  cellParams.push_back ( fabs( refPoint.z() ) ) ;
300 #ifdef DebugLog
301  std::cout << "HcalFlexiHardcodeGeometryLoader::fillHE-> " << hid << " " << hid.rawId() << " " << std::hex << hid.rawId() << std::dec << " " << hid.ieta() << '/' << hid.iphi() << '/' << hid.depth() << refPoint << '/' << cellParams [0] << '/' << cellParams [1] << '/' << cellParams [2] << std::endl;
302 #endif
303  fGeometry->newCell(refPoint, refPoint, refPoint,
304  CaloCellGeometry::getParmPtr(cellParams,
305  fGeometry->parMgr(),
306  fGeometry->parVecVec()),
307  hid ) ;
308  }
309  }
310  }
311 }
CaloSubdetectorGeometry::newCell
virtual void newCell(const GlobalPoint &f1, const GlobalPoint &f2, const GlobalPoint &f3, const CCGFloat *parm, const DetId &detId)=0
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
CaloCellGeometry::getParmPtr
static const CCGFloat * getParmPtr(const std::vector< CCGFloat > &vd, ParMgr *mgr, ParVecVec &pvv)
Definition: CaloCellGeometry.cc:146
perp
T perp() const
Magnitude of transverse component.
Definition: Basic3DVectorLD.h:153
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
void HcalFlexiHardcodeGeometryLoader::fillHF ( CaloSubdetectorGeometry *  fGeometry,
const std::vector< HFCellParameters > &  fCells 
)
private

Definition at line 313 of file HcalFlexiHardcodeGeometryLoader.cc.

References funct::cos(), gather_cfg::cout, TauDecayModes::dec, DEGREE2RAD, HcalDetId::depth(), HcalFlexiHardcodeGeometryLoader::HFCellParameters::depth, HcalFlexiHardcodeGeometryLoader::HFCellParameters::dphi, HcalFlexiHardcodeGeometryLoader::HFCellParameters::eta, PV3DBase< T, PVType, FrameType >::eta(), CaloCellGeometry::getParmPtr(), HcalForward, HcalDetId::ieta(), SurfaceOrientation::inner, HcalDetId::iphi(), JetComb::kPhi, MAX_HCAL_PHI, CaloSubdetectorGeometry::newCell(), HcalFlexiHardcodeGeometryLoader::HFCellParameters::nPhi, SurfaceOrientation::outer, CaloSubdetectorGeometry::parMgr(), CaloSubdetectorGeometry::parVecVec(), perp(), HcalFlexiHardcodeGeometryLoader::HFCellParameters::phiFirst, HcalFlexiHardcodeGeometryLoader::HFCellParameters::phiStep, DetId::rawId(), HcalFlexiHardcodeGeometryLoader::HFCellParameters::rMax, HcalFlexiHardcodeGeometryLoader::HFCellParameters::rMin, funct::sin(), x, y, z, HcalFlexiHardcodeGeometryLoader::HFCellParameters::zMax, and HcalFlexiHardcodeGeometryLoader::HFCellParameters::zMin.

Referenced by load().

313  {
314 
315  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
316  const HcalFlexiHardcodeGeometryLoader::HFCellParameters& param = fCells[iCell];
317  for (int kPhi = 0; kPhi < param.nPhi; ++kPhi) {
318  int iPhi = param.phiFirst + kPhi*param.phiStep;
319  HcalDetId hid (HcalForward, param.eta, iPhi, param.depth);
320  // middle of the cell
321  float phiCenter = ((iPhi-1)*360./MAX_HCAL_PHI + 0.5*param.dphi) * DEGREE2RAD;
322  GlobalPoint inner (param.rMin, 0, param.zMin);
323  GlobalPoint outer (param.rMax, 0, param.zMin);
324  float iEta = inner.eta();
325  float oEta = outer.eta();
326  float etaCenter = 0.5 * ( iEta + oEta );
327 
328  float perp = param.zMin / sinh (etaCenter);
329  float x = perp * cos (phiCenter);
330  float y = perp * sin (phiCenter);
331  float z = (param.eta > 0) ? param.zMin : -param.zMin;
332  // make cell geometry
333  GlobalPoint refPoint (x,y,z); // center of the cell's face
334  std::vector<CCGFloat> cellParams;
335  cellParams.reserve (5);
336  cellParams.push_back (0.5 * ( iEta - oEta )); // deta_half
337  cellParams.push_back (0.5 * param.dphi * DEGREE2RAD); // dphi_half
338  cellParams.push_back (0.5 * (param.zMax - param.zMin)); // dz_half
339  cellParams.push_back ( fabs( refPoint.eta()));
340  cellParams.push_back ( fabs( refPoint.z() ) ) ;
341 #ifdef DebugLog
342  std::cout << "HcalFlexiHardcodeGeometryLoader::fillHF-> " << hid << " " << hid.rawId() << " " << std::hex << hid.rawId() << std::dec << " " << hid.ieta() << '/' << hid.iphi() << '/' << hid.depth() << refPoint << '/' << cellParams [0] << '/' << cellParams [1] << '/' << cellParams [2] << std::endl;
343 #endif
344  fGeometry->newCell(refPoint, refPoint, refPoint,
345  CaloCellGeometry::getParmPtr(cellParams,
346  fGeometry->parMgr(),
347  fGeometry->parVecVec()),
348  hid ) ;
349  }
350  }
351 }
CaloSubdetectorGeometry::newCell
virtual void newCell(const GlobalPoint &f1, const GlobalPoint &f2, const GlobalPoint &f3, const CCGFloat *parm, const DetId &detId)=0
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
CaloCellGeometry::getParmPtr
static const CCGFloat * getParmPtr(const std::vector< CCGFloat > &vd, ParMgr *mgr, ParVecVec &pvv)
Definition: CaloCellGeometry.cc:146
perp
T perp() const
Magnitude of transverse component.
Definition: Basic3DVectorLD.h:153
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
CaloSubdetectorGeometry * HcalFlexiHardcodeGeometryLoader::load ( const HcalTopology &  fTopology,
const HcalDDDRecConstants &  hcons 
)

Definition at line 24 of file HcalFlexiHardcodeGeometryLoader.cc.

References CaloSubdetectorGeometry::allocateCorners(), CaloSubdetectorGeometry::allocatePar(), CaloSubdetectorGeometry::cornersMgr(), gather_cfg::cout, fillHBHO(), fillHE(), fillHF(), HcalTopologyMode::H2, HcalGeometry::k_NumberOfParametersPerShape, makeHBCells(), makeHECells(), makeHECells_H2(), makeHFCells(), makeHOCells(), HcalTopology::mode(), HcalTopology::ncells(), CaloSubdetectorGeometry::numberOfShapes(), and CaloSubdetectorGeometry::parMgr().

Referenced by HcalHardcodeGeometryEP::produceIdeal().

24  {
25  CaloSubdetectorGeometry* hcalGeometry = new HcalGeometry (fTopology);
26  if( 0 == hcalGeometry->cornersMgr() ) hcalGeometry->allocateCorners ( fTopology.ncells() );
27  if( 0 == hcalGeometry->parMgr() ) hcalGeometry->allocatePar (hcalGeometry->numberOfShapes(),
28  HcalGeometry::k_NumberOfParametersPerShape ) ;
29 #ifdef DebugLog
30  std::cout << "FlexiGeometryLoader initialize with ncells "
31  << fTopology.ncells() << " and shapes "
32  << hcalGeometry->numberOfShapes() << ":"
33  << HcalGeometry::k_NumberOfParametersPerShape << std::endl;
34 #endif
35  if (fTopology.mode() == HcalTopologyMode::H2) { // TB geometry
36  fillHBHO (hcalGeometry, makeHBCells(hcons), true);
37  fillHBHO (hcalGeometry, makeHOCells(), false);
38  fillHE (hcalGeometry, makeHECells_H2());
39  } else { // regular geometry
40  fillHBHO (hcalGeometry, makeHBCells(hcons), true);
41  fillHBHO (hcalGeometry, makeHOCells(), false);
42  fillHF (hcalGeometry, makeHFCells(hcons));
43  fillHE (hcalGeometry, makeHECells(hcons));
44  }
45  return hcalGeometry;
46 }
HcalFlexiHardcodeGeometryLoader::makeHFCells
std::vector< HFCellParameters > makeHFCells(const HcalDDDRecConstants &hcons)
Definition: HcalFlexiHardcodeGeometryLoader.cc:258
HcalFlexiHardcodeGeometryLoader::fillHBHO
void fillHBHO(CaloSubdetectorGeometry *fGeometry, const std::vector< HBHOCellParameters > &fCells, bool fHB)
Definition: HcalFlexiHardcodeGeometryLoader.cc:119
HcalFlexiHardcodeGeometryLoader::makeHECells_H2
std::vector< HECellParameters > makeHECells_H2()
Definition: HcalFlexiHardcodeGeometryLoader.cc:218
CaloSubdetectorGeometry::allocatePar
void allocatePar(ParVec::size_type n, unsigned int m)
Definition: CaloSubdetectorGeometry.cc:140
HcalFlexiHardcodeGeometryLoader::makeHBCells
std::vector< HBHOCellParameters > makeHBCells(const HcalDDDRecConstants &hcons)
Definition: HcalFlexiHardcodeGeometryLoader.cc:50
HcalTopology::mode
HcalTopologyMode::Mode mode() const
Definition: HcalTopology.h:31
CaloSubdetectorGeometry::numberOfShapes
virtual unsigned int numberOfShapes() const
Definition: CaloSubdetectorGeometry.h:92
HcalFlexiHardcodeGeometryLoader::makeHOCells
std::vector< HBHOCellParameters > makeHOCells()
Definition: HcalFlexiHardcodeGeometryLoader.cc:93
HcalFlexiHardcodeGeometryLoader::fillHE
void fillHE(CaloSubdetectorGeometry *fGeometry, const std::vector< HECellParameters > &fCells)
Definition: HcalFlexiHardcodeGeometryLoader.cc:276
HcalFlexiHardcodeGeometryLoader::makeHECells
std::vector< HECellParameters > makeHECells(const HcalDDDRecConstants &hcons)
Definition: HcalFlexiHardcodeGeometryLoader.cc:155
HcalFlexiHardcodeGeometryLoader::fillHF
void fillHF(CaloSubdetectorGeometry *fGeometry, const std::vector< HFCellParameters > &fCells)
Definition: HcalFlexiHardcodeGeometryLoader.cc:313
CaloSubdetectorGeometry::cornersMgr
CaloCellGeometry::CornersMgr * cornersMgr()
Definition: CaloSubdetectorGeometry.h:82
CaloSubdetectorGeometry::allocateCorners
void allocateCorners(CaloCellGeometry::CornersVec::size_type n)
Definition: CaloSubdetectorGeometry.cc:130
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
HcalTopology::ncells
virtual unsigned int ncells() const
return a count of valid cells (for dense indexing use)
Definition: HcalTopology.cc:1233
std::vector< HcalFlexiHardcodeGeometryLoader::HBHOCellParameters > HcalFlexiHardcodeGeometryLoader::makeHBCells ( const HcalDDDRecConstants &  hcons)
private

Definition at line 50 of file HcalFlexiHardcodeGeometryLoader.cc.

References gather_cfg::cout, HLT_FULL_cff::depth, HLT_FULL_cff::etaMax, HLT_FULL_cff::etaMin, plotBeamSpotDB::first, HcalDDDRecConstants::getConstHBHE(), HcalDDDRecConstants::getEtaBins(), i, relval_2017::k, query::result, and edm::second().

Referenced by load().

50  {
51 
52  std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> result;
53  std::vector<std::pair<double,double> > gconsHB = hcons.getConstHBHE(0);
54  std::vector<double> layerDepths;
55  layerDepths.push_back(gconsHB[0].first-gconsHB[0].second);
56  for (int i=0; i<17; ++i)
57  layerDepths.push_back(gconsHB[i].first+gconsHB[i].second);
58  std::vector<HcalDDDRecConstants::HcalEtaBin> etabins = hcons.getEtaBins(0);
59 
60 #ifdef DebugLog
61  std::cout << "FlexiGeometryLoader called for " << etabins.size()
62  << " Eta Bins" << std::endl;
63  for (unsigned int k=0; k<gconsHB.size(); ++k) {
64  std::cout << "gconsHB[" << k << "] = " << gconsHB[k].first << ":"
65  << gconsHB[k].second << " LayerDepth[" << k << "] = "
66  << layerDepths[k] << std::endl;
67  }
68 #endif
69  for (unsigned int i=0; i<etabins.size(); ++i) {
70  int iring = etabins[i].ieta;
71  int nphi = etabins[i].nPhi;
72  int depth = etabins[i].depthStart;
73  for (unsigned int k=0; k<etabins[i].layer.size(); ++k) {
74  double rmin = layerDepths[etabins[i].layer[k].first-1];
75  double rmax = layerDepths[etabins[i].layer[k].second];
76 #ifdef DebugLog
77  std::cout << "HBRing " << iring << " eta " << etabins[i].etaMin << ":"
78  << etabins[i].etaMax << " depth " << depth << " R " << rmin
79  << ":" << rmax << " Phi 1:" << nphi << ":" << etabins[i].phi0
80  << ":" << etabins[i].dphi << " layer[" << k << "]: "
81  << etabins[i].layer[k].first-1 << ":"
82  << etabins[i].layer[k].second << std::endl;
83 #endif
84  result.push_back (HcalFlexiHardcodeGeometryLoader::HBHOCellParameters(iring, depth, 1, nphi, 1, etabins[i].phi0, etabins[i].dphi, rmin, rmax, etabins[i].etaMin, etabins[i].etaMax));
85  depth++;
86  }
87  }
88  return result;
89 }
HLT_FULL_cff.etaMax
tuple etaMax
Definition: HLT_FULL_cff.py:8839
i
int i
Definition: DBlmapReader.cc:9
relval_2017.k
list k
Definition: relval_2017.py:22
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
HcalDDDRecConstants::getConstHBHE
std::vector< std::pair< double, double > > getConstHBHE(const int type) const
Definition: HcalDDDRecConstants.h:57
query.result
tuple result
Definition: query.py:137
HLT_FULL_cff.etaMin
tuple etaMin
Definition: HLT_FULL_cff.py:8838
HLT_FULL_cff.depth
tuple depth
Definition: HLT_FULL_cff.py:10673
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
HcalDDDRecConstants::getEtaBins
std::vector< HcalEtaBin > getEtaBins(const int itype) const
Definition: HcalDDDRecConstants.cc:30
std::vector< HcalFlexiHardcodeGeometryLoader::HECellParameters > HcalFlexiHardcodeGeometryLoader::makeHECells ( const HcalDDDRecConstants &  hcons)
private

Definition at line 155 of file HcalFlexiHardcodeGeometryLoader.cc.

References gather_cfg::cout, HLT_FULL_cff::depth, HLT_FULL_cff::etaMax, HLT_FULL_cff::etaMin, plotBeamSpotDB::first, HcalDDDRecConstants::getConstHBHE(), HcalDDDRecConstants::getEtaBins(), i, relval_2017::k, relval_steps::k2, M_PI, query::result, edm::second(), units(), SiStripMonitorClusterAlca_cfi::zmax, and SiStripMonitorClusterAlca_cfi::zmin.

Referenced by load().

155  {
156 
157  std::vector<HcalFlexiHardcodeGeometryLoader::HECellParameters> result;
158  std::vector<std::pair<double,double> > gconsHE = hcons.getConstHBHE(1);
159  std::vector<double> layerDepths;
160 #ifdef DebugLog
161  std::cout << "HcalFlexiHardcodeGeometryLoader:HE with " << gconsHE.size() << " cells" << std::endl;
162 #endif
163  if (gconsHE.size() > 0) {
164  unsigned int istart = 1;
165  layerDepths.push_back(gconsHE[istart].first-gconsHE[istart].second);
166  for (unsigned int i=istart; i<gconsHE.size(); ++i)
167  layerDepths.push_back(gconsHE[i].first+gconsHE[i].second);
168  std::vector<HcalDDDRecConstants::HcalEtaBin> etabins = hcons.getEtaBins(1);
169 
170 #ifdef DebugLog
171  std::cout << "FlexiGeometryLoader called for HE with " << etabins.size()
172  << " Eta Bins and " << layerDepths.size() << " depths"
173  << std::endl;
174  for (unsigned int i=0; i<layerDepths.size(); ++i)
175  std::cout << " Depth[" << i << "] = " << layerDepths[i];
176  std::cout << std::endl;
177 #endif
178  for (unsigned int i=0; i<etabins.size(); ++i) {
179  int iring = etabins[i].ieta;
180  int nphi = etabins[i].nPhi;
181  int depth = etabins[i].depthStart;
182  double dphi = etabins[i].dphi;
183  int units = int(((dphi*72)/(2*M_PI))+0.5);
184  int fioff = (units == 4) ? 3 : 1;
185  nphi *= units;
186  for (unsigned int k=0; k<etabins[i].layer.size(); ++k) {
187  int layf = etabins[i].layer[k].first-1;
188  int layl = etabins[i].layer[k].second-1;
189  double zmin = layerDepths[layf];
190  double zmax = layerDepths[layl];
191  if (zmin < 1.0) {
192  for (int k2=layf; k2<=layl; ++k2) {
193  if (layerDepths[k2] > 10) {
194  zmin = layerDepths[k2];
195  break;
196  }
197  }
198  }
199  if (zmin >= zmax) zmax = zmin+10.;
200 #ifdef DebugLog
201  std::cout << "HERing " << iring << " eta " << etabins[i].etaMin << ":"
202  << etabins[i].etaMax << " depth " << depth << " Z " << zmin
203  << ":" << zmax << " Phi 1:" << nphi << ":" << etabins[i].phi0
204  << ":" << dphi << ":" << units << ":" << fioff << " layer["
205  << k << "]: " << etabins[i].layer[k].first-1 << ":"
206  << etabins[i].layer[k].second-1 << std::endl;
207 #endif
208  result.push_back(HcalFlexiHardcodeGeometryLoader::HECellParameters(iring, depth, fioff, nphi, units, etabins[i].phi0, dphi, zmin, zmax, etabins[i].etaMin, etabins[i].etaMax));
209  depth++;
210  }
211  }
212  }
213  return result;
214 }
HLT_FULL_cff.etaMax
tuple etaMax
Definition: HLT_FULL_cff.py:8839
i
int i
Definition: DBlmapReader.cc:9
relval_steps.k2
k2
Definition: relval_steps.py:1472
relval_2017.k
list k
Definition: relval_2017.py:22
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
HcalDDDRecConstants::getConstHBHE
std::vector< std::pair< double, double > > getConstHBHE(const int type) const
Definition: HcalDDDRecConstants.h:57
query.result
tuple result
Definition: query.py:137
HLT_FULL_cff.etaMin
tuple etaMin
Definition: HLT_FULL_cff.py:8838
M_PI
#define M_PI
Definition: readTestVector.cc:25
HLT_FULL_cff.depth
tuple depth
Definition: HLT_FULL_cff.py:10673
SiStripMonitorClusterAlca_cfi.zmin
tuple zmin
Definition: SiStripMonitorClusterAlca_cfi.py:170
units
TString units(TString variable, Char_t axis)
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
SiStripMonitorClusterAlca_cfi.zmax
tuple zmax
Definition: SiStripMonitorClusterAlca_cfi.py:171
HcalDDDRecConstants::getEtaBins
std::vector< HcalEtaBin > getEtaBins(const int itype) const
Definition: HcalDDDRecConstants.cc:30
std::vector< HcalFlexiHardcodeGeometryLoader::HECellParameters > HcalFlexiHardcodeGeometryLoader::makeHECells_H2 ( )
private

Definition at line 218 of file HcalFlexiHardcodeGeometryLoader.cc.

References DEGREE2RAD, i, and query::result.

Referenced by load().

218  {
219 
220  const double HEZMIN_H2 = 400.715;
221  const double HEZMID_H2 = 436.285;
222  const double HEZMAX_H2 = 541.885;
223  const double dphi1 = 5*DEGREE2RAD;
224  const double dphi2 = 2*dphi1;
225 
226  HcalFlexiHardcodeGeometryLoader::HECellParameters cells [] = {
227  // eta, depth, firstPhi, nPhi, stepPhi, phiStart, deltaPhi, zMin, zMax, etaMin, etaMax
228  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 16, 3, 1, 8, 1, 0, dphi1, 409.885, 462.685, 1.305, 1.373),
229  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 17, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, 427.485, 1.373, 1.444),
230  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 17, 2, 1, 8, 1, 0, dphi1, 427.485, 506.685, 1.373, 1.444),
231  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 18, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.444, 1.521),
232  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 18, 2, 1, 8, 1, 0, dphi1, HEZMID_H2, 524.285, 1.444, 1.521),
233  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 19, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.521, 1.603),
234  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 19, 2, 1, 8, 1, 0, dphi1, HEZMID_H2, HEZMAX_H2, 1.521, 1.603),
235  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 20, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.603, 1.693),
236  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 20, 2, 1, 8, 1, 0, dphi1, HEZMID_H2, HEZMAX_H2, 1.603, 1.693),
237  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 21, 1, 1, 8, 2, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.693, 1.79),
238  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 21, 2, 1, 8, 2, 0, dphi1, HEZMID_H2, HEZMAX_H2, 1.693, 1.79),
239  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 22, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, HEZMID_H2, 1.79, 1.88),
240  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 22, 2, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 1.79, 1.88),
241  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 23, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, HEZMID_H2, 1.88, 1.98),
242  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 23, 2, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 1.88, 1.98),
243  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 24, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, 418.685, 1.98, 2.09),
244  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 24, 2, 1, 8, 2, 0, dphi2, 418.685, HEZMID_H2, 1.98, 2.09),
245  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 24, 3, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 1.98, 2.09),
246  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 25, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, 418.685, 2.09, 2.21),
247  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 25, 2, 1, 8, 2, 0, dphi2, 418.685, HEZMID_H2, 2.09, 2.21),
248  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 25, 3, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 2.09, 2.21)
249  };
250  int nCells = sizeof(cells)/sizeof(HcalFlexiHardcodeGeometryLoader::HECellParameters);
251  std::vector <HcalFlexiHardcodeGeometryLoader::HECellParameters> result;
252  result.reserve (nCells);
253  for (int i = 0; i < nCells; ++i) result.push_back (cells[i]);
254  return result;
255 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
std::vector< HcalFlexiHardcodeGeometryLoader::HFCellParameters > HcalFlexiHardcodeGeometryLoader::makeHFCells ( const HcalDDDRecConstants &  hcons)
private

Definition at line 258 of file HcalFlexiHardcodeGeometryLoader.cc.

References HLT_FULL_cff::depth, HcalDDDRecConstants::getHFCellParameters(), i, HLT_FULL_cff::nPhi, and query::result.

Referenced by load().

258  {
259 
260  const float HFZMIN1 = 1115.;
261  const float HFZMIN2 = 1137.;
262  const float HFZMAX = 1280.1;
263  std::vector<HcalDDDRecConstants::HFCellParameters> cells = hcons.getHFCellParameters();
264  unsigned int nCells = cells.size();
265  std::vector <HcalFlexiHardcodeGeometryLoader::HFCellParameters> result;
266  result.reserve (nCells);
267  for (unsigned int i = 0; i < nCells; ++i) {
268  HcalFlexiHardcodeGeometryLoader::HFCellParameters cell1(cells[i].ieta,cells[i].depth,cells[i].firstPhi,cells[i].stepPhi,cells[i].nPhi,5*cells[i].stepPhi,HFZMIN1,HFZMAX,cells[i].rMin,cells[i].rMax);
269  result.push_back (cell1);
270  HcalFlexiHardcodeGeometryLoader::HFCellParameters cell2(cells[i].ieta,1+cells[i].depth,cells[i].firstPhi,cells[i].stepPhi,cells[i].nPhi,5*cells[i].stepPhi,HFZMIN2,HFZMAX,cells[i].rMin,cells[i].rMax);
271  result.push_back (cell2);
272  }
273  return result;
274 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
HcalDDDRecConstants::getHFCellParameters
std::vector< HFCellParameters > getHFCellParameters() const
Definition: HcalDDDRecConstants.cc:178
HLT_FULL_cff.depth
tuple depth
Definition: HLT_FULL_cff.py:10673
HLT_FULL_cff.nPhi
tuple nPhi
Definition: HLT_FULL_cff.py:3101
std::vector< HcalFlexiHardcodeGeometryLoader::HBHOCellParameters > HcalFlexiHardcodeGeometryLoader::makeHOCells ( )
private

Definition at line 93 of file HcalFlexiHardcodeGeometryLoader.cc.

References DEGREE2RAD, i, and query::result.

Referenced by load().

93  {
94  const double HORMIN0 = 390.0;
95  const double HORMIN1 = 412.6;
96  const double HORMAX = 413.6;
97  const int nCells = 15;
98  const double etamin[nCells] = {0.000,0.087,0.174, 0.261, 0.3395,0.435,0.522,
99  0.609,0.696,0.783, 0.873, 0.957, 1.044,1.131,
100  1.218};
101  const double etamax[nCells] = {0.087,0.174,0.261, 0.3075,0.435, 0.522,0.609,
102  0.696,0.783,0.8494,0.957, 1.044, 1.131,1.218,
103  1.305};
104  std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> result;
105  result.reserve (nCells);
106  double dphi = 5*DEGREE2RAD;
107  for (int i = 0; i < nCells; ++i) {
108  double rmin = ((i < 4) ? HORMIN0 : HORMIN1);
109  // eta, depth, firstPhi, stepPhi, deltaPhi, rMin, rMax, etaMin, etaMax
110  result.push_back (HcalFlexiHardcodeGeometryLoader::HBHOCellParameters(i+1, 4, 1, 72, 1, 0, dphi, rmin, HORMAX, etamin[i], etamax[i]));
111  }
112  return result;
113 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137

Member Data Documentation

double HcalFlexiHardcodeGeometryLoader::DEGREE2RAD
private

Definition at line 90 of file HcalFlexiHardcodeGeometryLoader.h.

Referenced by fillHF(), HcalFlexiHardcodeGeometryLoader(), makeHECells_H2(), and makeHOCells().

int HcalFlexiHardcodeGeometryLoader::MAX_HCAL_PHI
private

Definition at line 89 of file HcalFlexiHardcodeGeometryLoader.h.

Referenced by fillHF(), and HcalFlexiHardcodeGeometryLoader().

Generated for CMSSW Reference Manual by doxygen 1.8.5