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 //#define DebugLog
14 // ==============> Loader Itself <==========================
15 
16 HcalFlexiHardcodeGeometryLoader::HcalFlexiHardcodeGeometryLoader(const edm::ParameterSet&) {
17 
18  MAX_HCAL_PHI = 72;
19  DEGREE2RAD = M_PI / 180.;
20 }
21 
22 CaloSubdetectorGeometry* HcalFlexiHardcodeGeometryLoader::load(const HcalTopology& fTopology, const HcalDDDRecConstants& hcons) {
23  CaloSubdetectorGeometry* hcalGeometry = new HcalGeometry (fTopology);
24  if( 0 == hcalGeometry->cornersMgr() ) hcalGeometry->allocateCorners ( fTopology.ncells() );
25  if( 0 == hcalGeometry->parMgr() ) hcalGeometry->allocatePar (hcalGeometry->numberOfShapes(),
26  HcalGeometry::k_NumberOfParametersPerShape ) ;
27  if (fTopology.mode() == HcalTopologyMode::H2) { // TB geometry
28  fillHBHO (hcalGeometry, makeHBCells(hcons), true);
29  fillHBHO (hcalGeometry, makeHOCells(), false);
30  fillHE (hcalGeometry, makeHECells_H2());
31  } else { // regular geometry
32  fillHBHO (hcalGeometry, makeHBCells(hcons), true);
33  fillHBHO (hcalGeometry, makeHOCells(), false);
34  fillHF (hcalGeometry, makeHFCells());
35  fillHE (hcalGeometry, makeHECells(hcons));
36  }
37  return hcalGeometry;
38 }
39 
40 
41 // ----------> HB <-----------
42 std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> HcalFlexiHardcodeGeometryLoader::makeHBCells (const HcalDDDRecConstants& hcons) {
43 
44  std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> result;
45  std::vector<std::pair<double,double> > gconsHB = hcons.getConstHBHE(0);
46  std::vector<double> layerDepths;
47  layerDepths.push_back(gconsHB[0].first-gconsHB[0].second);
48  for (int i=0; i<17; ++i)
49  layerDepths.push_back(gconsHB[i].first+gconsHB[i].second);
50  std::vector<HcalDDDRecConstants::HcalEtaBin> etabins = hcons.getEtaBins(0);
51 
52 #ifdef DebugLog
53  std::cout << "FlexiGeometryLoader called for " << etabins.size()
54  << " Eta Bins" << std::endl;
55  for (unsigned int k=0; k<gconsHB.size(); ++k) {
56  std::cout << "gconsHB[" << k << "] = " << gconsHB[k].first << ":"
57  << gconsHB[k].second << " LayerDepth[" << k << "] = "
58  << layerDepths[k] << std::endl;
59  }
60 #endif
61  for (unsigned int i=0; i<etabins.size(); ++i) {
62  int iring = etabins[i].ieta;
63  int nphi = etabins[i].nPhi;
64  int depth = etabins[i].depthStart;
65  for (unsigned int k=0; k<etabins[i].layer.size(); ++k) {
66  double rmin = layerDepths[etabins[i].layer[k].first-1];
67  double rmax = layerDepths[etabins[i].layer[k].second];
68 #ifdef DebugLog
69  std::cout << "HBRing " << iring << " eta " << etabins[i].etaMin << ":"
70  << etabins[i].etaMax << " depth " << depth << " R " << rmin
71  << ":" << rmax << " Phi 1:" << nphi << ":" << etabins[i].phi0
72  << ":" << etabins[i].dphi << " layer[" << k << "]: "
73  << etabins[i].layer[k].first-1 << ":"
74  << etabins[i].layer[k].second << std::endl;
75 #endif
76  result.push_back (HcalFlexiHardcodeGeometryLoader::HBHOCellParameters(iring, depth, 1, nphi, 1, etabins[i].phi0, etabins[i].dphi, rmin, rmax, etabins[i].etaMin, etabins[i].etaMax));
77  depth++;
78  }
79  }
80  return result;
81 }
82 
83 
84 // ----------> HO <-----------
85 std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> HcalFlexiHardcodeGeometryLoader::makeHOCells () {
86  const double HORMIN0 = 390.0;
87  const double HORMIN1 = 412.6;
88  const double HORMAX = 413.6;
89  const int nCells = 15;
90  const double etamin[nCells] = {0.000,0.087,0.174, 0.261, 0.3395,0.435,0.522,
91  0.609,0.696,0.783, 0.873, 0.957, 1.044,1.131,
92  1.218};
93  const double etamax[nCells] = {0.087,0.174,0.261, 0.3075,0.435, 0.522,0.609,
94  0.696,0.783,0.8494,0.957, 1.044, 1.131,1.218,
95  1.305};
96  std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters> result;
97  result.reserve (nCells);
98  double dphi = 5*DEGREE2RAD;
99  for (int i = 0; i < nCells; ++i) {
100  double rmin = ((i < 4) ? HORMIN0 : HORMIN1);
101  // eta, depth, firstPhi, stepPhi, deltaPhi, rMin, rMax, etaMin, etaMax
102  result.push_back (HcalFlexiHardcodeGeometryLoader::HBHOCellParameters(i+1, 4, 1, 72, 1, 0, dphi, rmin, HORMAX, etamin[i], etamax[i]));
103  }
104  return result;
105 }
106 
107 
108 //
109 // Convert constants to appropriate cells
110 //
111 void HcalFlexiHardcodeGeometryLoader::fillHBHO (CaloSubdetectorGeometry* fGeometry, const std::vector<HcalFlexiHardcodeGeometryLoader::HBHOCellParameters>& fCells, bool fHB) {
112 
113  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
114  const HcalFlexiHardcodeGeometryLoader::HBHOCellParameters& param = fCells[iCell];
115  for (int iPhi = param.phiFirst; iPhi <= param.nPhi; iPhi += param.phiStep) {
116  for (int iside = -1; iside <= 1; iside += 2) { // both detector sides are identical
117  HcalDetId hid (fHB ? HcalBarrel : HcalOuter, param.eta*iside, iPhi, param.depth);
118  float phiCenter = param.phiStart+(iPhi-0.5)*param.dphi; // middle of the cell
119  float etaCenter = 0.5*(param.etaMin + param.etaMax);
120  float x = param.rMin* cos (phiCenter);
121  float y = param.rMin* sin (phiCenter);
122  float z = iside * param.rMin * sinh(etaCenter);
123  // make cell geometry
124  GlobalPoint refPoint (x,y,z); // center of the cell's face
125  std::vector<CCGFloat> cellParams;
126  cellParams.reserve (5);
127  cellParams.push_back (0.5 * (param.etaMax - param.etaMin)); // deta_half
128  cellParams.push_back (0.5 * param.dphi); // dphi_half
129  cellParams.push_back (0.5 * (param.rMax - param.rMin) * cosh (etaCenter)); // dr_half
130  cellParams.push_back ( fabs( refPoint.eta() ) ) ;
131  cellParams.push_back ( fabs( refPoint.z() ) ) ;
132 #ifdef DebugLog
133  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;
134 #endif
135  fGeometry->newCell(refPoint, refPoint, refPoint,
136  CaloCellGeometry::getParmPtr(cellParams,
137  fGeometry->parMgr(),
138  fGeometry->parVecVec()),
139  hid ) ;
140  }
141  }
142  }
143 }
144 
145 
146 // ----------> HE <-----------
147 std::vector<HcalFlexiHardcodeGeometryLoader::HECellParameters> HcalFlexiHardcodeGeometryLoader::makeHECells (const HcalDDDRecConstants& hcons) {
148 
149  std::vector<HcalFlexiHardcodeGeometryLoader::HECellParameters> result;
150  std::vector<std::pair<double,double> > gconsHE = hcons.getConstHBHE(1);
151  std::vector<double> layerDepths;
152 #ifdef DebugLog
153  std::cout << "HcalFlexiHardcodeGeometryLoader:HE with " << gconsHE.size() << " cells" << std::endl;
154 #endif
155  if (gconsHE.size() > 0) {
156  unsigned int istart = 1;
157  layerDepths.push_back(gconsHE[istart].first-gconsHE[istart].second);
158  for (unsigned int i=istart; i<gconsHE.size(); ++i)
159  layerDepths.push_back(gconsHE[i].first+gconsHE[i].second);
160  std::vector<HcalDDDRecConstants::HcalEtaBin> etabins = hcons.getEtaBins(1);
161 
162 #ifdef DebugLog
163  std::cout << "FlexiGeometryLoader called for HE with " << etabins.size()
164  << " Eta Bins and " << layerDepths.size() << " depths"
165  << std::endl;
166  for (unsigned int i=0; i<layerDepths.size(); ++i)
167  std::cout << " Depth[" << i << "] = " << layerDepths[i];
168  std::cout << std::endl;
169 #endif
170  for (unsigned int i=0; i<etabins.size(); ++i) {
171  int iring = etabins[i].ieta;
172  int nphi = etabins[i].nPhi;
173  int depth = etabins[i].depthStart;
174  double dphi = etabins[i].dphi;
175  int units = int(((dphi*72)/(2*M_PI))+0.5);
176  int fioff = (units == 4) ? 3 : 1;
177  nphi *= units;
178  for (unsigned int k=0; k<etabins[i].layer.size(); ++k) {
179  int layf = etabins[i].layer[k].first-1;
180  int layl = etabins[i].layer[k].second-1;
181  double zmin = layerDepths[layf];
182  double zmax = layerDepths[layl];
183  if (zmin < 1.0) {
184  for (int k2=layf; k2<=layl; ++k2) {
185  if (layerDepths[k2] > 10) {
186  zmin = layerDepths[k2];
187  break;
188  }
189  }
190  }
191  if (zmin >= zmax) zmax = zmin+10.;
192 #ifdef DebugLog
193  std::cout << "HERing " << iring << " eta " << etabins[i].etaMin << ":"
194  << etabins[i].etaMax << " depth " << depth << " Z " << zmin
195  << ":" << zmax << " Phi 1:" << nphi << ":" << etabins[i].phi0
196  << ":" << dphi << ":" << units << ":" << fioff << " layer["
197  << k << "]: " << etabins[i].layer[k].first-1 << ":"
198  << etabins[i].layer[k].second-1 << std::endl;
199 #endif
200  result.push_back(HcalFlexiHardcodeGeometryLoader::HECellParameters(iring, depth, fioff, nphi, units, etabins[i].phi0, dphi, zmin, zmax, etabins[i].etaMin, etabins[i].etaMax));
201  depth++;
202  }
203  }
204  }
205  return result;
206 }
207 
208 
209 // ----------> HE @ H2 <-----------
210 std::vector <HcalFlexiHardcodeGeometryLoader::HECellParameters> HcalFlexiHardcodeGeometryLoader::makeHECells_H2 () {
211 
212  const double HEZMIN_H2 = 400.715;
213  const double HEZMID_H2 = 436.285;
214  const double HEZMAX_H2 = 541.885;
215  const double dphi1 = 5*DEGREE2RAD;
216  const double dphi2 = 2*dphi1;
217 
218  HcalFlexiHardcodeGeometryLoader::HECellParameters cells [] = {
219  // eta, depth, firstPhi, nPhi, stepPhi, phiStart, deltaPhi, zMin, zMax, etaMin, etaMax
220  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 16, 3, 1, 8, 1, 0, dphi1, 409.885, 462.685, 1.305, 1.373),
221  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 17, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, 427.485, 1.373, 1.444),
222  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 17, 2, 1, 8, 1, 0, dphi1, 427.485, 506.685, 1.373, 1.444),
223  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 18, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.444, 1.521),
224  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 18, 2, 1, 8, 1, 0, dphi1, HEZMID_H2, 524.285, 1.444, 1.521),
225  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 19, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.521, 1.603),
226  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 19, 2, 1, 8, 1, 0, dphi1, HEZMID_H2, HEZMAX_H2, 1.521, 1.603),
227  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 20, 1, 1, 8, 1, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.603, 1.693),
228  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 20, 2, 1, 8, 1, 0, dphi1, HEZMID_H2, HEZMAX_H2, 1.603, 1.693),
229  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 21, 1, 1, 8, 2, 0, dphi1, HEZMIN_H2, HEZMID_H2, 1.693, 1.79),
230  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 21, 2, 1, 8, 2, 0, dphi1, HEZMID_H2, HEZMAX_H2, 1.693, 1.79),
231  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 22, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, HEZMID_H2, 1.79, 1.88),
232  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 22, 2, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 1.79, 1.88),
233  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 23, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, HEZMID_H2, 1.88, 1.98),
234  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 23, 2, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 1.88, 1.98),
235  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 24, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, 418.685, 1.98, 2.09),
236  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 24, 2, 1, 8, 2, 0, dphi2, 418.685, HEZMID_H2, 1.98, 2.09),
237  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 24, 3, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 1.98, 2.09),
238  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 25, 1, 1, 8, 2, 0, dphi2, HEZMIN_H2, 418.685, 2.09, 2.21),
239  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 25, 2, 1, 8, 2, 0, dphi2, 418.685, HEZMID_H2, 2.09, 2.21),
240  HcalFlexiHardcodeGeometryLoader::HECellParameters ( 25, 3, 1, 8, 2, 0, dphi2, HEZMID_H2, HEZMAX_H2, 2.09, 2.21)
241  };
242  int nCells = sizeof(cells)/sizeof(HcalFlexiHardcodeGeometryLoader::HECellParameters);
243  std::vector <HcalFlexiHardcodeGeometryLoader::HECellParameters> result;
244  result.reserve (nCells);
245  for (int i = 0; i < nCells; ++i) result.push_back (cells[i]);
246  return result;
247 }
248 
249 // ----------> HF <-----------
250 std::vector <HcalFlexiHardcodeGeometryLoader::HFCellParameters> HcalFlexiHardcodeGeometryLoader::makeHFCells () {
251 
252  const float HFZMIN1 = 1115.;
253  const float HFZMIN2 = 1137.;
254  const float HFZMAX = 1280.1;
255 
256  HcalFlexiHardcodeGeometryLoader::HFCellParameters cells [] = {
257  // eta, depth, firstPhi, stepPhi, deltaPhi, zMin, zMax, rMin, rMax
258  HcalFlexiHardcodeGeometryLoader::HFCellParameters (29, 1, 1, 2, 10, HFZMIN1, HFZMAX,116.2,130.0),
259  HcalFlexiHardcodeGeometryLoader::HFCellParameters (29, 2, 1, 2, 10, HFZMIN2, HFZMAX,116.2,130.0),
260  HcalFlexiHardcodeGeometryLoader::HFCellParameters (30, 1, 1, 2, 10, HFZMIN1, HFZMAX, 97.5,116.2),
261  HcalFlexiHardcodeGeometryLoader::HFCellParameters (30, 2, 1, 2, 10, HFZMIN2, HFZMAX, 97.5,116.2),
262  HcalFlexiHardcodeGeometryLoader::HFCellParameters (31, 1, 1, 2, 10, HFZMIN1, HFZMAX, 81.8, 97.5),
263  HcalFlexiHardcodeGeometryLoader::HFCellParameters (31, 2, 1, 2, 10, HFZMIN2, HFZMAX, 81.8, 97.5),
264  HcalFlexiHardcodeGeometryLoader::HFCellParameters (32, 1, 1, 2, 10, HFZMIN1, HFZMAX, 68.6, 81.8),
265  HcalFlexiHardcodeGeometryLoader::HFCellParameters (32, 2, 1, 2, 10, HFZMIN2, HFZMAX, 68.6, 81.8),
266  HcalFlexiHardcodeGeometryLoader::HFCellParameters (33, 1, 1, 2, 10, HFZMIN1, HFZMAX, 57.6, 68.6),
267  HcalFlexiHardcodeGeometryLoader::HFCellParameters (33, 2, 1, 2, 10, HFZMIN2, HFZMAX, 57.6, 68.6),
268  HcalFlexiHardcodeGeometryLoader::HFCellParameters (34, 1, 1, 2, 10, HFZMIN1, HFZMAX, 48.3, 57.6),
269  HcalFlexiHardcodeGeometryLoader::HFCellParameters (34, 2, 1, 2, 10, HFZMIN2, HFZMAX, 48.3, 57.6),
270  HcalFlexiHardcodeGeometryLoader::HFCellParameters (35, 1, 1, 2, 10, HFZMIN1, HFZMAX, 40.6, 48.3),
271  HcalFlexiHardcodeGeometryLoader::HFCellParameters (35, 2, 1, 2, 10, HFZMIN2, HFZMAX, 40.6, 48.3),
272  HcalFlexiHardcodeGeometryLoader::HFCellParameters (36, 1, 1, 2, 10, HFZMIN1, HFZMAX, 34.0, 40.6),
273  HcalFlexiHardcodeGeometryLoader::HFCellParameters (36, 2, 1, 2, 10, HFZMIN2, HFZMAX, 34.0, 40.6),
274  HcalFlexiHardcodeGeometryLoader::HFCellParameters (37, 1, 1, 2, 10, HFZMIN1, HFZMAX, 28.6, 34.0),
275  HcalFlexiHardcodeGeometryLoader::HFCellParameters (37, 2, 1, 2, 10, HFZMIN2, HFZMAX, 28.6, 34.0),
276  HcalFlexiHardcodeGeometryLoader::HFCellParameters (38, 1, 1, 2, 10, HFZMIN1, HFZMAX, 24.0, 28.6),
277  HcalFlexiHardcodeGeometryLoader::HFCellParameters (38, 2, 1, 2, 10, HFZMIN2, HFZMAX, 24.0, 28.6),
278  HcalFlexiHardcodeGeometryLoader::HFCellParameters (39, 1, 1, 2, 10, HFZMIN1, HFZMAX, 20.1, 24.0),
279  HcalFlexiHardcodeGeometryLoader::HFCellParameters (39, 2, 1, 2, 10, HFZMIN2, HFZMAX, 20.1, 24.0),
280  HcalFlexiHardcodeGeometryLoader::HFCellParameters (40, 1, 3, 4, 20, HFZMIN1, HFZMAX, 16.9, 20.1),
281  HcalFlexiHardcodeGeometryLoader::HFCellParameters (40, 2, 3, 4, 20, HFZMIN2, HFZMAX, 16.9, 20.1),
282  HcalFlexiHardcodeGeometryLoader::HFCellParameters (41, 1, 3, 4, 20, HFZMIN1, HFZMAX, 12.5, 16.9),
283  HcalFlexiHardcodeGeometryLoader::HFCellParameters (41, 2, 3, 4, 20, HFZMIN2, HFZMAX, 12.5, 16.9)
284  };
285  int nCells = sizeof(cells)/sizeof(HcalFlexiHardcodeGeometryLoader::HFCellParameters);
286  std::vector <HcalFlexiHardcodeGeometryLoader::HFCellParameters> result;
287  result.reserve (nCells);
288  for (int i = 0; i < nCells; ++i) result.push_back (cells[i]);
289  return result;
290 }
291 
292 void HcalFlexiHardcodeGeometryLoader::fillHE (CaloSubdetectorGeometry* fGeometry, const std::vector <HcalFlexiHardcodeGeometryLoader::HECellParameters>& fCells) {
293 
294  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
295  const HcalFlexiHardcodeGeometryLoader::HECellParameters& param = fCells[iCell];
296  int kPhi(param.phiFirst);
297  for (int iPhi = param.phiFirst; iPhi <= param.nPhi; iPhi += param.phiStep, ++kPhi) {
298  for (int iside = -1; iside <= 1; iside += 2) { // both detector sides are identical
299  HcalDetId hid (HcalEndcap, param.eta*iside, iPhi, param.depth);
300  float phiCenter = param.phiStart + (kPhi-0.5)*param.dphi; // middle of the cell
301  float etaCenter = 0.5 * (param.etaMin + param.etaMax);
302 
303  float perp = param.zMin / sinh (etaCenter);
304  float x = perp * cos (phiCenter);
305  float y = perp * sin (phiCenter);
306  float z = iside * param.zMin;
307  // make cell geometry
308  GlobalPoint refPoint (x,y,z); // center of the cell's face
309  std::vector<CCGFloat> cellParams;
310  cellParams.reserve (5);
311  cellParams.push_back (0.5 * (param.etaMax - param.etaMin)); //deta_half
312  cellParams.push_back (0.5 * param.dphi); // dphi_half
313  cellParams.push_back (-0.5 * (param.zMax - param.zMin) / tanh (etaCenter)); // dz_half, "-" means edges in Z
314  cellParams.push_back ( fabs( refPoint.eta() ) ) ;
315  cellParams.push_back ( fabs( refPoint.z() ) ) ;
316 #ifdef DebugLog
317  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;
318 #endif
319  fGeometry->newCell(refPoint, refPoint, refPoint,
320  CaloCellGeometry::getParmPtr(cellParams,
321  fGeometry->parMgr(),
322  fGeometry->parVecVec()),
323  hid ) ;
324  }
325  }
326  }
327 }
328 
329 void HcalFlexiHardcodeGeometryLoader::fillHF (CaloSubdetectorGeometry* fGeometry, const std::vector <HcalFlexiHardcodeGeometryLoader::HFCellParameters>& fCells) {
330 
331  for (size_t iCell = 0; iCell < fCells.size(); ++iCell) {
332  const HcalFlexiHardcodeGeometryLoader::HFCellParameters& param = fCells[iCell];
333 // int kPhi(0);
334  for (int iPhi = param.phiFirst; iPhi <= MAX_HCAL_PHI; iPhi += param.phiStep) {
335  for (int iside = -1; iside <= 1; iside += 2) { // both detector sides are identical
336  HcalDetId hid (HcalForward, param.eta*iside, iPhi, param.depth);
337  // middle of the cell
338 // float phiCenter = ((kPhi + 0.5) * param.dphi) * DEGREE2RAD;
339  float phiCenter = ((iPhi-1)*360./MAX_HCAL_PHI + 0.5*param.dphi) * DEGREE2RAD;
340  GlobalPoint inner (param.rMin, 0, param.zMin);
341  GlobalPoint outer (param.rMax, 0, param.zMin);
342  float iEta = inner.eta();
343  float oEta = outer.eta();
344  float etaCenter = 0.5 * ( iEta + oEta );
345 
346  float perp = param.zMin / sinh (etaCenter);
347  float x = perp * cos (phiCenter);
348  float y = perp * sin (phiCenter);
349  float z = iside * param.zMin;
350  // make cell geometry
351  GlobalPoint refPoint (x,y,z); // center of the cell's face
352  std::vector<CCGFloat> cellParams;
353  cellParams.reserve (5);
354  cellParams.push_back (0.5 * ( iEta - oEta )); // deta_half
355  cellParams.push_back (0.5 * param.dphi * DEGREE2RAD); // dphi_half
356  cellParams.push_back (0.5 * (param.zMax - param.zMin)); // dz_half
357  cellParams.push_back ( fabs( refPoint.eta()));
358  cellParams.push_back ( fabs( refPoint.z() ) ) ;
359 #ifdef DebugLog
360  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;
361 #endif
362  fGeometry->newCell(refPoint, refPoint, refPoint,
363  CaloCellGeometry::getParmPtr(cellParams,
364  fGeometry->parMgr(),
365  fGeometry->parVecVec()),
366  hid ) ;
367  }
368  }
369  }
370 }
i
int i
Definition: DBlmapReader.cc:9
relval_steps.k2
k2
Definition: relval_steps.py:1591
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
HcalFlexiHardcodeGeometryLoader::makeHFCells
std::vector< HFCellParameters > makeHFCells()
Definition: HcalFlexiHardcodeGeometryLoader.cc:250
HcalFlexiHardcodeGeometryLoader::fillHBHO
void fillHBHO(CaloSubdetectorGeometry *fGeometry, const std::vector< HBHOCellParameters > &fCells, bool fHB)
Definition: HcalFlexiHardcodeGeometryLoader.cc:111
HcalFlexiHardcodeGeometryLoader::makeHECells_H2
std::vector< HECellParameters > makeHECells_H2()
Definition: HcalFlexiHardcodeGeometryLoader.cc:210
HcalFlexiHardcodeGeometryLoader::HcalFlexiHardcodeGeometryLoader
HcalFlexiHardcodeGeometryLoader(const edm::ParameterSet &)
Definition: HcalFlexiHardcodeGeometryLoader.cc:16
CaloSubdetectorGeometry::allocatePar
void allocatePar(ParVec::size_type n, unsigned int m)
Definition: CaloSubdetectorGeometry.cc:140
HLT_25ns14e33_v1_cff.etaMin
tuple etaMin
Definition: HLT_25ns14e33_v1_cff.py:26057
HcalFlexiHardcodeGeometryLoader::makeHBCells
std::vector< HBHOCellParameters > makeHBCells(const HcalDDDRecConstants &hcons)
Definition: HcalFlexiHardcodeGeometryLoader.cc:42
HcalTopology::mode
HcalTopologyMode::Mode mode() const
Definition: HcalTopology.h:32
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:49
HcalDetId::depth
int depth() const
get the tower depth
Definition: HcalDetId.h:55
CaloSubdetectorGeometry::numberOfShapes
virtual unsigned int numberOfShapes() const
Definition: CaloSubdetectorGeometry.h:92
HcalFlexiHardcodeGeometryLoader::makeHOCells
std::vector< HBHOCellParameters > makeHOCells()
Definition: HcalFlexiHardcodeGeometryLoader.cc:85
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
query.result
tuple result
Definition: query.py:137
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:51
CCGFloat
CaloCellGeometry::CCGFloat CCGFloat
Definition: CaloCellGeometry.cc:4
HcalFlexiHardcodeGeometryLoader::fillHE
void fillHE(CaloSubdetectorGeometry *fGeometry, const std::vector< HECellParameters > &fCells)
Definition: HcalFlexiHardcodeGeometryLoader.cc:292
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:147
M_PI
#define M_PI
Definition: readTestVector.cc:25
HLT_25ns14e33_v1_cff.depth
tuple depth
Definition: HLT_25ns14e33_v1_cff.py:6940
HcalDetId::iphi
int iphi() const
get the cell iphi
Definition: HcalDetId.h:53
HcalFlexiHardcodeGeometryLoader::fillHF
void fillHF(CaloSubdetectorGeometry *fGeometry, const std::vector< HFCellParameters > &fCells)
Definition: HcalFlexiHardcodeGeometryLoader.cc:329
SiStripMonitorClusterAlca_cfi.zmin
tuple zmin
Definition: SiStripMonitorClusterAlca_cfi.py:168
CaloSubdetectorGeometry::cornersMgr
CaloCellGeometry::CornersMgr * cornersMgr()
Definition: CaloSubdetectorGeometry.h:82
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:22
CaloSubdetectorGeometry::allocateCorners
void allocateCorners(CaloCellGeometry::CornersVec::size_type n)
Definition: CaloSubdetectorGeometry.cc:130
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
relval_steps.k
list k
Definition: relval_steps.py:1709
HLT_25ns14e33_v1_cff.etaMax
tuple etaMax
Definition: HLT_25ns14e33_v1_cff.py:26058
HcalTopology::ncells
virtual unsigned int ncells() const
return a count of valid cells (for dense indexing use)
Definition: HcalTopology.cc:1174
SiStripMonitorClusterAlca_cfi.zmax
tuple zmax
Definition: SiStripMonitorClusterAlca_cfi.py:169
HcalDDDRecConstants::getEtaBins
std::vector< HcalEtaBin > getEtaBins(const int itype) const
Definition: HcalDDDRecConstants.cc:29
Generated for CMSSW Reference Manual by doxygen 1.8.5