test
CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
HcalFlexiHardcodeGeometryLoader.cc
Go to the documentation of this file.
1 #include "Geometry/HcalTowerAlgo/interface/HcalFlexiHardcodeGeometryLoader.h"
2 #include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
3 #include "Geometry/CaloGeometry/interface/IdealObliquePrism.h"
4 #include "Geometry/CaloGeometry/interface/IdealZPrism.h"
5 #include "Geometry/CaloTopology/interface/HcalTopology.h"
6 #include "Geometry/HcalTowerAlgo/interface/HcalGeometry.h"
7 #include "Geometry/HcalCommonData/interface/HcalDDDRecConstants.h"
8 #include "FWCore/MessageLogger/interface/MessageLogger.h"
9 
10 #include <vector>
11 
12 typedef CaloCellGeometry::CCGFloat CCGFloat ;
13 
14 //#define DebugLog
15 
16 // ==============> Loader Itself <==========================
17 
18 HcalFlexiHardcodeGeometryLoader::HcalFlexiHardcodeGeometryLoader(const edm::ParameterSet&) {
19 
20  MAX_HCAL_PHI = 72;
21  DEGREE2RAD = M_PI / 180.;
22 }
23 
24 CaloSubdetectorGeometry* HcalFlexiHardcodeGeometryLoader::load(const HcalTopology& fTopology, const HcalDDDRecConstants& hcons) {
25  CaloSubdetectorGeometry* hcalGeometry = new HcalGeometry (fTopology);
26  if( 0 == hcalGeometry->cornersMgr() ) hcalGeometry->allocateCorners ( fTopology.ncells()+fTopology.getHFSize() );
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 }
47 
48 
49 // ----------> HB <-----------
50 std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> HcalFlexiHardcodeGeometryLoader::makeHBCells (const HcalDDDRecConstants& hcons) {
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 }
90 
91 
92 // ----------> HO <-----------
93 std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> HcalFlexiHardcodeGeometryLoader::makeHOCells () {
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 }
114 
115 
116 //
117 // Convert constants to appropriate cells
118 //
119 void HcalFlexiHardcodeGeometryLoader::fillHBHO (CaloSubdetectorGeometry* fGeometry, const std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters>& fCells, bool fHB) {
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 }
152 
153 
154 // ----------> HE <-----------
155 std::vector<HcalFlexiHardcodeGeometryLoader::HECellParameters> HcalFlexiHardcodeGeometryLoader::makeHECells (const HcalDDDRecConstants& hcons) {
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 }
215 
216 
217 // ----------> HE @ H2 <-----------
218 std::vector <HcalFlexiHardcodeGeometryLoader::HECellParameters> HcalFlexiHardcodeGeometryLoader::makeHECells_H2 () {
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 }
256 
257 // ----------> HF <-----------
258 std::vector <HcalFlexiHardcodeGeometryLoader::HFCellParameters> HcalFlexiHardcodeGeometryLoader::makeHFCells (const HcalDDDRecConstants& hcons) {
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 }
275 
276 void HcalFlexiHardcodeGeometryLoader::fillHE (CaloSubdetectorGeometry* fGeometry, const std::vector <HcalFlexiHardcodeGeometryLoader::HECellParameters>& fCells) {
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 }
312 
313 void HcalFlexiHardcodeGeometryLoader::fillHF (CaloSubdetectorGeometry* fGeometry, const std::vector <HcalFlexiHardcodeGeometryLoader::HFCellParameters>& fCells) {
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 }
HcalTopology::getHFSize
unsigned int getHFSize() const
Definition: HcalTopology.h:124
i
int i
Definition: DBlmapReader.cc:9
relval_steps.k2
k2
Definition: relval_steps.py:1598
CaloSubdetectorGeometry::newCell
virtual void newCell(const GlobalPoint &f1, const GlobalPoint &f2, const GlobalPoint &f3, const CCGFloat *parm, const DetId &detId)=0
HcalFlexiHardcodeGeometryLoader::makeHFCells
std::vector< HFCellParameters > makeHFCells(const HcalDDDRecConstants &hcons)
Definition: HcalFlexiHardcodeGeometryLoader.cc:258
relval_2017.k
list k
Definition: relval_2017.py:23
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
HcalFlexiHardcodeGeometryLoader::fillHBHO
void fillHBHO(CaloSubdetectorGeometry *fGeometry, const std::vector< HBHOCellParameters > &fCells, bool fHB)
Definition: HcalFlexiHardcodeGeometryLoader.cc:119
HLT_25ns10e33_v2_cff.depth
tuple depth
Definition: HLT_25ns10e33_v2_cff.py:10449
HcalFlexiHardcodeGeometryLoader::makeHECells_H2
std::vector< HECellParameters > makeHECells_H2()
Definition: HcalFlexiHardcodeGeometryLoader.cc:218
HcalFlexiHardcodeGeometryLoader::HcalFlexiHardcodeGeometryLoader
HcalFlexiHardcodeGeometryLoader(const edm::ParameterSet &)
Definition: HcalFlexiHardcodeGeometryLoader.cc:18
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
mps_fire.result
tuple result
Definition: mps_fire.py:84
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
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
HcalDetId::depth
int depth() const
get the tower depth
Definition: HcalDetId.cc:106
CaloSubdetectorGeometry::numberOfShapes
virtual unsigned int numberOfShapes() const
Definition: CaloSubdetectorGeometry.h:92
HcalFlexiHardcodeGeometryLoader::makeHOCells
std::vector< HBHOCellParameters > makeHOCells()
Definition: HcalFlexiHardcodeGeometryLoader.cc:93
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
HcalDetId::ieta
int ieta() const
get the cell ieta
Definition: HcalDetId.h:56
HcalDDDRecConstants::getHFCellParameters
std::vector< HFCellParameters > getHFCellParameters() const
Definition: HcalDDDRecConstants.cc:178
CCGFloat
CaloCellGeometry::CCGFloat CCGFloat
Definition: CaloCellGeometry.cc:4
HcalFlexiHardcodeGeometryLoader::fillHE
void fillHE(CaloSubdetectorGeometry *fGeometry, const std::vector< HECellParameters > &fCells)
Definition: HcalFlexiHardcodeGeometryLoader.cc:276
CaloCellGeometry::getParmPtr
static const CCGFloat * getParmPtr(const std::vector< CCGFloat > &vd, ParMgr *mgr, ParVecVec &pvv)
Definition: CaloCellGeometry.cc:146
HcalFlexiHardcodeGeometryLoader::makeHECells
std::vector< HECellParameters > makeHECells(const HcalDDDRecConstants &hcons)
Definition: HcalFlexiHardcodeGeometryLoader.cc:155
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:51
HcalDetId::iphi
int iphi() const
get the cell iphi
Definition: HcalDetId.cc:101
HcalFlexiHardcodeGeometryLoader::fillHF
void fillHF(CaloSubdetectorGeometry *fGeometry, const std::vector< HFCellParameters > &fCells)
Definition: HcalFlexiHardcodeGeometryLoader.cc:313
SiStripMonitorClusterAlca_cfi.zmin
tuple zmin
Definition: SiStripMonitorClusterAlca_cfi.py:170
CaloSubdetectorGeometry::cornersMgr
CaloCellGeometry::CornersMgr * cornersMgr()
Definition: CaloSubdetectorGeometry.h:82
HLT_25ns10e33_v2_cff.nPhi
tuple nPhi
Definition: HLT_25ns10e33_v2_cff.py:2905
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:76
units
TString units(TString variable, Char_t axis)
perp
T perp() const
Magnitude of transverse component.
Definition: Basic3DVectorLD.h:153
HcalFlexiHardcodeGeometryLoader::load
CaloSubdetectorGeometry * load(const HcalTopology &fTopology, const HcalDDDRecConstants &hcons)
Definition: HcalFlexiHardcodeGeometryLoader.cc:24
CaloSubdetectorGeometry::allocateCorners
void allocateCorners(CaloCellGeometry::CornersVec::size_type n)
Definition: CaloSubdetectorGeometry.cc:130
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
HLT_25ns10e33_v2_cff.etaMax
tuple etaMax
Definition: HLT_25ns10e33_v2_cff.py:8668
HLT_25ns10e33_v2_cff.etaMin
tuple etaMin
Definition: HLT_25ns10e33_v2_cff.py:8667
HcalTopology::ncells
virtual unsigned int ncells() const
return a count of valid cells (for dense indexing use)
Definition: HcalTopology.cc:1233
SiStripMonitorClusterAlca_cfi.zmax
tuple zmax
Definition: SiStripMonitorClusterAlca_cfi.py:171
HcalDDDRecConstants::getEtaBins
std::vector< HcalEtaBin > getEtaBins(const int itype) const
Definition: HcalDDDRecConstants.cc:30
Generated for CMSSW Reference Manual by doxygen 1.8.5