CMS 3D CMS Logo
FWTGeoRecoGeometryESProducer.cc
Go to the documentation of this file.
1 #include "Fireworks/Geometry/interface/FWTGeoRecoGeometryESProducer.h"
2 #include "Fireworks/Geometry/interface/FWTGeoRecoGeometry.h"
3 #include "Fireworks/Geometry/interface/FWTGeoRecoGeometryRecord.h"
4 
5 #include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"
6 #include "DataFormats/GeometrySurface/interface/TrapezoidalPlaneBounds.h"
7 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
8 #include "DataFormats/MuonDetId/interface/RPCDetId.h"
9 #include "DataFormats/MuonDetId/interface/GEMDetId.h"
10 #include "DataFormats/MuonDetId/interface/ME0DetId.h"
11 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
12 #include "DataFormats/HcalDetId/interface/HcalSubdetector.h"
13 #include "DataFormats/EcalDetId/interface/EBDetId.h"
14 #include "DataFormats/EcalDetId/interface/EEDetId.h"
15 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
16 #include "DataFormats/CaloTowers/interface/CaloTowerDetId.h"
17 #include "FWCore/ParameterSet/interface/ParameterSet.h"
18 
19 #include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
20 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
21 #include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
22 #include "Geometry/HcalTowerAlgo/interface/HcalGeometry.h"
23 #include "Geometry/CSCGeometry/interface/CSCGeometry.h"
24 #include "Geometry/DTGeometry/interface/DTGeometry.h"
25 #include "Geometry/CSCGeometry/interface/CSCChamber.h"
26 #include "Geometry/CSCGeometry/interface/CSCLayer.h"
27 #include "Geometry/DTGeometry/interface/DTChamber.h"
28 #include "Geometry/DTGeometry/interface/DTLayer.h"
29 #include "Geometry/RPCGeometry/interface/RPCGeometry.h"
30 #include "Geometry/GEMGeometry/interface/GEMEtaPartition.h"
31 #include "Geometry/GEMGeometry/interface/GEMGeometry.h"
32 #include "Geometry/GEMGeometry/interface/ME0EtaPartition.h"
33 #include "Geometry/GEMGeometry/interface/ME0Geometry.h"
34 #include "Geometry/Records/interface/CaloGeometryRecord.h"
35 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
36 #include "Geometry/TrackerGeometryBuilder/interface/RectangularPixelTopology.h"
37 #include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"
38 #include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h"
39 #include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetType.h"
40 #include "Geometry/CommonTopologies/interface/StripTopology.h"
41 #include "Geometry/CommonTopologies/interface/RectangularStripTopology.h"
42 #include "Geometry/CommonTopologies/interface/TrapezoidalStripTopology.h"
43 #include "Geometry/CaloGeometry/interface/IdealZPrism.h"
44 #include "Geometry/CaloGeometry/interface/IdealObliquePrism.h"
45 #include "Geometry/CaloGeometry/interface/TruncatedPyramid.h"
46 
47 #include "TGeoManager.h"
48 #include "TGeoArb8.h"
49 #include "TGeoMatrix.h"
50 
51 #include "TFile.h"
52 #include "TTree.h"
53 #include "TError.h"
54 #include "TMath.h"
55 
56 #include "TEveVector.h"
57 #include "TEveTrans.h"
58 
59 //std::map< const CaloCellGeometry::CCGFloat*, TGeoVolume*> caloShapeMap;
60 namespace {
61  typedef std::map<const float*, TGeoVolume*> CaloVolMap;
62 }
63 FWTGeoRecoGeometryESProducer::FWTGeoRecoGeometryESProducer(const edm::ParameterSet& pset) : m_dummyMedium(nullptr) {
64  m_tracker = pset.getUntrackedParameter<bool>("Tracker", true);
65  m_muon = pset.getUntrackedParameter<bool>("Muon", true);
66  m_calo = pset.getUntrackedParameter<bool>("Calo", true);
67 
68  auto cc = setWhatProduced(this);
69  if (m_tracker || m_muon) {
70  cc.setConsumes(m_trackingGeomToken);
71  }
72  if (m_tracker) {
73  cc.setConsumes(m_trackerTopologyToken);
74  }
75  if (m_calo) {
76  cc.setConsumes(m_caloGeomToken);
77  }
78 }
79 
80 FWTGeoRecoGeometryESProducer::~FWTGeoRecoGeometryESProducer(void) {}
81 
82 namespace {
83 
84  void AddLeafNode(TGeoVolume* mother, TGeoVolume* daughter, const char* name, TGeoMatrix* mtx) {
85  int n = mother->GetNdaughters();
86  mother->AddNode(daughter, 1, mtx);
87  mother->GetNode(n)->SetName(name);
88  }
89 
91  TGeoCombiTrans* createPlacement(const GeomDet* det) {
92  // Position of the DetUnit's center
93  float posx = det->surface().position().x();
94  float posy = det->surface().position().y();
95  float posz = det->surface().position().z();
96 
97  TGeoTranslation trans(posx, posy, posz);
98 
99  // Add the coeff of the rotation matrix
100  // with a projection on the basis vectors
101  TkRotation<float> detRot = det->surface().rotation();
102 
103  TGeoRotation rotation;
104  const Double_t matrix[9] = {detRot.xx(),
105  detRot.yx(),
106  detRot.zx(),
107  detRot.xy(),
108  detRot.yy(),
109  detRot.zy(),
110  detRot.xz(),
111  detRot.yz(),
112  detRot.zz()};
113  rotation.SetMatrix(matrix);
114 
115  return new TGeoCombiTrans(trans, rotation);
116  }
117 
118 } // namespace
119 //______________________________________________________________________________
120 
121 TGeoVolume* FWTGeoRecoGeometryESProducer::GetDaughter(TGeoVolume* mother, const char* prefix, ERecoDet cidx, int id) {
122  TGeoVolume* res = nullptr;
123  if (mother->GetNdaughters()) {
124  TGeoNode* n = mother->FindNode(Form("%s_%d_1", prefix, id));
125  if (n)
126  res = n->GetVolume();
127  }
128 
129  if (!res) {
130  res = new TGeoVolumeAssembly(Form("%s_%d", prefix, id));
131  res->SetMedium(GetMedium(cidx));
132  mother->AddNode(res, 1);
133  }
134 
135  return res;
136 }
137 
138 TGeoVolume* FWTGeoRecoGeometryESProducer::GetDaughter(TGeoVolume* mother, const char* prefix, ERecoDet cidx) {
139  TGeoVolume* res = nullptr;
140  if (mother->GetNdaughters()) {
141  TGeoNode* n = mother->FindNode(Form("%s_1", prefix));
142  if (n)
143  res = n->GetVolume();
144  }
145 
146  if (!res) {
147  // printf("GetDau... new holder %s for mother %s \n", mother->GetName(), prefix);
148  res = new TGeoVolumeAssembly(prefix);
149  res->SetMedium(GetMedium(cidx));
150  mother->AddNode(res, 1);
151  }
152 
153  return res;
154 }
155 
156 TGeoVolume* FWTGeoRecoGeometryESProducer::GetTopHolder(const char* prefix, ERecoDet cidx) {
157  // printf("GetTopHolder res = %s \n", prefix);
158  TGeoVolume* res = GetDaughter(gGeoManager->GetTopVolume(), prefix, cidx);
159  return res;
160 }
161 
162 namespace {
163 
164  enum GMCol {
165  Green = 4,
166  Blue0 = 13,
167  Blue1 = 24,
168  Blue2 = 6,
169  Yellow0 = 3,
170  Yellow1 = 16,
171  Pink = 10,
172  Red = 29,
173  Orange0 = 79,
174  Orange1 = 14,
175  Magenta = 8,
176  Gray = 12
177  };
178 
179 }
180 
181 TGeoMedium* FWTGeoRecoGeometryESProducer::GetMedium(ERecoDet det) {
182  std::map<ERecoDet, TGeoMedium*>::iterator it = m_recoMedium.find(det);
183  if (it != m_recoMedium.end())
184  return it->second;
185 
186  std::string name;
187  int color;
188 
189  switch (det) {
190  // TRACKER
191  case kSiPixel:
192  name = "SiPixel";
193  color = GMCol::Green;
194  break;
195 
196  case kSiStrip:
197  name = "SiStrip";
198  color = GMCol::Gray;
199  break;
200  // MUON
201  case kMuonDT:
202  name = "MuonDT";
203  color = GMCol::Blue2;
204  break;
205 
206  case kMuonRPC:
207  name = "MuonRPC";
208  color = GMCol::Red;
209  break;
210 
211  case kMuonGEM:
212  name = "MuonGEM";
213  color = GMCol::Yellow1;
214  break;
215 
216  case kMuonCSC:
217  name = "MuonCSC";
218  color = GMCol::Gray;
219  break;
220 
221  case kMuonME0:
222  name = "MuonME0";
223  color = GMCol::Yellow0;
224  break;
225 
226  // CALO
227  case kECal:
228  name = "ECal";
229  color = GMCol::Blue2;
230  break;
231  case kHCal:
232  name = "HCal";
233  color = GMCol::Orange1;
234  break;
235  case kCaloTower:
236  name = "CaloTower";
237  color = GMCol::Green;
238  break;
239  case kHGCE:
240  name = "HGCEE";
241  color = GMCol::Blue2;
242  break;
243  case kHGCH:
244  name = "HGCEH";
245  color = GMCol::Blue1;
246  break;
247  default:
248  printf("invalid medium id \n");
249  return m_dummyMedium;
250  }
251 
252  TGeoMaterial* mat = new TGeoMaterial(name.c_str(), 0, 0, 0);
253  mat->SetZ(color);
254  m_recoMedium[det] = new TGeoMedium(name.c_str(), 0, mat);
255  mat->SetFillStyle(3000); // tansparency 3000-3100
256  mat->SetDensity(1); // disable override of transparency in TGeoManager::DefaultColors()
257 
258  return m_recoMedium[det];
259 }
260 
261 //______________________________________________________________________________
262 
263 std::unique_ptr<FWTGeoRecoGeometry> FWTGeoRecoGeometryESProducer::produce(const FWTGeoRecoGeometryRecord& record) {
264  using namespace edm;
265 
266  auto fwTGeoRecoGeometry = std::make_unique<FWTGeoRecoGeometry>();
267 
268  if (m_calo) {
269  m_caloGeom = &record.get(m_caloGeomToken);
270  }
271 
272  TGeoManager* geom = new TGeoManager("cmsGeo", "CMS Detector");
273  if (nullptr == gGeoIdentity) {
274  gGeoIdentity = new TGeoIdentity("Identity");
275  }
276 
277  fwTGeoRecoGeometry->manager(geom);
278 
279  // Default material is Vacuum
280  TGeoMaterial* vacuum = new TGeoMaterial("Vacuum", 0, 0, 0);
281  m_dummyMedium = new TGeoMedium("reco", 0, vacuum);
282 
283  TGeoVolume* top = geom->MakeBox("CMS", m_dummyMedium, 270., 270., 120.);
284 
285  if (nullptr == top) {
286  return std::unique_ptr<FWTGeoRecoGeometry>();
287  }
288  geom->SetTopVolume(top);
289  // ROOT chokes unless colors are assigned
290  top->SetVisibility(kFALSE);
291  top->SetLineColor(kBlue);
292 
293  if (m_tracker || m_muon) {
294  m_trackingGeom = &record.get(m_trackingGeomToken);
295  }
296 
297  if (m_tracker) {
298  DetId detId(DetId::Tracker, 0);
299  m_trackerGeom = static_cast<const TrackerGeometry*>(m_trackingGeom->slaveGeometry(detId));
300 
301  m_trackerTopology = &record.get(m_trackerTopologyToken);
302 
303  addPixelBarrelGeometry();
304  addPixelForwardGeometry();
305 
306  addTIBGeometry();
307  addTIDGeometry();
308  addTOBGeometry();
309  addTECGeometry();
310  }
311 
312  if (m_muon) {
313  addDTGeometry();
314  addCSCGeometry();
315  addRPCGeometry();
316  addME0Geometry();
317  addGEMGeometry();
318  }
319 
320  if (m_calo) {
321  addEcalCaloGeometry();
322  addHcalCaloGeometryBarrel();
323  addHcalCaloGeometryEndcap();
324  addHcalCaloGeometryOuter();
325  addHcalCaloGeometryForward();
326  addCaloTowerGeometry();
327  }
328 
329  geom->CloseGeometry();
330 
331  geom->DefaultColors();
332  // printf("==== geo manager NNodes = %d \n", geom->GetNNodes());
333  geom->CloseGeometry();
334 
335  return fwTGeoRecoGeometry;
336 }
337 
339 TGeoShape* FWTGeoRecoGeometryESProducer::createShape(const GeomDet* det) {
340  TGeoShape* shape = nullptr;
341 
342  // Trapezoidal
343  const Bounds* b = &((det->surface()).bounds());
344  const TrapezoidalPlaneBounds* b2 = dynamic_cast<const TrapezoidalPlaneBounds*>(b);
345  if (b2) {
346  std::array<const float, 4> const& par = b2->parameters();
347 
348  // These parameters are half-lengths, as in CMSIM/GEANT3
349  float hBottomEdge = par[0];
350  float hTopEdge = par[1];
351  float thickness = par[2];
352  float apothem = par[3];
353 
354  std::stringstream s;
355  s << "T_" << hBottomEdge << "_" << hTopEdge << "_" << thickness << "_" << apothem;
356  std::string name = s.str();
357 
358  // Do not create identical shape,
359  // if one already exists
360  shape = m_nameToShape[name];
361  if (nullptr == shape) {
362  shape = new TGeoTrap(name.c_str(),
363  thickness, //dz
364  0, //theta
365  0, //phi
366  apothem, //dy1
367  hBottomEdge, //dx1
368  hTopEdge, //dx2
369  0, //alpha1
370  apothem, //dy2
371  hBottomEdge, //dx3
372  hTopEdge, //dx4
373  0); //alpha2
374 
375  m_nameToShape[name] = shape;
376  }
377  }
378  if (dynamic_cast<const RectangularPlaneBounds*>(b) != nullptr) {
379  // Rectangular
380  float length = det->surface().bounds().length();
381  float width = det->surface().bounds().width();
382  float thickness = det->surface().bounds().thickness();
383 
384  std::stringstream s;
385  s << "R_" << width << "_" << length << "_" << thickness;
386  std::string name = s.str();
387 
388  // Do not create identical shape,
389  // if one already exists
390  shape = m_nameToShape[name];
391  if (nullptr == shape) {
392  shape = new TGeoBBox(name.c_str(), width / 2., length / 2., thickness / 2.); // dx, dy, dz
393 
394  m_nameToShape[name] = shape;
395  }
396  }
397 
398  return shape;
399 }
400 
402 TGeoVolume* FWTGeoRecoGeometryESProducer::createVolume(const std::string& name, const GeomDet* det, ERecoDet mid) {
403  TGeoShape* solid = createShape(det);
404 
405  std::map<TGeoShape*, TGeoVolume*>::iterator vIt = m_shapeToVolume.find(solid);
406  if (vIt != m_shapeToVolume.end())
407  return vIt->second;
408 
409  TGeoVolume* volume = new TGeoVolume(name.c_str(), solid, GetMedium(mid));
410 
411  m_shapeToVolume[solid] = volume;
412 
413  return volume;
414 }
415 
424 
425 void FWTGeoRecoGeometryESProducer::addPixelBarrelGeometry() {
426  TGeoVolume* tv = GetTopHolder("SiPixel", kSiPixel);
427  TGeoVolume* assembly = GetDaughter(tv, "PXB", kSiPixel);
428 
429  for (auto it : m_trackerGeom->detsPXB()) {
430  DetId detid = it->geographicalId();
431  unsigned int layer = m_trackerTopology->pxbLayer(detid);
432  unsigned int module = m_trackerTopology->pxbModule(detid);
433  unsigned int ladder = m_trackerTopology->pxbLadder(detid);
434 
435  std::string name = Form("PXB Ly:%d, Md:%d Ld:%d ", layer, module, ladder);
436  TGeoVolume* child = createVolume(name, it, kSiPixel);
437 
438  TGeoVolume* holder = GetDaughter(assembly, "Layer", kSiPixel, layer);
439  holder = GetDaughter(holder, "Module", kSiPixel, module);
440 
441  AddLeafNode(holder, child, name.c_str(), createPlacement(it));
442  }
443 }
444 
445 void FWTGeoRecoGeometryESProducer::addPixelForwardGeometry() {
446  TGeoVolume* tv = GetTopHolder("SiPixel", kSiPixel);
447  TGeoVolume* assembly = GetDaughter(tv, "PXF", kSiPixel);
448 
449  for (auto it : m_trackerGeom->detsPXF()) {
450  DetId detid = it->geographicalId();
451  unsigned int disk = m_trackerTopology->pxfDisk(detid);
452  unsigned int blade = m_trackerTopology->pxfBlade(detid);
453  unsigned int panel = m_trackerTopology->pxfPanel(detid);
454  unsigned int side = m_trackerTopology->side(detid);
455 
456  std::string name = Form("PXF D:%d, B:%d, P:%d, S:%d", disk, blade, panel, side);
457  TGeoVolume* child = createVolume(name, it, kSiPixel);
458 
459  TGeoVolume* holder = GetDaughter(assembly, "Side", kSiPixel, side);
460  holder = GetDaughter(holder, "Disk", kSiPixel, disk);
461  holder = GetDaughter(holder, "Blade", kSiPixel, blade);
462  holder = GetDaughter(holder, "Panel", kSiPixel, panel);
463 
464  AddLeafNode(holder, child, name.c_str(), createPlacement(it));
465  }
466 }
467 
468 void FWTGeoRecoGeometryESProducer::addTIBGeometry() {
469  TGeoVolume* tv = GetTopHolder("SiStrip", kSiStrip);
470  TGeoVolume* assembly = GetDaughter(tv, "TIB", kSiStrip);
471 
472  for (auto it : m_trackerGeom->detsTIB()) {
473  DetId detid = it->geographicalId();
474  unsigned int module = m_trackerTopology->tibModule(detid);
475  unsigned int order = m_trackerTopology->tibOrder(detid);
476  unsigned int side = m_trackerTopology->tibSide(detid);
477 
478  std::string name = m_trackerTopology->print(detid);
479 
480  TGeoVolume* child = createVolume(name, it, kSiStrip);
481  TGeoVolume* holder = GetDaughter(assembly, "Module", kSiStrip, module);
482  holder = GetDaughter(holder, "Order", kSiStrip, order);
483  holder = GetDaughter(holder, "Side", kSiStrip, side);
484  AddLeafNode(holder, child, name.c_str(), createPlacement(it));
485  }
486 }
487 
488 void FWTGeoRecoGeometryESProducer::addTIDGeometry() {
489  TGeoVolume* tv = GetTopHolder("SiStrip", kSiStrip);
490  TGeoVolume* assembly = GetDaughter(tv, "TID", kSiStrip);
491 
492  for (auto it : m_trackerGeom->detsTID()) {
493  DetId detid = it->geographicalId();
494  unsigned int side = m_trackerTopology->tidSide(detid);
495  unsigned int wheel = m_trackerTopology->tidWheel(detid);
496  unsigned int ring = m_trackerTopology->tidRing(detid);
497 
498  std::string name = m_trackerTopology->print(detid);
499 
500  TGeoVolume* child = createVolume(name, it, kSiStrip);
501  TGeoVolume* holder = GetDaughter(assembly, "Side", kSiStrip, side);
502  holder = GetDaughter(holder, "Wheel", kSiStrip, wheel);
503  holder = GetDaughter(holder, "Ring", kSiStrip, ring);
504  AddLeafNode(holder, child, name.c_str(), createPlacement(it));
505  }
506 }
507 
508 void FWTGeoRecoGeometryESProducer::addTOBGeometry() {
509  TGeoVolume* tv = GetTopHolder("SiStrip", kSiStrip);
510  TGeoVolume* assembly = GetDaughter(tv, "TOB", kSiStrip);
511 
512  for (auto it : m_trackerGeom->detsTOB()) {
513  DetId detid = it->geographicalId();
514  unsigned int rod = m_trackerTopology->tobRod(detid);
515  unsigned int side = m_trackerTopology->tobSide(detid);
516  unsigned int module = m_trackerTopology->tobModule(detid);
517 
518  std::string name = m_trackerTopology->print(detid);
519 
520  TGeoVolume* child = createVolume(name, it, kSiStrip);
521  TGeoVolume* holder = GetDaughter(assembly, "Rod", kSiStrip, rod);
522  holder = GetDaughter(holder, "Side", kSiStrip, side);
523  holder = GetDaughter(holder, "Module", kSiStrip, module);
524  AddLeafNode(holder, child, name.c_str(), createPlacement(it));
525  }
526 }
527 
528 void FWTGeoRecoGeometryESProducer::addTECGeometry() {
529  TGeoVolume* tv = GetTopHolder("SiStrip", kSiStrip);
530  TGeoVolume* assembly = GetDaughter(tv, "TEC", kSiStrip);
531 
532  for (auto it : m_trackerGeom->detsTEC()) {
533  DetId detid = it->geographicalId();
534  unsigned int order = m_trackerTopology->tecOrder(detid);
535  unsigned int ring = m_trackerTopology->tecRing(detid);
536  unsigned int module = m_trackerTopology->tecModule(detid);
537 
538  std::string name = m_trackerTopology->print(detid);
539 
540  TGeoVolume* child = createVolume(name, it, kSiStrip);
541 
542  TGeoVolume* holder = GetDaughter(assembly, "Order", kSiStrip, order);
543  holder = GetDaughter(holder, "Ring", kSiStrip, ring);
544  holder = GetDaughter(holder, "Module", kSiStrip, module);
545  AddLeafNode(holder, child, name.c_str(), createPlacement(it));
546  }
547 }
548 
549 //==============================================================================
550 //==============================================================================
551 //=================================== MUON =====================================
552 //==============================================================================
553 
554 void FWTGeoRecoGeometryESProducer::addDTGeometry() {
555  TGeoVolume* tv = GetTopHolder("Muon", kMuonRPC);
556  TGeoVolume* assemblyTop = GetDaughter(tv, "DT", kMuonDT);
557 
558  //
559  // DT chambers geometry
560  //
561  {
562  TGeoVolume* assembly = GetDaughter(assemblyTop, "DTChamber", kMuonDT);
563  auto const& dtChamberGeom = m_trackingGeom->slaveGeometry(DTChamberId())->dets();
564  for (auto it = dtChamberGeom.begin(), end = dtChamberGeom.end(); it != end; ++it) {
565  if (auto chamber = dynamic_cast<const DTChamber*>(*it)) {
566  DTChamberId detid = chamber->geographicalId();
567  std::stringstream s;
568  s << detid;
569  std::string name = s.str();
570 
571  TGeoVolume* child = createVolume(name, chamber, kMuonDT);
572  TGeoVolume* holder = GetDaughter(assembly, "Wheel", kMuonDT, detid.wheel());
573  holder = GetDaughter(holder, "Station", kMuonDT, detid.station());
574  holder = GetDaughter(holder, "Sector", kMuonDT, detid.sector());
575 
576  AddLeafNode(holder, child, name.c_str(), createPlacement(chamber));
577  }
578  }
579  }
580 
581  // Fill in DT super layer parameters
582  {
583  TGeoVolume* assembly = GetDaughter(assemblyTop, "DTSuperLayer", kMuonDT);
584  auto const& dtSuperLayerGeom = m_trackingGeom->slaveGeometry(DTSuperLayerId())->dets();
585  for (auto it = dtSuperLayerGeom.begin(), end = dtSuperLayerGeom.end(); it != end; ++it) {
586  if (auto* superlayer = dynamic_cast<const DTSuperLayer*>(*it)) {
587  DTSuperLayerId detid(DetId(superlayer->geographicalId()));
588  std::stringstream s;
589  s << detid;
590  std::string name = s.str();
591 
592  TGeoVolume* child = createVolume(name, superlayer, kMuonDT);
593 
594  TGeoVolume* holder = GetDaughter(assembly, "Wheel", kMuonDT, detid.wheel());
595  holder = GetDaughter(holder, "Station", kMuonDT, detid.station());
596  holder = GetDaughter(holder, "Sector", kMuonDT, detid.sector());
597  holder = GetDaughter(holder, "SuperLayer", kMuonDT, detid.superlayer());
598  AddLeafNode(holder, child, name.c_str(), createPlacement(superlayer));
599  }
600  }
601  }
602  // Fill in DT layer parameters
603  {
604  TGeoVolume* assembly = GetDaughter(assemblyTop, "DTLayer", kMuonDT);
605  auto const& dtLayerGeom = m_trackingGeom->slaveGeometry(DTLayerId())->dets();
606  for (auto it = dtLayerGeom.begin(), end = dtLayerGeom.end(); it != end; ++it) {
607  if (auto layer = dynamic_cast<const DTLayer*>(*it)) {
608  DTLayerId detid(DetId(layer->geographicalId()));
609 
610  std::stringstream s;
611  s << detid;
612  std::string name = s.str();
613 
614  TGeoVolume* child = createVolume(name, layer, kMuonDT);
615 
616  TGeoVolume* holder = GetDaughter(assembly, "Wheel", kMuonDT, detid.wheel());
617  holder = GetDaughter(holder, "Station", kMuonDT, detid.station());
618  holder = GetDaughter(holder, "Sector", kMuonDT, detid.sector());
619  holder = GetDaughter(holder, "SuperLayer", kMuonDT, detid.superlayer());
620  holder = GetDaughter(holder, "Layer", kMuonDT, detid.layer());
621  AddLeafNode(holder, child, name.c_str(), createPlacement(layer));
622  }
623  }
624  }
625 }
626 //______________________________________________________________________________
627 
628 void FWTGeoRecoGeometryESProducer::addCSCGeometry() {
629  if (!m_trackingGeom->slaveGeometry(CSCDetId()))
630  throw cms::Exception("FatalError") << "Cannnot find CSCGeometry\n";
631 
632  TGeoVolume* tv = GetTopHolder("Muon", kMuonRPC);
633  TGeoVolume* assembly = GetDaughter(tv, "CSC", kMuonCSC);
634 
635  auto const& cscGeom = m_trackingGeom->slaveGeometry(CSCDetId())->dets();
636  for (auto it = cscGeom.begin(), itEnd = cscGeom.end(); it != itEnd; ++it) {
637  unsigned int rawid = (*it)->geographicalId();
638  CSCDetId detId(rawid);
639  std::stringstream s;
640  s << "CSC" << detId;
641  std::string name = s.str();
642 
643  TGeoVolume* child = nullptr;
644 
645  if (auto chamber = dynamic_cast<const CSCChamber*>(*it))
646  child = createVolume(name, chamber, kMuonCSC);
647  else if (auto* layer = dynamic_cast<const CSCLayer*>(*it))
648  child = createVolume(name, layer, kMuonCSC);
649 
650  if (child) {
651  TGeoVolume* holder = GetDaughter(assembly, "Endcap", kMuonCSC, detId.endcap());
652  holder = GetDaughter(holder, "Station", kMuonCSC, detId.station());
653  holder = GetDaughter(holder, "Ring", kMuonCSC, detId.ring());
654  holder = GetDaughter(holder, "Chamber", kMuonCSC, detId.chamber());
655 
656  // holder->AddNode(child, 1, createPlacement( *it ));
657  AddLeafNode(holder, child, name.c_str(), createPlacement(*it));
658  }
659  }
660 }
661 
662 //______________________________________________________________________________
663 
664 void FWTGeoRecoGeometryESProducer::addGEMGeometry() {
665  try {
666  DetId detId(DetId::Muon, MuonSubdetId::GEM);
667  const GEMGeometry* gemGeom = static_cast<const GEMGeometry*>(m_trackingGeom->slaveGeometry(detId));
668 
669  TGeoVolume* tv = GetTopHolder("Muon", kMuonRPC);
670  TGeoVolume* assemblyTop = GetDaughter(tv, "GEM", kMuonGEM);
671 
672  {
673  TGeoVolume* assembly = GetDaughter(assemblyTop, "GEMSuperChambers", kMuonGEM);
674  for (auto it = gemGeom->superChambers().begin(), end = gemGeom->superChambers().end(); it != end; ++it) {
675  const GEMSuperChamber* sc = (*it);
676  if (sc) {
677  GEMDetId detid = sc->geographicalId();
678  std::stringstream s;
679  s << detid;
680  std::string name = s.str();
681 
682  TGeoVolume* child = createVolume(name, sc, kMuonGEM);
683 
684  TGeoVolume* holder = GetDaughter(assembly, "SuperChamber Region", kMuonGEM, detid.region());
685  holder = GetDaughter(holder, "Ring", kMuonGEM, detid.ring());
686  holder = GetDaughter(holder, "Station", kMuonGEM, detid.station());
687  holder = GetDaughter(holder, "Chamber", kMuonGEM, detid.chamber());
688 
689  AddLeafNode(holder, child, name.c_str(), createPlacement(*it));
690  }
691  }
692  }
693 
694  {
695  TGeoVolume* assembly = GetDaughter(assemblyTop, "GEMetaPartitions", kMuonGEM);
696  for (auto it = gemGeom->etaPartitions().begin(), end = gemGeom->etaPartitions().end(); it != end; ++it) {
697  const GEMEtaPartition* roll = (*it);
698  if (roll) {
699  GEMDetId detid = roll->geographicalId();
700  std::stringstream s;
701  s << detid;
702  std::string name = s.str();
703 
704  TGeoVolume* child = createVolume(name, roll, kMuonGEM);
705 
706  TGeoVolume* holder = GetDaughter(assembly, "ROLL Region", kMuonGEM, detid.region());
707  holder = GetDaughter(holder, "Ring", kMuonGEM, detid.ring());
708  holder = GetDaughter(holder, "Station", kMuonGEM, detid.station());
709  holder = GetDaughter(holder, "Layer", kMuonGEM, detid.layer());
710  holder = GetDaughter(holder, "Chamber", kMuonGEM, detid.chamber());
711 
712  AddLeafNode(holder, child, name.c_str(), createPlacement(*it));
713  }
714  }
715  }
716  } catch (cms::Exception& exception) {
717  edm::LogInfo("FWRecoGeometry") << "failed to produce GEM geometry " << exception.what() << std::endl;
718  }
719 }
720 
721 //______________________________________________________________________________
722 
723 void FWTGeoRecoGeometryESProducer::addRPCGeometry() {
724  TGeoVolume* tv = GetTopHolder("Muon", kMuonRPC);
725  TGeoVolume* assembly = GetDaughter(tv, "RPC", kMuonRPC);
726 
727  DetId detId(DetId::Muon, MuonSubdetId::RPC);
728  const RPCGeometry* rpcGeom = static_cast<const RPCGeometry*>(m_trackingGeom->slaveGeometry(detId));
729  for (auto it = rpcGeom->rolls().begin(), end = rpcGeom->rolls().end(); it != end; ++it) {
730  RPCRoll const* roll = (*it);
731  if (roll) {
732  RPCDetId detid = roll->geographicalId();
733  std::stringstream s;
734  s << detid;
735  std::string name = s.str();
736 
737  TGeoVolume* child = createVolume(name, roll, kMuonRPC);
738 
739  TGeoVolume* holder = GetDaughter(assembly, "ROLL Region", kMuonRPC, detid.region());
740  holder = GetDaughter(holder, "Ring", kMuonRPC, detid.ring());
741  holder = GetDaughter(holder, "Station", kMuonRPC, detid.station());
742  holder = GetDaughter(holder, "Sector", kMuonRPC, detid.sector());
743  holder = GetDaughter(holder, "Layer", kMuonRPC, detid.layer());
744  holder = GetDaughter(holder, "Subsector", kMuonRPC, detid.subsector());
745 
746  AddLeafNode(holder, child, name.c_str(), createPlacement(*it));
747  }
748  };
749 }
750 
751 void FWTGeoRecoGeometryESProducer::addME0Geometry() {
752  TGeoVolume* tv = GetTopHolder("Muon", kMuonME0);
753  TGeoVolume* assembly = GetDaughter(tv, "ME0", kMuonME0);
754 
755  DetId detId(DetId::Muon, 5);
756  try {
757  const ME0Geometry* me0Geom = static_cast<const ME0Geometry*>(m_trackingGeom->slaveGeometry(detId));
758 
759  for (auto roll : me0Geom->etaPartitions()) {
760  if (roll) {
761  unsigned int rawid = roll->geographicalId().rawId();
762  //std::cout << "AMT FWTTTTRecoGeometryES\n" << rawid ;
763 
764  ME0DetId detid(rawid);
765  std::stringstream s;
766  s << detid;
767  std::string name = s.str();
768  TGeoVolume* child = createVolume(name, roll, kMuonME0);
769 
770  TGeoVolume* holder = GetDaughter(assembly, "Region", kMuonME0, detid.region());
771  holder = GetDaughter(holder, "Layer", kMuonME0, detid.layer());
772  holder = GetDaughter(holder, "Chamber", kMuonME0, detid.chamber());
773  AddLeafNode(holder, child, name.c_str(), createPlacement(roll));
774  }
775  }
776  } catch (cms::Exception& exception) {
777  edm::LogInfo("FWRecoGeometry") << "failed to produce ME0 geometry " << exception.what() << std::endl;
778  }
779 }
780 
781 //==============================================================================
782 //================================= CALO =======================================
783 //==============================================================================
784 
785 void FWTGeoRecoGeometryESProducer::addHcalCaloGeometryBarrel(void) {
786  TGeoVolume* tv = GetTopHolder("HCal", kHCal);
787  TGeoVolume* assembly = GetDaughter(tv, "HCalBarrel", kHCal);
788 
789  std::vector<DetId> vid = m_caloGeom->getValidDetIds(DetId::Hcal, HcalSubdetector::HcalBarrel);
790 
791  CaloVolMap caloShapeMapP;
792  CaloVolMap caloShapeMapN;
793  for (std::vector<DetId>::const_iterator it = vid.begin(), end = vid.end(); it != end; ++it) {
794  //HcalDetId detid = HcalDetId(it->rawId());
795  HcalDetId detid(*it);
796  const CaloCellGeometry* cellb = (m_caloGeom->getGeometry(*it)).get();
797  const IdealObliquePrism* cell = dynamic_cast<const IdealObliquePrism*>(cellb);
798 
799  if (!cell) {
800  printf("HB not oblique !!!\n");
801  continue;
802  }
803 
804  TGeoVolume* volume = nullptr;
805  CaloVolMap& caloShapeMap = (cell->etaPos() > 0) ? caloShapeMapP : caloShapeMapN;
806  CaloVolMap::iterator volIt = caloShapeMap.find(cell->param());
807  if (volIt == caloShapeMap.end()) {
808  // printf("FIREWORKS NEW SHAPE BEGIN eta = %f etaPos = %f, phiPos %f >>>>>> \n", cell->eta(), cell->etaPos(), cell->phiPos());
809  IdealObliquePrism::Pt3DVec lc(8);
810  IdealObliquePrism::Pt3D ref;
811  IdealObliquePrism::localCorners(lc, cell->param(), ref);
812  HepGeom::Vector3D<float> lCenter;
813  for (int c = 0; c < 8; ++c)
814  lCenter += lc[c];
815  lCenter *= 0.125;
816 
817  static const int arr[] = {1, 0, 3, 2, 5, 4, 7, 6};
818  double points[16];
819  for (int c = 0; c < 8; ++c) {
820  if (cell->etaPos() > 0)
821  points[c * 2 + 0] = -(lc[arr[c]].z() - lCenter.z());
822  else
823  points[c * 2 + 0] = (lc[arr[c]].z() - lCenter.z());
824  points[c * 2 + 1] = (lc[arr[c]].y() - lCenter.y());
825  // printf("AMT xy[%d] <=>[%d] = (%.4f, %.4f) \n", arr[c], c, points[c*2], points[c*2+1]);
826  }
827 
828  float dz = (lc[4].x() - lc[0].x()) * 0.5;
829  TGeoShape* solid = new TGeoArb8(dz, &points[0]);
830  volume = new TGeoVolume("hcal oblique prism", solid, GetMedium(kHCal));
831  caloShapeMap[cell->param()] = volume;
832  } else {
833  volume = volIt->second;
834  }
835 
836  HepGeom::Vector3D<float> gCenter;
837  CaloCellGeometry::CornersVec const& gc = cell->getCorners();
838  for (int c = 0; c < 8; ++c)
839  gCenter += HepGeom::Vector3D<float>(gc[c].x(), gc[c].y(), gc[c].z());
840  gCenter *= 0.125;
841 
842  TGeoTranslation gtr(gCenter.x(), gCenter.y(), gCenter.z());
843  TGeoRotation rot;
844  rot.RotateY(90);
845 
846  TGeoRotation rotPhi;
847  rotPhi.SetAngles(0, -cell->phiPos() * TMath::RadToDeg(), 0);
848  rot.MultiplyBy(&rotPhi);
849 
850  TGeoVolume* holder = GetDaughter(assembly, "side", kHCal, detid.zside());
851  holder = GetDaughter(holder, "ieta", kHCal, detid.ieta());
852  std::stringstream nname;
853  nname << detid;
854  AddLeafNode(holder, volume, nname.str().c_str(), new TGeoCombiTrans(gtr, rot));
855  }
856 
857  // printf("HB map size P = %lu , N = %lu", caloShapeMapP.size(),caloShapeMapN.size() );
858 }
859 //______________________________________________________________________________
860 
861 void FWTGeoRecoGeometryESProducer::addHcalCaloGeometryEndcap(void) {
862  CaloVolMap caloShapeMapP;
863  CaloVolMap caloShapeMapN;
864 
865  TGeoVolume* tv = GetTopHolder("HCal", kHCal);
866  TGeoVolume* assembly = GetDaughter(tv, "HCalEndcap", kHCal);
867 
868  std::vector<DetId> vid = m_caloGeom->getValidDetIds(DetId::Hcal, HcalSubdetector::HcalEndcap);
869 
870  for (std::vector<DetId>::const_iterator it = vid.begin(), end = vid.end(); it != end; ++it) {
871  HcalDetId detid = HcalDetId(it->rawId());
872  const CaloCellGeometry* cellb = (m_caloGeom->getGeometry(*it)).get();
873  const IdealObliquePrism* cell = dynamic_cast<const IdealObliquePrism*>(cellb);
874 
875  if (!cell) {
876  printf("EC not oblique \n");
877  continue;
878  }
879 
880  TGeoVolume* volume = nullptr;
881  CaloVolMap& caloShapeMap = (cell->etaPos() > 0) ? caloShapeMapP : caloShapeMapN;
882  CaloVolMap::iterator volIt = caloShapeMap.find(cell->param());
883  if (volIt == caloShapeMap.end()) {
884  IdealObliquePrism::Pt3DVec lc(8);
885  IdealObliquePrism::Pt3D ref;
886  IdealObliquePrism::localCorners(lc, cell->param(), ref);
887  HepGeom::Vector3D<float> lCenter;
888  for (int c = 0; c < 8; ++c)
889  lCenter += lc[c];
890  lCenter *= 0.125;
891 
892  //for( int c = 0; c < 8; ++c)
893  // printf("lc.push_back(TEveVector(%.4f, %.4f, %.4f));\n", lc[c].x(), lc[c].y(), lc[c].z() );
894 
895  static const int arrP[] = {3, 2, 1, 0, 7, 6, 5, 4};
896  static const int arrN[] = {7, 6, 5, 4, 3, 2, 1, 0};
897  const int* arr = (detid.ieta() > 0) ? &arrP[0] : &arrN[0];
898 
899  double points[16];
900  for (int c = 0; c < 8; ++c) {
901  points[c * 2 + 0] = lc[arr[c]].x() - lCenter.x();
902  points[c * 2 + 1] = lc[arr[c]].y() - lCenter.y();
903  }
904 
905  float dz = (lc[4].z() - lc[0].z()) * 0.5;
906  TGeoShape* solid = new TGeoArb8(dz, &points[0]);
907  volume = new TGeoVolume("ecal oblique prism", solid, GetMedium(kHCal));
908  caloShapeMap[cell->param()] = volume;
909  } else {
910  volume = volIt->second;
911  }
912 
913  HepGeom::Vector3D<float> gCenter;
914  CaloCellGeometry::CornersVec const& gc = cell->getCorners();
915  for (int c = 0; c < 8; ++c) {
916  gCenter += HepGeom::Vector3D<float>(gc[c].x(), gc[c].y(), gc[c].z());
917  // printf("gc.push_back(TEveVector(%.4f, %.4f, %.4f));\n", gc[c].x(), gc[c].y(),gc[c].z() );
918  }
919  gCenter *= 0.125;
920 
921  TGeoTranslation gtr(gCenter.x(), gCenter.y(), gCenter.z());
922  TGeoRotation rot;
923  rot.SetAngles(cell->phiPos() * TMath::RadToDeg(), 0, 0);
924 
925  TGeoVolume* holder = GetDaughter(assembly, "side", kHCal, detid.zside());
926  holder = GetDaughter(holder, "ieta", kHCal, detid.ieta());
927  std::stringstream nname;
928  nname << detid;
929  AddLeafNode(holder, volume, nname.str().c_str(), new TGeoCombiTrans(gtr, rot));
930  }
931 
932  // printf("HE map size P = %lu , N = %lu", caloShapeMapP.size(),caloShapeMapN.size() );
933 }
934 
935 void FWTGeoRecoGeometryESProducer::addHcalCaloGeometryOuter() {
936  CaloVolMap caloShapeMapP;
937  CaloVolMap caloShapeMapN;
938 
939  TGeoVolume* tv = GetTopHolder("HCal", kHCal);
940  TGeoVolume* assembly = GetDaughter(tv, "HCalOuter", kHCal);
941 
942  std::vector<DetId> vid = m_caloGeom->getValidDetIds(DetId::Hcal, HcalSubdetector::HcalOuter);
943 
944  for (std::vector<DetId>::const_iterator it = vid.begin(), end = vid.end(); it != end; ++it) {
945  HcalDetId detid = HcalDetId(it->rawId());
946  const CaloCellGeometry* cellb = (m_caloGeom->getGeometry(*it)).get();
947  const IdealObliquePrism* cell = dynamic_cast<const IdealObliquePrism*>(cellb);
948 
949  if (!cell) {
950  printf("EC not oblique \n");
951  continue;
952  }
953 
954  TGeoVolume* volume = nullptr;
955  CaloVolMap& caloShapeMap = (cell->etaPos() > 0) ? caloShapeMapP : caloShapeMapN;
956  CaloVolMap::iterator volIt = caloShapeMap.find(cell->param());
957  if (volIt == caloShapeMap.end()) {
958  IdealObliquePrism::Pt3DVec lc(8);
959  IdealObliquePrism::Pt3D ref;
960  IdealObliquePrism::localCorners(lc, cell->param(), ref);
961  HepGeom::Vector3D<float> lCenter;
962  for (int c = 0; c < 8; ++c)
963  lCenter += lc[c];
964  lCenter *= 0.125;
965  static const int arrP[] = {3, 2, 1, 0, 7, 6, 5, 4};
966  static const int arrN[] = {7, 6, 5, 4, 3, 2, 1, 0};
967  const int* arr = (detid.ieta() > 0) ? &arrP[0] : &arrN[0];
968 
969  double points[16];
970  for (int c = 0; c < 8; ++c) {
971  points[c * 2 + 0] = lc[arr[c]].x() - lCenter.x();
972  points[c * 2 + 1] = lc[arr[c]].y() - lCenter.y();
973  }
974 
975  float dz = (lc[4].z() - lc[0].z()) * 0.5;
976  TGeoShape* solid = new TGeoArb8(dz, &points[0]);
977  volume = new TGeoVolume("ecal oblique prism", solid, GetMedium(kHCal));
978  caloShapeMap[cell->param()] = volume;
979  } else {
980  volume = volIt->second;
981  }
982  HepGeom::Vector3D<float> gCenter;
983  CaloCellGeometry::CornersVec const& gc = cell->getCorners();
984  for (int c = 0; c < 8; ++c) {
985  gCenter += HepGeom::Vector3D<float>(gc[c].x(), gc[c].y(), gc[c].z());
986  }
987  gCenter *= 0.125;
988 
989  TGeoTranslation gtr(gCenter.x(), gCenter.y(), gCenter.z());
990  TGeoRotation rot;
991  rot.SetAngles(cell->phiPos() * TMath::RadToDeg(), 0, 0);
992 
993  TGeoVolume* holder = GetDaughter(assembly, "side", kHCal, detid.zside());
994  holder = GetDaughter(holder, "ieta", kHCal, detid.ieta());
995  std::stringstream nname;
996  nname << detid;
997  AddLeafNode(holder, volume, nname.str().c_str(), new TGeoCombiTrans(gtr, rot));
998  }
999 }
1000 
1001 void FWTGeoRecoGeometryESProducer::addHcalCaloGeometryForward() {
1002  CaloVolMap caloShapeMapP;
1003  CaloVolMap caloShapeMapN;
1004 
1005  TGeoVolume* tv = GetTopHolder("HCal", kHCal);
1006  TGeoVolume* assembly = GetDaughter(tv, "HCalForward", kHCal);
1007 
1008  std::vector<DetId> vid = m_caloGeom->getValidDetIds(DetId::Hcal, HcalSubdetector::HcalForward);
1009 
1010  for (std::vector<DetId>::const_iterator it = vid.begin(), end = vid.end(); it != end; ++it) {
1011  HcalDetId detid = HcalDetId(it->rawId());
1012  const CaloCellGeometry* cellb = (m_caloGeom->getGeometry(*it)).get();
1013  const IdealZPrism* cell = dynamic_cast<const IdealZPrism*>(cellb);
1014 
1015  if (!cell) {
1016  printf("EC not Z prism \n");
1017  continue;
1018  }
1019 
1020  TGeoVolume* volume = nullptr;
1021  CaloVolMap& caloShapeMap = (cell->etaPos() > 0) ? caloShapeMapP : caloShapeMapN;
1022  CaloVolMap::iterator volIt = caloShapeMap.find(cell->param());
1023  if (volIt == caloShapeMap.end()) {
1024  IdealZPrism::Pt3DVec lc(8);
1025  IdealZPrism::Pt3D ref;
1026  IdealZPrism::localCorners(lc, cell->param(), ref);
1027  HepGeom::Vector3D<float> lCenter;
1028  for (int c = 0; c < 8; ++c)
1029  lCenter += lc[c];
1030  lCenter *= 0.125;
1031  static const int arrP[] = {3, 2, 1, 0, 7, 6, 5, 4};
1032  static const int arrN[] = {7, 6, 5, 4, 3, 2, 1, 0};
1033  const int* arr = (detid.ieta() > 0) ? &arrP[0] : &arrN[0];
1034 
1035  double points[16];
1036  for (int c = 0; c < 8; ++c) {
1037  points[c * 2 + 0] = lc[arr[c]].x() - lCenter.x();
1038  points[c * 2 + 1] = lc[arr[c]].y() - lCenter.y();
1039  }
1040 
1041  float dz = (lc[4].z() - lc[0].z()) * 0.5;
1042  TGeoShape* solid = new TGeoArb8(dz, &points[0]);
1043  volume = new TGeoVolume("ecal oblique prism", solid, GetMedium(kHCal));
1044  caloShapeMap[cell->param()] = volume;
1045  } else {
1046  volume = volIt->second;
1047  }
1048  HepGeom::Vector3D<float> gCenter;
1049  CaloCellGeometry::CornersVec const& gc = cell->getCorners();
1050  for (int c = 0; c < 8; ++c) {
1051  gCenter += HepGeom::Vector3D<float>(gc[c].x(), gc[c].y(), gc[c].z());
1052  }
1053  gCenter *= 0.125;
1054 
1055  TGeoTranslation gtr(gCenter.x(), gCenter.y(), gCenter.z());
1056  TGeoRotation rot;
1057  rot.SetAngles(cell->phiPos() * TMath::RadToDeg(), 0, 0);
1058 
1059  TGeoVolume* holder = GetDaughter(assembly, "side", kHCal, detid.zside());
1060  holder = GetDaughter(holder, "ieta", kHCal, detid.ieta());
1061  std::stringstream nname;
1062  nname << detid;
1063  AddLeafNode(holder, volume, nname.str().c_str(), new TGeoCombiTrans(gtr, rot));
1064  }
1065 }
1066 
1067 void FWTGeoRecoGeometryESProducer::addCaloTowerGeometry() {
1068  CaloVolMap caloShapeMapP;
1069  CaloVolMap caloShapeMapN;
1070 
1071  TGeoVolume* tv = GetTopHolder("CaloTower", kCaloTower);
1072  TGeoVolume* assembly = GetDaughter(tv, "CaloTower", kCaloTower);
1073 
1074  std::vector<DetId> vid = m_caloGeom->getValidDetIds(DetId::Calo, CaloTowerDetId::SubdetId);
1075  for (std::vector<DetId>::const_iterator it = vid.begin(), end = vid.end(); it != end; ++it) {
1076  CaloTowerDetId detid = CaloTowerDetId(it->rawId());
1077  const CaloCellGeometry* cellb = (m_caloGeom->getGeometry(*it)).get();
1078  const IdealObliquePrism* cell = dynamic_cast<const IdealObliquePrism*>(cellb);
1079  if (!cell) {
1080  printf("EC not oblique \n");
1081  continue;
1082  }
1083  TGeoVolume* volume = nullptr;
1084  CaloVolMap& caloShapeMap = (cell->etaPos() > 0) ? caloShapeMapP : caloShapeMapN;
1085  CaloVolMap::iterator volIt = caloShapeMap.find(cell->param());
1086  if (volIt == caloShapeMap.end()) {
1087  IdealObliquePrism::Pt3DVec lc(8);
1088  IdealObliquePrism::Pt3D ref;
1089  IdealObliquePrism::localCorners(lc, cell->param(), ref);
1090  HepGeom::Vector3D<float> lCenter;
1091  for (int c = 0; c < 8; ++c)
1092  lCenter += lc[c];
1093  lCenter *= 0.125;
1094 
1095  static const int arrP[] = {3, 2, 1, 0, 7, 6, 5, 4};
1096  static const int arrN[] = {7, 6, 5, 4, 3, 2, 1, 0};
1097  const int* arr = (detid.ieta() > 0) ? &arrP[0] : &arrN[0];
1098 
1099  double points[16];
1100  for (int c = 0; c < 8; ++c) {
1101  points[c * 2 + 0] = lc[arr[c]].x() - lCenter.x();
1102  points[c * 2 + 1] = lc[arr[c]].y() - lCenter.y();
1103  }
1104 
1105  float dz = (lc[4].z() - lc[0].z()) * 0.5;
1106  TGeoShape* solid = new TGeoArb8(dz, &points[0]);
1107  volume = new TGeoVolume("ecal oblique prism", solid, GetMedium(kCaloTower));
1108  caloShapeMap[cell->param()] = volume;
1109  } else {
1110  volume = volIt->second;
1111  }
1112 
1113  HepGeom::Vector3D<float> gCenter;
1114  CaloCellGeometry::CornersVec const& gc = cell->getCorners();
1115  for (int c = 0; c < 8; ++c) {
1116  gCenter += HepGeom::Vector3D<float>(gc[c].x(), gc[c].y(), gc[c].z());
1117  }
1118  gCenter *= 0.125;
1119 
1120  TGeoTranslation gtr(gCenter.x(), gCenter.y(), gCenter.z());
1121  TGeoRotation rot;
1122  rot.SetAngles(cell->phiPos() * TMath::RadToDeg(), 0, 0);
1123 
1124  TGeoVolume* holder = GetDaughter(assembly, "side", kCaloTower, detid.zside());
1125  holder = GetDaughter(holder, "ieta", kCaloTower, detid.ieta());
1126  std::stringstream nname;
1127  nname << detid;
1128  AddLeafNode(holder, volume, nname.str().c_str(), new TGeoCombiTrans(gtr, rot));
1129  }
1130 }
1131 
1132 //______________________________________________________________________________
1133 
1134 TGeoHMatrix* getEcalTrans(CaloCellGeometry::CornersVec const& gc) {
1135  TEveVector gCenter;
1136  for (int i = 0; i < 8; ++i)
1137  gCenter += TEveVector(gc[i].x(), gc[i].y(), gc[i].z());
1138  gCenter *= 0.125;
1139 
1140  TEveVector tgCenter; // top center 4 corners
1141  for (int i = 4; i < 8; ++i)
1142  tgCenter += TEveVector(gc[i].x(), gc[i].y(), gc[i].z());
1143  tgCenter *= 0.25;
1144 
1145  TEveVector axis = tgCenter - gCenter;
1146  axis.Normalize();
1147 
1148  TEveTrans tr;
1149  TVector3 v1t;
1150  tr.GetBaseVec(1, v1t);
1151 
1152  TEveVector v1(v1t.x(), v1t.y(), v1t.z());
1153  double dot13 = axis.Dot(v1);
1154  TEveVector gd = axis;
1155  gd *= dot13;
1156  v1 -= gd;
1157  v1.Normalize();
1158  TEveVector v2;
1159  TMath::Cross(v1.Arr(), axis.Arr(), v2.Arr());
1160  TMath::Cross(axis.Arr(), v1.Arr(), v2.Arr());
1161  v2.Normalize();
1162 
1163  tr.SetBaseVec(1, v1.fX, v1.fY, v1.fZ);
1164  tr.SetBaseVec(2, v2.fX, v2.fY, v2.fZ);
1165  tr.SetBaseVec(3, axis.fX, axis.fY, axis.fZ);
1166  tr.Move3PF(gCenter.fX, gCenter.fY, gCenter.fZ);
1167 
1168  TGeoHMatrix* out = new TGeoHMatrix();
1169  tr.SetGeoHMatrix(*out);
1170  return out;
1171 }
1172 
1173 TGeoShape* makeEcalShape(const TruncatedPyramid* cell) {
1174  // printf("BEGIN EE SHAPE --------------------------------\n");
1175  // std::cout << detid << std::endl;
1176  const HepGeom::Transform3D idtr;
1177  TruncatedPyramid::Pt3DVec co(8);
1178  TruncatedPyramid::Pt3D ref;
1179  TruncatedPyramid::localCorners(co, cell->param(), ref);
1180  //for( int c = 0; c < 8; ++c)
1181  // printf("lc.push_back(TEveVector(%.4f, %.4f, %.4f));\n", co[c].x(),co[c].y(),co[c].z() );
1182 
1183  double points[16];
1184  for (int c = 0; c < 8; ++c) {
1185  points[c * 2] = co[c].x();
1186  points[c * 2 + 1] = co[c].y();
1187  }
1188  TGeoShape* solid = new TGeoArb8(cell->param()[0], points);
1189  return solid;
1190 }
1191 
1192 //______________________________________________________________________________
1193 
1194 void FWTGeoRecoGeometryESProducer::addEcalCaloGeometry(void) {
1195  TGeoVolume* tv = GetTopHolder("ECal", kECal);
1196  CaloVolMap caloShapeMap;
1197 
1198  {
1199  TGeoVolume* assembly = GetDaughter(tv, "ECalBarrel", kECal);
1200 
1201  std::vector<DetId> vid = m_caloGeom->getValidDetIds(DetId::Ecal, EcalSubdetector::EcalBarrel);
1202  for (std::vector<DetId>::const_iterator it = vid.begin(), end = vid.end(); it != end; ++it) {
1203  EBDetId detid(*it);
1204  const CaloCellGeometry* cellb = (m_caloGeom->getGeometry(*it)).get();
1205  const TruncatedPyramid* cell = dynamic_cast<const TruncatedPyramid*>(cellb);
1206  if (!cell) {
1207  printf("ecalBarrel cell not a TruncatedPyramid !!\n");
1208  return;
1209  }
1210 
1211  TGeoVolume* volume = nullptr;
1212  CaloVolMap::iterator volIt = caloShapeMap.find(cell->param());
1213  if (volIt == caloShapeMap.end()) {
1214  volume = new TGeoVolume("EE TruncatedPyramid", makeEcalShape(cell), GetMedium(kECal));
1215  caloShapeMap[cell->param()] = volume;
1216  } else {
1217  volume = volIt->second;
1218  }
1219  TGeoHMatrix* mtx = getEcalTrans(cell->getCorners());
1220  TGeoVolume* holder = GetDaughter(assembly, "side", kECal, detid.zside());
1221  holder = GetDaughter(holder, "ieta", kECal, detid.ieta());
1222  std::stringstream nname;
1223  nname << detid;
1224  AddLeafNode(holder, volume, nname.str().c_str(), mtx);
1225  }
1226  }
1227 
1228  {
1229  TGeoVolume* assembly = GetDaughter(tv, "ECalEndcap", kECal);
1230 
1231  std::vector<DetId> vid = m_caloGeom->getValidDetIds(DetId::Ecal, EcalSubdetector::EcalEndcap);
1232  for (std::vector<DetId>::const_iterator it = vid.begin(), end = vid.end(); it != end; ++it) {
1233  EEDetId detid(*it);
1234  const CaloCellGeometry* cellb = (m_caloGeom->getGeometry(*it)).get();
1235  const TruncatedPyramid* cell = dynamic_cast<const TruncatedPyramid*>(cellb);
1236  if (!cell) {
1237  printf("ecalEndcap cell not a TruncatedPyramid !!\n");
1238  continue;
1239  }
1240 
1241  TGeoVolume* volume = nullptr;
1242  CaloVolMap::iterator volIt = caloShapeMap.find(cell->param());
1243  if (volIt == caloShapeMap.end()) {
1244  volume = new TGeoVolume("EE TruncatedPyramid", makeEcalShape(cell), GetMedium(kECal));
1245  caloShapeMap[cell->param()] = volume;
1246  } else {
1247  volume = volIt->second;
1248  }
1249  TGeoHMatrix* mtx = getEcalTrans(cell->getCorners());
1250  TGeoVolume* holder = GetDaughter(assembly, "side", kECal, detid.zside());
1251  holder = GetDaughter(holder, "ix", kECal, detid.ix());
1252  std::stringstream nname;
1253  nname << detid;
1254  AddLeafNode(holder, volume, nname.str().c_str(), mtx);
1255  }
1256  }
1257 }
IdealObliquePrism.h
FWTGeoRecoGeometry.h
MuonSubdetId::GEM
static constexpr int GEM
Definition: MuonSubdetId.h:14
TrackerTopology::tibOrder
unsigned int tibOrder(const DetId &id) const
Definition: TrackerTopology.h:209
HLT_2018_cff.points
points
Definition: HLT_2018_cff.py:20125
ME0Geometry::etaPartitions
const std::vector< ME0EtaPartition const * > & etaPartitions() const
Return a vector of all ME0 eta partitions.
Definition: ME0Geometry.cc:33
RPCRoll
Definition: RPCRoll.h:12
FWTGeoRecoGeometryESProducer::addEcalCaloGeometry
void addEcalCaloGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:1194
TkRotation< float >
DTSuperLayerId
Definition: DTSuperLayerId.h:12
DDAxes::y
TrackerTopology::side
unsigned int side(const DetId &id) const
Definition: TrackerTopology.cc:28
ApeEstimator_cff.width
width
Definition: ApeEstimator_cff.py:24
FWTGeoRecoGeometryESProducer::m_recoMedium
std::map< ERecoDet, TGeoMedium * > m_recoMedium
Definition: FWTGeoRecoGeometryESProducer.h:89
FWTGeoRecoGeometryESProducer::kMuonRPC
Definition: FWTGeoRecoGeometryESProducer.h:37
EBDetId::ieta
int ieta() const
get the crystal ieta
Definition: EBDetId.h:49
mps_fire.i
i
Definition: mps_fire.py:355
TkRotation::zy
T zy() const
Definition: extTkRotation.h:258
FWTGeoRecoGeometryESProducer::kMuonME0
Definition: FWTGeoRecoGeometryESProducer.h:40
Bounds::width
virtual float width() const =0
StripGeomDetUnit.h
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
TrackerGeometry.h
FWTGeoRecoGeometryESProducer::addHcalCaloGeometryBarrel
void addHcalCaloGeometryBarrel()
Definition: FWTGeoRecoGeometryESProducer.cc:785
GeomDet
Definition: GeomDet.h:27
StripGeomDetType.h
FWTGeoRecoGeometryESProducer::addCSCGeometry
void addCSCGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:628
makeMuonMisalignmentScenario.matrix
list matrix
Definition: makeMuonMisalignmentScenario.py:141
FWTGeoRecoGeometryRecord.h
GEMSuperChamber
Definition: GEMSuperChamber.h:19
RectangularPixelTopology.h
vid
Definition: VIDCutFlowResult.h:25
FWTGeoRecoGeometryESProducer::kECal
Definition: FWTGeoRecoGeometryESProducer.h:41
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
IdealObliquePrism::Pt3DVec
CaloCellGeometry::Pt3DVec Pt3DVec
Definition: IdealObliquePrism.h:32
FWTGeoRecoGeometryESProducer::m_trackerTopologyToken
edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > m_trackerTopologyToken
Definition: FWTGeoRecoGeometryESProducer.h:92
FWTGeoRecoGeometryESProducer::m_tracker
bool m_tracker
Definition: FWTGeoRecoGeometryESProducer.h:102
EBDetId
Definition: EBDetId.h:17
edm
HLT enums.
Definition: AlignableModifier.h:19
ME0Geometry
Definition: ME0Geometry.h:12
ME0DetId.h
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:155
RPCDetId
Definition: RPCDetId.h:16
FWTGeoRecoGeometryESProducer::addTOBGeometry
void addTOBGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:508
EBDetId.h
GEMEtaPartition
Definition: GEMEtaPartition.h:12
EEDetId.h
DetId::Hcal
Definition: DetId.h:28
edm::LogInfo
Definition: MessageLogger.h:254
FWTGeoRecoGeometryESProducer::GetDaughter
TGeoVolume * GetDaughter(TGeoVolume *mother, const char *prefix, ERecoDet cidx, int id)
Definition: FWTGeoRecoGeometryESProducer.cc:121
edm::ESProducer::setWhatProduced
auto setWhatProduced(T *iThis, const es::Label &iLabel={})
Definition: ESProducer.h:138
GlobalPosition_Frontier_DevDB_cff.record
record
Definition: GlobalPosition_Frontier_DevDB_cff.py:10
FWTGeoRecoGeometryESProducer.h
Bounds
Definition: Bounds.h:18
FWTGeoRecoGeometryESProducer::produce
std::unique_ptr< FWTGeoRecoGeometry > produce(const FWTGeoRecoGeometryRecord &)
Definition: FWTGeoRecoGeometryESProducer.cc:263
TrackingGeometry::dets
virtual const DetContainer & dets() const =0
Returm a vector of all GeomDet (including all GeomDetUnits)
FWTGeoRecoGeometryESProducer::kMuonDT
Definition: FWTGeoRecoGeometryESProducer.h:36
CaloCellGeometry::getCorners
CornersVec const & getCorners() const
Returns the corner points of this cell's volume.
Definition: CaloCellGeometry.h:73
TruncatedPyramid::Pt3DVec
CaloCellGeometry::Pt3DVec Pt3DVec
Definition: TruncatedPyramid.h:23
TruncatedPyramid
A base class to handle the particular shape of Ecal Xtals. Taken from ORCA Calorimetry Code.
Definition: TruncatedPyramid.h:19
FWTGeoRecoGeometryESProducer::addPixelForwardGeometry
void addPixelForwardGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:445
DDAxes::x
CaloTowerDetId::SubdetId
static const int SubdetId
Definition: CaloTowerDetId.h:34
StripTopology.h
HcalBarrel
Definition: HcalAssistant.h:33
EZArrayFL< GlobalPoint >
cms::cuda::co
T *__restrict__ co
Definition: prefixScan.h:46
b2
static constexpr float b2
Definition: L1EGammaCrystalsEmulatorProducer.cc:82
FWTGeoRecoGeometryESProducer::addME0Geometry
void addME0Geometry()
Definition: FWTGeoRecoGeometryESProducer.cc:751
EEDetId::ix
int ix() const
Definition: EEDetId.h:77
DetId::Calo
Definition: DetId.h:29
FWTGeoRecoGeometryESProducer::ERecoDet
ERecoDet
Definition: FWTGeoRecoGeometryESProducer.h:32
FWTGeoRecoGeometryESProducer::addHcalCaloGeometryForward
void addHcalCaloGeometryForward()
Definition: FWTGeoRecoGeometryESProducer.cc:1001
EcalBarrel
Definition: EcalSubdetector.h:10
getEcalTrans
TGeoHMatrix * getEcalTrans(CaloCellGeometry::CornersVec const &gc)
Definition: FWTGeoRecoGeometryESProducer.cc:1134
RectangularStripTopology.h
TrackerTopology::tidRing
unsigned int tidRing(const DetId &id) const
Definition: TrackerTopology.h:218
HcalGeometry.h
end
#define end
Definition: vmac.h:39
TrackerTopology::tobRod
unsigned int tobRod(const DetId &id) const
Definition: TrackerTopology.h:195
TrackerTopology::tidWheel
unsigned int tidWheel(const DetId &id) const
Definition: TrackerTopology.h:201
FWTGeoRecoGeometryRecord
Definition: FWTGeoRecoGeometryRecord.h:9
Bounds::length
virtual float length() const =0
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
TrackerTopology::tibSide
unsigned int tibSide(const DetId &id) const
Definition: TrackerTopology.h:186
Phase2TrackerMonitorDigi_cff.switch
switch
Definition: Phase2TrackerMonitorDigi_cff.py:12
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
TrackerTopology::pxfPanel
unsigned int pxfPanel(const DetId &id) const
Definition: TrackerTopology.h:450
TrackerGeometry::detsPXB
const DetContainer & detsPXB() const
Definition: TrackerGeometry.cc:171
FWTGeoRecoGeometryESProducer::~FWTGeoRecoGeometryESProducer
~FWTGeoRecoGeometryESProducer(void) override
Definition: FWTGeoRecoGeometryESProducer.cc:80
DetId
Definition: DetId.h:17
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:37
EBDetId::zside
int zside() const
get the z-side of the crystal (1/-1)
Definition: EBDetId.h:45
TrackerTopology.h
alignCSCRings.s
s
Definition: alignCSCRings.py:92
FWTGeoRecoGeometryESProducer::FWTGeoRecoGeometryESProducer
FWTGeoRecoGeometryESProducer(const edm::ParameterSet &)
Definition: FWTGeoRecoGeometryESProducer.cc:63
TrackerGeometry::detsTOB
const DetContainer & detsTOB() const
Definition: TrackerGeometry.cc:179
IdealObliquePrism
Definition: IdealObliquePrism.h:28
GEMEtaPartition.h
FWTGeoRecoGeometryESProducer::kSiStrip
Definition: FWTGeoRecoGeometryESProducer.h:35
FWTGeoRecoGeometryESProducer::addHcalCaloGeometryEndcap
void addHcalCaloGeometryEndcap()
Definition: FWTGeoRecoGeometryESProducer.cc:861
FWTGeoRecoGeometryESProducer::addPixelBarrelGeometry
void addPixelBarrelGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:425
TrapezoidalPlaneBounds.h
Calorimetry_cff.thickness
thickness
Definition: Calorimetry_cff.py:114
TkRotation::xz
T xz() const
Definition: extTkRotation.h:253
TruncatedPyramid.h
IdealZPrism.h
Surface::bounds
const Bounds & bounds() const
Definition: Surface.h:87
DDAxes::z
FWTGeoRecoGeometryESProducer::m_caloGeomToken
edm::ESGetToken< CaloGeometry, CaloGeometryRecord > m_caloGeomToken
Definition: FWTGeoRecoGeometryESProducer.h:93
TrackerTopology::print
std::string print(DetId detid) const
Definition: TrackerTopology.cc:252
FWTGeoRecoGeometryESProducer::GetTopHolder
TGeoVolume * GetTopHolder(const char *prefix, ERecoDet cidx)
Definition: FWTGeoRecoGeometryESProducer.cc:156
TrackerGeometry::detsPXF
const DetContainer & detsPXF() const
Definition: TrackerGeometry.cc:173
RectangularPlaneBounds.h
relativeConstraints.geom
geom
Definition: relativeConstraints.py:72
HcalOuter
Definition: HcalAssistant.h:35
GMCol
GMCol
Definition: FWTGeoRecoGeometryESProducer.cc:164
EEDetId::zside
int zside() const
Definition: EEDetId.h:71
b
double b
Definition: hdecay.h:118
FWTGeoRecoGeometryESProducer::m_dummyMedium
TGeoMedium * m_dummyMedium
Definition: FWTGeoRecoGeometryESProducer.h:100
FWTGeoRecoGeometryESProducer::m_muon
bool m_muon
Definition: FWTGeoRecoGeometryESProducer.h:103
IdealObliquePrism::Pt3D
CaloCellGeometry::Pt3D Pt3D
Definition: IdealObliquePrism.h:31
IdealZPrism
Definition: IdealZPrism.h:26
DTLayerId
Definition: DTLayerId.h:12
IdealObliquePrism::localCorners
static void localCorners(Pt3DVec &vec, const CCGFloat *pv, Pt3D &ref)
Definition: IdealObliquePrism.cc:45
TrackerGeometry::detsTID
const DetContainer & detsTID() const
Definition: TrackerGeometry.cc:177
FWTGeoRecoGeometryESProducer::addDTGeometry
void addDTGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:554
EEDetId
Definition: EEDetId.h:14
FWTGeoRecoGeometryESProducer::m_trackerGeom
const TrackerGeometry * m_trackerGeom
Definition: FWTGeoRecoGeometryESProducer.h:97
DTLayer.h
CaloGeometryRecord.h
TkRotation::yx
T yx() const
Definition: extTkRotation.h:254
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DTGeometry.h
EcalSubdetector.h
EcalEndcap
Definition: EcalSubdetector.h:10
RPCDetId.h
FWTGeoRecoGeometryESProducer::m_caloGeom
const CaloGeometry * m_caloGeom
Definition: FWTGeoRecoGeometryESProducer.h:96
cppFunctionSkipper.exception
exception
Definition: cppFunctionSkipper.py:10
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:64
FWTGeoRecoGeometryESProducer::createVolume
TGeoVolume * createVolume(const std::string &name, const GeomDet *det, ERecoDet=kDummy)
Definition: FWTGeoRecoGeometryESProducer.cc:402
Bounds::thickness
virtual float thickness() const =0
HcalDetId::ieta
constexpr int ieta() const
get the cell ieta
Definition: HcalDetId.h:155
edm::ParameterSet
Definition: ParameterSet.h:36
idealTransformation.rotation
dictionary rotation
Definition: idealTransformation.py:1
DetId::Tracker
Definition: DetId.h:25
TkRotation::xx
T xx() const
Definition: extTkRotation.h:251
IdealZPrism::localCorners
static void localCorners(Pt3DVec &vec, const CCGFloat *pv, Pt3D &ref)
Definition: IdealZPrism.cc:72
CaloCellGeometry
Definition: CaloCellGeometry.h:50
FWTGeoRecoGeometryESProducer::kCaloTower
Definition: FWTGeoRecoGeometryESProducer.h:43
CaloGeometry::getGeometry
std::shared_ptr< const CaloCellGeometry > getGeometry(const DetId &id) const
Get the cell geometry of a given detector id.
Definition: CaloGeometry.cc:60
HcalDetId.h
GEMDetId
Definition: GEMDetId.h:17
CSCDetId
Definition: CSCDetId.h:26
CaloCellGeometry::param
const CCGFloat * param() const
Definition: CaloCellGeometry.h:99
eventshapeDQM_cfi.order
order
Definition: eventshapeDQM_cfi.py:8
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
TrackerTopology::tibModule
unsigned int tibModule(const DetId &id) const
Definition: TrackerTopology.h:172
TrackerTopology::tidSide
unsigned int tidSide(const DetId &id) const
Definition: TrackerTopology.h:190
FWTGeoRecoGeometryESProducer::m_trackingGeom
const GlobalTrackingGeometry * m_trackingGeom
Definition: FWTGeoRecoGeometryESProducer.h:95
HcalDetId
Definition: HcalDetId.h:12
makeMuonMisalignmentScenario.wheel
wheel
Definition: makeMuonMisalignmentScenario.py:319
TrackerTopology::tecRing
unsigned int tecRing(const DetId &id) const
ring id
Definition: TrackerTopology.h:217
FWTGeoRecoGeometryESProducer::createShape
TGeoShape * createShape(const GeomDet *det)
Definition: FWTGeoRecoGeometryESProducer.cc:339
TrackerTopology::pxfDisk
unsigned int pxfDisk(const DetId &id) const
Definition: TrackerTopology.h:446
TkRotation::xy
T xy() const
Definition: extTkRotation.h:252
GlobalTrackingGeometry::slaveGeometry
const TrackingGeometry * slaveGeometry(DetId id) const
Return the pointer to the actual geometry for a given DetId.
Definition: GlobalTrackingGeometry.cc:54
TrackerGeometry::detsTIB
const DetContainer & detsTIB() const
Definition: TrackerGeometry.cc:175
CaloTowerDetId.h
ME0DetId
Definition: ME0DetId.h:16
TkRotation::zz
T zz() const
Definition: extTkRotation.h:259
HcalSubdetector.h
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
DetId::Ecal
Definition: DetId.h:27
module
Definition: vlib.h:198
TrapezoidalPlaneBounds
Definition: TrapezoidalPlaneBounds.h:15
get
#define get
cc
res
Definition: Electron.h:6
FWTGeoRecoGeometryESProducer::m_calo
bool m_calo
Definition: FWTGeoRecoGeometryESProducer.h:104
HcalForward
Definition: HcalAssistant.h:36
FWTGeoRecoGeometryESProducer::kMuonGEM
Definition: FWTGeoRecoGeometryESProducer.h:39
TkRotation::yz
T yz() const
Definition: extTkRotation.h:256
FWTGeoRecoGeometryESProducer::addTECGeometry
void addTECGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:528
ME0Geometry.h
GloballyPositioned::position
const PositionType & position() const
Definition: GloballyPositioned.h:36
CaloCellGeometry.h
GEMGeometry.h
GEMDetId.h
FWTGeoRecoGeometryESProducer::m_shapeToVolume
std::map< TGeoShape *, TGeoVolume * > m_shapeToVolume
Definition: FWTGeoRecoGeometryESProducer.h:88
TruncatedPyramid::localCorners
static void localCorners(Pt3DVec &vec, const CCGFloat *pv, Pt3D &ref)
Definition: TruncatedPyramid.cc:177
CaloGeometry::getValidDetIds
std::vector< DetId > getValidDetIds() const
Get the list of all valid detector ids.
Definition: CaloGeometry.cc:75
TrapezoidalStripTopology.h
CaloTowerDetId::ieta
int ieta() const
get the tower ieta
Definition: CaloTowerDetId.h:30
TrackerTopology::tobModule
unsigned int tobModule(const DetId &id) const
Definition: TrackerTopology.h:166
CaloCellGeometry::etaPos
virtual float etaPos() const
Definition: CaloCellGeometry.h:88
TrackerTopology::pxbModule
unsigned int pxbModule(const DetId &id) const
Definition: TrackerTopology.h:160
FWTGeoRecoGeometryESProducer::kHCal
Definition: FWTGeoRecoGeometryESProducer.h:42
FWTGeoRecoGeometryESProducer::addCaloTowerGeometry
void addCaloTowerGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:1067
CSCLayer.h
HcalEndcap
Definition: HcalAssistant.h:34
PVValHelper::dz
Definition: PVValidationHelpers.h:50
TrackerGeometry::detsTEC
const DetContainer & detsTEC() const
Definition: TrackerGeometry.cc:181
MuonSubdetId::RPC
static constexpr int RPC
Definition: MuonSubdetId.h:13
IdealZPrism::Pt3D
CaloCellGeometry::Pt3D Pt3D
Definition: IdealZPrism.h:31
TkRotation::yy
T yy() const
Definition: extTkRotation.h:255
CaloGeometry.h
ME0EtaPartition.h
TrackerTopology::tecOrder
unsigned int tecOrder(const DetId &id) const
Definition: TrackerTopology.h:206
PixelGeomDetUnit.h
PVValHelper::ladder
Definition: PVValidationHelpers.h:72
relativeConstraints.ring
ring
Definition: relativeConstraints.py:68
FWTGeoRecoGeometryESProducer::addTIBGeometry
void addTIBGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:468
makeMuonMisalignmentScenario.rot
rot
Definition: makeMuonMisalignmentScenario.py:322
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
CaloCellGeometry::phiPos
virtual float phiPos() const
Definition: CaloCellGeometry.h:89
makeEcalShape
TGeoShape * makeEcalShape(const TruncatedPyramid *cell)
Definition: FWTGeoRecoGeometryESProducer.cc:1173
TrackerTopology::tecModule
unsigned int tecModule(const DetId &id) const
Definition: TrackerTopology.h:169
GEMGeometry::etaPartitions
const std::vector< const GEMEtaPartition * > & etaPartitions() const
Return a vector of all GEM eta partitions.
Definition: GEMGeometry.cc:40
FWTGeoRecoGeometryESProducer::GetMedium
TGeoMedium * GetMedium(ERecoDet)
Definition: FWTGeoRecoGeometryESProducer.cc:181
MillePedeFileConverter_cfg.out
out
Definition: MillePedeFileConverter_cfg.py:31
DTChamber.h
FWTGeoRecoGeometryESProducer::kHGCE
Definition: FWTGeoRecoGeometryESProducer.h:44
GEMGeometry
Definition: GEMGeometry.h:24
FWTGeoRecoGeometryESProducer::m_trackingGeomToken
edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord > m_trackingGeomToken
Definition: FWTGeoRecoGeometryESProducer.h:91
TrackerTopology::pxfBlade
unsigned int pxfBlade(const DetId &id) const
Definition: TrackerTopology.h:447
FWTGeoRecoGeometryESProducer::m_trackerTopology
const TrackerTopology * m_trackerTopology
Definition: FWTGeoRecoGeometryESProducer.h:98
RPCGeometry
Definition: RPCGeometry.h:20
cms::Exception
Definition: Exception.h:70
DetId::Muon
Definition: DetId.h:26
DTChamberId
Definition: DTChamberId.h:14
CaloTowerDetId::zside
int zside() const
get the z-side of the tower (1/-1)
Definition: CaloTowerDetId.h:26
RPCGeometry::rolls
const std::vector< const RPCRoll * > & rolls() const
Return a vector of all RPC rolls.
Definition: RPCGeometry.cc:44
FWTGeoRecoGeometryESProducer::addRPCGeometry
void addRPCGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:723
ParameterSet.h
FWTGeoRecoGeometryESProducer::kHGCH
Definition: FWTGeoRecoGeometryESProducer.h:45
GEMGeometry::superChambers
const std::vector< const GEMSuperChamber * > & superChambers() const
Return a vector of all GEM super chambers.
Definition: GEMGeometry.cc:36
GloballyPositioned::rotation
const RotationType & rotation() const
Definition: GloballyPositioned.h:38
HcalDetId::zside
constexpr int zside() const
get the z-side of the cell (1/-1)
Definition: HcalDetId.h:141
CSCChamber.h
IdealZPrism::Pt3DVec
CaloCellGeometry::Pt3DVec Pt3DVec
Definition: IdealZPrism.h:32
GlobalTrackingGeometry.h
child
Definition: simpleInheritance.h:11
FWTGeoRecoGeometryESProducer::m_nameToShape
std::map< std::string, TGeoShape * > m_nameToShape
Definition: FWTGeoRecoGeometryESProducer.h:87
TkRotation::zx
T zx() const
Definition: extTkRotation.h:257
dd4hep::createPlacement
TGeoCombiTrans * createPlacement(const Rotation3D &iRot, const Position &iTrans)
Definition: DDDefinitions2Objects.cc:109
TruncatedPyramid::Pt3D
CaloCellGeometry::Pt3D Pt3D
Definition: TruncatedPyramid.h:22
FWTGeoRecoGeometryESProducer::kSiPixel
Definition: FWTGeoRecoGeometryESProducer.h:34
RPCGeometry.h
FWTGeoRecoGeometryESProducer::addTIDGeometry
void addTIDGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:488
FWTGeoRecoGeometryESProducer::addGEMGeometry
void addGEMGeometry()
Definition: FWTGeoRecoGeometryESProducer.cc:664
TrackerTopology::tobSide
unsigned int tobSide(const DetId &id) const
Definition: TrackerTopology.h:180
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
CSCGeometry.h
FWTGeoRecoGeometryESProducer::kMuonCSC
Definition: FWTGeoRecoGeometryESProducer.h:38
ZMuMuAnalysisNtupler_cff.prefix
prefix
Definition: ZMuMuAnalysisNtupler_cff.py:14
CaloTowerDetId
Definition: CaloTowerDetId.h:12
FWTGeoRecoGeometryESProducer::addHcalCaloGeometryOuter
void addHcalCaloGeometryOuter()
Definition: FWTGeoRecoGeometryESProducer.cc:935
Generated for CMSSW Reference Manual by doxygen 1.8.16