ATLAS Offline Software
VP1CaloLegoSystem.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "VP1LegoSystems/VP1CaloLegoSystem.h"
6 #include "ui_calolegocontrollerform.h"
7 
8 #include <QMap>
9 
10 #include <Inventor/nodes/SoSwitch.h>
11 #include <Inventor/nodes/SoSeparator.h>
12 #include <Inventor/nodes/SoCube.h>
13 #include <Inventor/nodes/SoMaterial.h>
14 #include <Inventor/nodes/SoTranslation.h>
15 #include <Inventor/nodes/SoLineSet.h>
16 #include <Inventor/nodes/SoLightModel.h>
17 #include <Inventor/nodes/SoDrawStyle.h>
18 
19 #include "LArReadoutGeometry/FCALDetectorManager.h"
20 #include "LArReadoutGeometry/FCALModule.h"
21 
22 #include "LArReadoutGeometry/HECDetectorManager.h"
23 #include "LArReadoutGeometry/HECDetectorRegion.h"
24 
25 #include "LArReadoutGeometry/EMECDetectorManager.h"
26 #include "LArReadoutGeometry/EMECDetectorRegion.h"
27 
28 #include "LArReadoutGeometry/EMBDetectorManager.h"
29 #include "LArReadoutGeometry/EMBDetectorRegion.h"
30 
31 #include "VP1Base/VP1ExtraSepLayerHelper.h"
32 #include "VP1Base/VP1Serialise.h"
33 #include "VP1Base/VP1Deserialise.h"
34 #include "VP1Utils/VP1DetInfo.h"
35 #include "VP1Utils/VP1JobConfigInfo.h"
36 
37 #define MAX_OBJECTS_PER_TECHNOLOGY 3000
38 
39 class VP1CaloLegoSystem::Clockwork
40 {
41 public:
42  // Switches:
43  // 1. EMB0-3
44  // 2. EMEC0-3
45  // 3. HEC0-3
46  QMap<QString,SoSwitch*> switchMap;
47 
48  // Two maps for controller check boxes
49  QMap<QCheckBox*,QString> checkBoxNamesMap;
50  QMap<QString,QCheckBox*> checkBoxMap;
51 
52  SoSwitch *fcalSwitch[3]{}; // FCAL
53  SoSwitch *hecSwitch[4]{}; // HEC
54  SoSwitch *emecSwitch[4]{}; // EMEC
55  SoSwitch *embSwitch[4]{}; // EMB
56 
57 
58  std::map < SoNode *, const FCALTile *> TileMap;
59  std::map < SoNode *, HECCellConstLink> HECMap;
60  std::map < SoNode *, EMECCellConstLink> EMECMap;
61  std::map < SoNode *, EMBCellConstLink> EMBMap;
62 
63  SoSeparator * dummyCubeSep = nullptr;
64  SoSeparator * root = nullptr;
65 
66 };
67 
68 VP1CaloLegoSystem::VP1CaloLegoSystem()
69  :IVP13DSystemSimple("CaloLego","Display the readout in an eta-phi view","boudreau@pitt.edu"),
70  m_clockwork(new Clockwork())
71 {
72  m_clockwork->dummyCubeSep = 0;
73  m_clockwork->root = 0;
74 }
75 
76 VP1CaloLegoSystem::~VP1CaloLegoSystem()
77 {
78  delete m_clockwork;
79  m_clockwork = 0;
80 }
81 
82 QWidget* VP1CaloLegoSystem::buildController()
83 {
84  QWidget* controller = new QWidget(0);
85  Ui::frmCaloLegoController ui;
86  ui.setupUi(controller);
87 
88  VP1JobConfigInfo::ensureInit(this);
89  if (!VP1JobConfigInfo::hasLArGeometry()||!VP1JobConfigInfo::hasTileGeometry()) {
90  controller->setEnabled(false);
91  }
92 
93  // Populate Check Box Names Map
94  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMB0, "EMB0");
95  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMB1, "EMB1");
96  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMB2, "EMB2");
97  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMB3, "EMB3");
98  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMEC0,"EMEC0");
99  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMEC1,"EMEC1");
100  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMEC2,"EMEC2");
101  m_clockwork->checkBoxNamesMap.insert(ui.chbxEMEC3,"EMEC3");
102  m_clockwork->checkBoxNamesMap.insert(ui.chbxHEC0, "HEC0");
103  m_clockwork->checkBoxNamesMap.insert(ui.chbxHEC1, "HEC1");
104  m_clockwork->checkBoxNamesMap.insert(ui.chbxHEC2, "HEC2");
105  m_clockwork->checkBoxNamesMap.insert(ui.chbxHEC3, "HEC3");
106 
107  // Populate Check Box Map and connect slots
108  for(QCheckBox* cb : m_clockwork->checkBoxNamesMap.keys())
109  {
110  connect(cb,SIGNAL(toggled(bool)),this,SLOT(checkboxChanged()));
111  m_clockwork->checkBoxMap.insert(m_clockwork->checkBoxNamesMap[cb],cb);
112  }
113 
114  return controller;
115 }
116 
117 void VP1CaloLegoSystem::systemcreate(StoreGateSvc* )
118 {
119 }
120 
121 void VP1CaloLegoSystem::buildPermanentSceneGraph(StoreGateSvc*, SoSeparator *root) {
122 
123  VP1JobConfigInfo::ensureInit(this);
124  if (!VP1JobConfigInfo::hasLArGeometry()||!VP1JobConfigInfo::hasTileGeometry())
125  return;
126 
127  m_clockwork->root = root;
128 
129  for (int i=0;i<3;i++) {
130  m_clockwork->fcalSwitch[i] = new SoSwitch();
131  root->addChild(m_clockwork->fcalSwitch[i]);
132  }
133 
134  //We add a fully transparent dummy cube in order to get proper
135  //initial view (after first event we remove it again):
136  SoSeparator * dummyCubeSep = new SoSeparator;
137  dummyCubeSep->ref();
138  SoMaterial * dummyMat = new SoMaterial;
139  dummyMat->transparency = 1.0f;
140  SoTranslation * dummyTransl = new SoTranslation;
141  dummyTransl->translation.setValue(SbVec3f(0,3.15,0));
142  SoCube * dummyCube = new SoCube;
143  dummyCube->width = 6.7;
144  dummyCube->height = 6.3;
145  dummyCube->depth = 0.1;
146  dummyCubeSep->addChild(dummyMat);
147  dummyCubeSep->addChild(dummyTransl);
148  dummyCubeSep->addChild(dummyCube);
149  root->addChild(dummyCubeSep);
150 
151  for (int i=0;i<4;i++) {
152  m_clockwork->embSwitch[i] = new SoSwitch();
153  root->addChild(m_clockwork->embSwitch[i]);
154 
155  m_clockwork->emecSwitch[i] = new SoSwitch();
156  root->addChild(m_clockwork->emecSwitch[i]);
157 
158  m_clockwork->hecSwitch[i] = new SoSwitch();
159  root->addChild(m_clockwork->hecSwitch[i]);
160  }
161  m_clockwork->switchMap["EMB0"] = m_clockwork->embSwitch[0];
162  m_clockwork->switchMap["EMB1"] = m_clockwork->embSwitch[1];
163  m_clockwork->switchMap["EMB2"] = m_clockwork->embSwitch[2];
164  m_clockwork->switchMap["EMB3"] = m_clockwork->embSwitch[3];
165 
166  m_clockwork->switchMap["EMEC0"] = m_clockwork->emecSwitch[0];
167  m_clockwork->switchMap["EMEC1"] = m_clockwork->emecSwitch[1];
168  m_clockwork->switchMap["EMEC2"] = m_clockwork->emecSwitch[2];
169  m_clockwork->switchMap["EMEC3"] = m_clockwork->emecSwitch[3];
170 
171  m_clockwork->switchMap["HEC0"] = m_clockwork->hecSwitch[0];
172  m_clockwork->switchMap["HEC1"] = m_clockwork->hecSwitch[1];
173  m_clockwork->switchMap["HEC2"] = m_clockwork->hecSwitch[2];
174  m_clockwork->switchMap["HEC3"] = m_clockwork->hecSwitch[3];
175 
176  createEtaPhi();
177 
178 }
179 
180 void VP1CaloLegoSystem::systemerase()
181 {
182  if (m_clockwork->dummyCubeSep) {
183  if (m_clockwork->root->findChild(m_clockwork->dummyCubeSep)>=0)
184  m_clockwork->root->removeChild(m_clockwork->dummyCubeSep);
185  m_clockwork->dummyCubeSep->unref();
186  m_clockwork->dummyCubeSep = 0;
187  }
188 
189 }
190 
191 void VP1CaloLegoSystem::systemuncreate()
192 {
193  if (!VP1JobConfigInfo::hasLArGeometry()||!VP1JobConfigInfo::hasTileGeometry())
194  return;
195 
196  m_clockwork->root->enableNotify(false);
197  for (int i=0;i<4;i++) {
198  if (i<3) {
199  m_clockwork->fcalSwitch[i]->enableNotify(false);
200  m_clockwork->fcalSwitch[i]->removeAllChildren();
201  }
202  m_clockwork->embSwitch[i]->enableNotify(false);
203  m_clockwork->emecSwitch[i]->enableNotify(false);
204  m_clockwork->hecSwitch[i]->enableNotify(false);
205  m_clockwork->embSwitch[i]->removeAllChildren();
206  m_clockwork->emecSwitch[i]->removeAllChildren();
207  m_clockwork->hecSwitch[i]->removeAllChildren();
208  }
209 
210  m_clockwork->TileMap.clear();
211  m_clockwork->HECMap.clear();
212  m_clockwork->EMECMap.clear();
213  m_clockwork->EMBMap.clear();
214  m_clockwork->root->removeAllChildren();
215 }
216 
217 void VP1CaloLegoSystem::createEtaPhi() {
218 
219  // Styles & cet:
220  SoDrawStyle *drawStyle = new SoDrawStyle();
221  drawStyle->lineWidth=1;
222  SoLightModel *lm = new SoLightModel();
223  lm->model=SoLightModel::BASE_COLOR;
224 
225  SoMaterial *blue= new SoMaterial();
226  blue->diffuseColor.setValue(0,0,1);
227 
228  SoMaterial *green= new SoMaterial();
229  green->diffuseColor.setValue(0 , 1, 0);
230 
231  SoMaterial *yellow= new SoMaterial();
232  yellow->diffuseColor.setValue(0, 1.00, 1.00);
233 
234  SoMaterial *magenta = new SoMaterial();
235  magenta->diffuseColor.setValue(1.00,0.00, 1.00);
236 
237  for (int i=0;i<4;i++) {
238  if (i<3) {
239  m_clockwork->fcalSwitch[i]->addChild(drawStyle);
240  m_clockwork->fcalSwitch[i]->addChild(lm);
241  m_clockwork->fcalSwitch[i]->addChild(green);
242  }
243  m_clockwork->embSwitch[i]->addChild(drawStyle);
244  m_clockwork->emecSwitch[i]->addChild(drawStyle);
245  m_clockwork->hecSwitch[i]->addChild(drawStyle);
246  m_clockwork->embSwitch[i]->addChild(lm);
247  m_clockwork->emecSwitch[i]->addChild(lm);
248  m_clockwork->hecSwitch[i]->addChild(lm);
249  m_clockwork->embSwitch[i]->addChild(blue);
250  m_clockwork->emecSwitch[i]->addChild(magenta);
251  m_clockwork->hecSwitch[i]->addChild(yellow);
252  }
253 
254  VP1DetInfo::ensureInit(this);
255 
256  {
257  const FCALDetectorManager * manager=VP1DetInfo::fcalDetMgr();
258 
259  if (manager) {
260  FCALDetectorManager::ConstIterator e;
261  for (e=manager->beginFCAL();e!=manager->endFCAL(); ++e) {
262 
263  const FCALModule *fcalMod = *e;
264  SoSeparator *sep1 = new SoSeparator();
265  VP1ExtraSepLayerHelper *sep = new VP1ExtraSepLayerHelper(sep1);
266 
267  FCALModule::ConstIterator t;
268  for (t=fcalMod->beginTiles();t!=fcalMod->endTiles();++t) {
269  double x = t->getX();
270  double y = t->getY();
271  double dx = fcalMod->getFullWidthX(*t)/2.0;
272  double dy = fcalMod->getFullWidthY(*t)/2.0;
273 // double zf = fcalMod->getEndcapIndex()== 0 ? +fcalMod->getFullDepthZ(*t)/2.0 : -fcalMod->getFullDepthZ(*t)/2.0;
274 // double zc = 0;
275 // double zb = fcalMod->getEndcapIndex()== 0 ? -fcalMod->getFullDepthZ(*t)/2.0 : +fcalMod->getFullDepthZ(*t)/2.0;
276 
277  int cc=0;
278  SoVertexProperty *vtxProperty = new SoVertexProperty();
279  vtxProperty->vertex.set1Value(cc++, SbVec3f(x-dx+3,y-dy+3 ,0));
280  vtxProperty->vertex.set1Value(cc++, SbVec3f(x+dx-3,y-dy+3, 0));
281  vtxProperty->vertex.set1Value(cc++, SbVec3f(x+dx-3,y+dy-3 ,0));
282  vtxProperty->vertex.set1Value(cc++, SbVec3f(x-dx+3,y+dy-3 ,0));
283  vtxProperty->vertex.set1Value(cc++, SbVec3f(x-dx+3,y-dy+3 ,0));
284 
285  SoLineSet *ls = new SoLineSet();
286  ls->numVertices=5;
287  ls->vertexProperty=vtxProperty;
288  sep->addNode(ls);
289 
290  m_clockwork->TileMap[ls]=&(*t);
291  }
292  int sp = fcalMod->getModuleIndex()-1;
293  m_clockwork->fcalSwitch[sp]->addChild(sep1);
294 
295  }
296  }
297  }
298 
299  {
300  const HECDetectorManager * manager=VP1DetInfo::hecDetMgr();
301 
302  if (manager) {
303 
304  HECDetectorManager::DetectorRegionConstIterator e;
305  for (e=manager->beginDetectorRegion();e!=manager->endDetectorRegion(); ++e) {
306 
307  const HECDetectorRegion *region=*e;
308  SoSeparator *sep1 = new SoSeparator();
309  VP1ExtraSepLayerHelper *sep = new VP1ExtraSepLayerHelper(sep1);
310 
311  for (unsigned int iPhi=region->beginPhiIndex();iPhi<region->endPhiIndex();iPhi++) {
312  for (unsigned int iEta=region->beginEtaIndex();iEta<region->endEtaIndex();iEta++) {
313  HECCellConstLink cellPtr = region->getHECCell(iEta,iPhi);
314  if (cellPtr) {
315 
316  double phiMin = cellPtr->getPhiLocalLower();
317  double phiMax = cellPtr->getPhiLocalUpper();
318  double etaMin = cellPtr->getEtaMinNominal();
319  double etaMax = cellPtr->getEtaMaxNominal();
320 
321  if (region->getEndcapIndex()==0) {
322  phiMin = M_PI-phiMin;
323  phiMax = M_PI-phiMax;
324  etaMin = -etaMin;
325  etaMax = -etaMax;
326  }
327 
328  int cc=0;
329  SoVertexProperty *vtxProperty = new SoVertexProperty();
330  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMin ,0));
331  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMax ,0));
332  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMax,phiMax ,0));
333  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMax,phiMin ,0));
334  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMin ,0));
335 
336  SoLineSet *ls = new SoLineSet();
337  ls->numVertices=5;
338  ls->vertexProperty=vtxProperty;
339  sep->addNode(ls);
340 
341  m_clockwork->HECMap[ls]=cellPtr;
342  }
343  }
344  }
345  m_clockwork->hecSwitch[region->getSamplingIndex()]->addChild(sep1);
346  }
347  }
348  }
349 
350 
351  {
352  const EMECDetectorManager * manager=VP1DetInfo::emecDetMgr();
353 
354  if (manager) {
355 
356  EMECDetectorManager::DetectorRegionConstIterator e;
357  for (e=manager->beginDetectorRegion();e!=manager->endDetectorRegion(); ++e) {
358  const EMECDetectorRegion *region = *e;
359 
360  // Then grid:
361 
362 
363  SoSeparator *sep1 = new SoSeparator();
364  VP1ExtraSepLayerHelper *sep = new VP1ExtraSepLayerHelper(sep1);
365 
366 
367  for (unsigned int iPhi=region->beginPhiIndex();iPhi<region->endPhiIndex();iPhi++) {
368  for (unsigned int iEta=region->beginEtaIndex();iEta<region->endEtaIndex();iEta++) {
369 
370 
371 
372  EMECCellConstLink cellPtr = ((EMECDetectorRegion *) region)->getEMECCell(iEta,iPhi);
373  double phiMin = cellPtr->getPhiLocalLower();
374  double phiMax = cellPtr->getPhiLocalUpper();
375  double etaMin = cellPtr->getEtaMin();
376  double etaMax = cellPtr->getEtaMax();
377 
378  if (region->getEndcapIndex()==0) {
379  phiMin = M_PI-phiMin;
380  phiMax = M_PI-phiMax;
381  etaMin = -etaMin;
382  etaMax = -etaMax;
383  }
384 
385  int cc=0;
386  SoVertexProperty *vtxProperty = new SoVertexProperty();
387  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMin ,0));
388  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMax ,0));
389  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMax,phiMax ,0));
390  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMax,phiMin ,0));
391  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMin ,0));
392 
393  SoLineSet *ls = new SoLineSet();
394  ls->numVertices=5;
395  ls->vertexProperty=vtxProperty;
396  sep->addNode(ls);
397  m_clockwork->EMECMap[ls]=cellPtr;
398  }
399  }
400  m_clockwork->emecSwitch[region->getSamplingIndex()]->addChild(sep1);
401  }
402  }
403  }
404  {
405  const EMBDetectorManager * manager=VP1DetInfo::embDetMgr();
406 
407  if (manager) {
408 
409  EMBDetectorManager::DetectorRegionConstIterator e;
410  for (e=manager->beginDetectorRegion();e!=manager->endDetectorRegion(); ++e) {
411  const EMBDetectorRegion *region = *e;
412  SoSeparator *sep1 = new SoSeparator();
413  VP1ExtraSepLayerHelper *sep = new VP1ExtraSepLayerHelper(sep1);
414 
415  for (unsigned int iPhi=region->beginPhiIndex();iPhi<region->endPhiIndex();iPhi++) {
416  for (unsigned int iEta=region->beginEtaIndex();iEta<region->endEtaIndex();iEta++) {
417 
418 
419  EMBCellConstLink cellPtr = ((EMBDetectorRegion *) region)->getEMBCell(iEta,iPhi);
420  double phiMin = cellPtr->getPhiLocalLower();
421  double phiMax = cellPtr->getPhiLocalUpper();
422  double etaMin = cellPtr->getEtaMin();
423  double etaMax = cellPtr->getEtaMax();
424 
425  if (region->getEndcapIndex()==0) {
426  phiMin = M_PI-phiMin;
427  phiMax = M_PI-phiMax;
428  etaMin = -etaMin;
429  etaMax = -etaMax;
430  }
431 
432  int cc=0;
433  SoVertexProperty *vtxProperty = new SoVertexProperty();
434  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMin ,0));
435  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMax ,0));
436  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMax,phiMax ,0));
437  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMax,phiMin ,0));
438  vtxProperty->vertex.set1Value(cc++, SbVec3f(etaMin,phiMin ,0));
439 
440  SoLineSet *ls = new SoLineSet();
441  ls->numVertices=5;
442  ls->vertexProperty=vtxProperty;
443  sep->addNode(ls);
444  m_clockwork->EMBMap[ls]=cellPtr;
445  }
446  }
447  m_clockwork->embSwitch[region->getSamplingIndex()]->addChild(sep1);
448  }
449  }
450  }
451 }
452 
453 void VP1CaloLegoSystem::buildEventSceneGraph(StoreGateSvc* , SoSeparator *)
454 {
455 }
456 
457 void VP1CaloLegoSystem::checkboxChanged()
458 {
459  if (!VP1JobConfigInfo::hasLArGeometry()||!VP1JobConfigInfo::hasTileGeometry())
460  return;
461 
462  // Get ChB pointer
463  QCheckBox* cb = dynamic_cast<QCheckBox*>(sender());
464  if(cb && m_clockwork->checkBoxNamesMap.contains(cb))
465  {
466  // Get technology name
467  QString swName = m_clockwork->checkBoxNamesMap[cb];
468 
469  if(m_clockwork->switchMap.contains(swName))
470  {
471  // Get switch
472  SoSwitch* sw = m_clockwork->switchMap[swName];
473  if(cb->isChecked())
474  {
475  sw->whichChild = SO_SWITCH_ALL;
476  }
477  else
478  sw->whichChild = SO_SWITCH_NONE;
479  }
480  }
481 }
482 
483 
484 void VP1CaloLegoSystem::userPickedNode(SoNode* /*pickedNode*/, SoPath */*pickedPath*/)
485 {
486 }
487 
488 QByteArray VP1CaloLegoSystem::saveState()
489 {
490  ensureBuildController();
491  VP1Serialise serialise(1/*version*/,this);
492  serialise.save(IVP13DSystemSimple::saveState());
493 
494  //Checkboxes (by name for greater stability in case we change content of map):
495  QMapIterator<QString,QCheckBox*> it(m_clockwork->checkBoxMap);
496  QMap<QString,bool> checkboxstate;
497  while (it.hasNext()) {
498  it.next();
499  checkboxstate.insert(it.key(),it.value()->isChecked());
500  serialise.widgetHandled(it.value());
501  }
502  serialise.save(checkboxstate);
503 
504  serialise.warnUnsaved(controllerWidget());
505  return serialise.result();
506 }
507 
508 void VP1CaloLegoSystem::restoreFromState(QByteArray ba)
509 {
510  VP1Deserialise state(ba,this);
511  if (state.version()==0) {
512  message("Warning: State data in .vp1 file has obsolete format - ignoring!");
513  return;
514  }
515  if (state.version()!=1) {
516  message("Warning: State data in .vp1 file is in wrong format - ignoring!");
517  return;
518  }
519  ensureBuildController();
520  IVP13DSystemSimple::restoreFromState(state.restoreByteArray());
521 
522  //Checkboxes (by name for greater stability in case we change content of map):
523  QMap<QString,bool> checkboxstate(state.restore<QMap<QString,bool> >());
524  QMapIterator<QString,QCheckBox*> it(m_clockwork->checkBoxMap);
525  while (it.hasNext()) {
526  it.next();
527  state.widgetHandled(it.value());
528  if (checkboxstate.contains(it.key())) {
529  bool checked = checkboxstate.value(it.key());
530  if (it.value()->isChecked()!=checked)
531  it.value()->setChecked(checked);
532  }
533  }
534 
535  state.warnUnrestored(controllerWidget());
536 }
VP1Serialise.h
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
VP1CaloLegoSystem::Clockwork::hecSwitch
SoSwitch * hecSwitch[4]
Definition: VP1CaloLegoSystem.cxx:53
EMBDetectorRegion::beginEtaIndex
unsigned int beginEtaIndex() const
Returns the first eta index in the region.
Definition: EMBDetectorRegion.h:147
VP1CaloLegoSystem::Clockwork::fcalSwitch
SoSwitch * fcalSwitch[3]
Definition: VP1CaloLegoSystem.cxx:52
VP1CaloLegoSystem::Clockwork::embSwitch
SoSwitch * embSwitch[4]
Definition: VP1CaloLegoSystem.cxx:55
VP1CaloLegoSystem::checkboxChanged
void checkboxChanged()
Definition: VP1CaloLegoSystem.cxx:457
VP1CaloLegoSystem::buildPermanentSceneGraph
void buildPermanentSceneGraph(StoreGateSvc *detstore, SoSeparator *root)
Definition: VP1CaloLegoSystem.cxx:121
VP1CaloLegoSystem::restoreFromState
void restoreFromState(QByteArray ba)
Definition: VP1CaloLegoSystem.cxx:508
FCALDetectorManager
A manager class providing access to readout geometry information for the forward calorimeter.
Definition: FCALDetectorManager.h:29
VP1Deserialise.h
VP1Serialise
Definition: VP1Serialise.h:45
EMECDetectorRegion::getEndcapIndex
EMECDetectorRegion::DetectorSide getEndcapIndex() const
The endcap index.
Definition: EMECDetectorRegion.h:214
IVP13DSystemSimple
Definition: IVP13DSystemSimple.h:24
VP1CaloLegoSystem::systemerase
void systemerase()
Definition: VP1CaloLegoSystem.cxx:180
FCALDetectorManager::ConstIterator
std::vector< const FCALModule * >::const_iterator ConstIterator
Definition: FCALDetectorManager.h:34
RoiUtil::serialise
void serialise(const std::vector< const IRoiDescriptor * > &rois, roiserial_type &s)
serialise an entire vector of IRoiDescriptors
Definition: RoiSerialise.cxx:45
EMBDetectorRegion.h
EMECDetectorManager
A manager class providing access to readout geometry information for the electromagnetic endcap calor...
Definition: EMECDetectorManager.h:31
VP1JobConfigInfo::ensureInit
static void ensureInit(IVP1System *)
Definition: VP1JobConfigInfo.h:30
HECDetectorRegion::beginPhiIndex
unsigned int beginPhiIndex() const
returns the first phi index in the region.
Definition: HECDetectorRegion.h:179
VP1ExtraSepLayerHelper.h
VP1CaloLegoSystem::Clockwork::checkBoxMap
QMap< QString, QCheckBox * > checkBoxMap
Definition: VP1CaloLegoSystem.cxx:50
VP1JobConfigInfo::hasTileGeometry
static bool hasTileGeometry()
Definition: VP1JobConfigInfo.cxx:133
VP1CaloLegoSystem::systemcreate
void systemcreate(StoreGateSvc *detstore)
Definition: VP1CaloLegoSystem.cxx:117
EMECDetectorManager.h
FCALDetectorManager.h
VP1JobConfigInfo::hasLArGeometry
static bool hasLArGeometry()
Definition: VP1JobConfigInfo.cxx:132
FCALModule::endTiles
FCALModule::ConstIterator endTiles() const
Iteration over FCAL Tiles.
Definition: FCALModule.cxx:51
fillPileUpNoiseLumi.connect
string connect
Definition: fillPileUpNoiseLumi.py:70
CSV_InDetExporter.new
new
Definition: CSV_InDetExporter.py:145
skel.it
it
Definition: skel.GENtoEVGEN.py:396
VP1CaloLegoSystem::m_clockwork
Clockwork * m_clockwork
Definition: VP1CaloLegoSystem.h:43
VP1CaloLegoSystem::buildEventSceneGraph
void buildEventSceneGraph(StoreGateSvc *sg, SoSeparator *root)
Definition: VP1CaloLegoSystem.cxx:453
VP1CaloLegoSystem::buildController
QWidget * buildController()
Definition: VP1CaloLegoSystem.cxx:82
EMBDetectorRegion::getSamplingIndex
unsigned int getSamplingIndex() const
Returns the Sampling Layer Index.
Definition: EMBDetectorRegion.h:119
VP1CaloLegoSystem.h
EMECDetectorRegion::beginPhiIndex
unsigned int beginPhiIndex() const
returns the first phi index in the region.
Definition: EMECDetectorRegion.h:185
M_PI
#define M_PI
Definition: ActiveFraction.h:11
xAOD::etaMax
etaMax
Definition: HIEventShape_v2.cxx:46
EMECDetectorRegion::beginEtaIndex
unsigned int beginEtaIndex() const
returns the first eta index in the region.
Definition: EMECDetectorRegion.h:199
VP1DetInfo::embDetMgr
static const EMBDetectorManager * embDetMgr()
Definition: VP1DetInfo.cxx:150
EMECDetectorRegion
Definition: EMECDetectorRegion.h:30
HECDetectorRegion::beginEtaIndex
unsigned int beginEtaIndex() const
returns the first eta index in the region.
Definition: HECDetectorRegion.h:193
sendEI_SPB.root
root
Definition: sendEI_SPB.py:34
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
HECDetectorRegion.h
x
#define x
VP1DetInfo::hecDetMgr
static const HECDetectorManager * hecDetMgr()
Definition: VP1DetInfo.cxx:151
VP1CaloLegoSystem::Clockwork::switchMap
QMap< QString, SoSwitch * > switchMap
Definition: VP1CaloLegoSystem.cxx:46
VP1CaloLegoSystem::VP1CaloLegoSystem
VP1CaloLegoSystem()
Definition: VP1CaloLegoSystem.cxx:68
IVP1System::state
State state() const
Definition: IVP1System.cxx:129
EMBDetectorRegion::beginPhiIndex
unsigned int beginPhiIndex() const
Returns the first phi index in the region.
Definition: EMBDetectorRegion.h:133
IVP1System::saveState
virtual QByteArray saveState()
Definition: IVP1System.cxx:294
VP1DetInfo::fcalDetMgr
static const FCALDetectorManager * fcalDetMgr()
Definition: VP1DetInfo.cxx:154
VP1CaloLegoSystem::Clockwork::HECMap
std::map< SoNode *, HECCellConstLink > HECMap
Definition: VP1CaloLegoSystem.cxx:59
VP1DetInfo.h
VP1CaloLegoSystem::userPickedNode
void userPickedNode(SoNode *pickedNode, SoPath *pickedPath)
Definition: VP1CaloLegoSystem.cxx:484
VP1CaloLegoSystem::Clockwork::EMBMap
std::map< SoNode *, EMBCellConstLink > EMBMap
Definition: VP1CaloLegoSystem.cxx:61
EMBDetectorManager
A manager class providing access to readout geometry information for the electromagnetic barrel calor...
Definition: EMBDetectorManager.h:32
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:125
VP1CaloLegoSystem::Clockwork::root
SoSeparator * root
Definition: VP1CaloLegoSystem.cxx:64
VP1DetInfo::emecDetMgr
static const EMECDetectorManager * emecDetMgr()
Definition: VP1DetInfo.cxx:152
VP1DetInfo::ensureInit
static void ensureInit(IVP1System *)
Definition: VP1DetInfo.h:49
VP1ExtraSepLayerHelper
Definition: VP1ExtraSepLayerHelper.h:22
yellow
@ yellow
Definition: BinsDiffFromStripMedian.h:18
lumiFormat.i
int i
Definition: lumiFormat.py:85
FCALModule::ConstIterator
std::vector< FCALTile >::const_iterator ConstIterator
Definition: FCALModule.h:36
HECDetectorRegion
Description of a region of homogenous granularity in the hadronic endcap calorimeter.
Definition: HECDetectorRegion.h:31
VP1CaloLegoSystem::Clockwork
Definition: VP1CaloLegoSystem.cxx:40
VP1CaloLegoSystem::createEtaPhi
void createEtaPhi()
Definition: VP1CaloLegoSystem.cxx:217
VP1CaloLegoSystem::Clockwork::TileMap
std::map< SoNode *, const FCALTile * > TileMap
Definition: VP1CaloLegoSystem.cxx:58
FCALModule::getFullWidthX
double getFullWidthX(const FCALTile &tile) const
Gets Tile Full Width in X.
Definition: FCALModule.cxx:79
VP1CaloLegoSystem::Clockwork::checkBoxNamesMap
QMap< QCheckBox *, QString > checkBoxNamesMap
Definition: VP1CaloLegoSystem.cxx:49
VP1CaloLegoSystem::Clockwork::emecSwitch
SoSwitch * emecSwitch[4]
Definition: VP1CaloLegoSystem.cxx:54
IVP13DSystemSimple::ensureBuildController
void ensureBuildController()
Definition: IVP13DSystemSimple.cxx:90
VP1Deserialise
Definition: VP1Deserialise.h:44
HECDetectorManager
A manager class providing access to readout geometry information for the hadronic endcap calorimeter.
Definition: HECDetectorManager.h:28
VP1CaloLegoSystem::systemuncreate
void systemuncreate()
Definition: VP1CaloLegoSystem.cxx:191
HECDetectorRegion::getEndcapIndex
HECDetectorRegion::DetectorSide getEndcapIndex() const
The endcap index.
Definition: HECDetectorRegion.h:209
FCALModule::getModuleIndex
FCALModule::Module getModuleIndex() const
Returns the Module (1,2, or 3)
Definition: FCALModule.cxx:74
grepfile.sep
sep
Definition: grepfile.py:38
EMECDetectorRegion::getSamplingIndex
unsigned int getSamplingIndex() const
Returns the Sampling Layer Index.
Definition: EMECDetectorRegion.h:164
EMBDetectorRegion::getEndcapIndex
EMBDetectorRegion::DetectorSide getEndcapIndex() const
The endcap index.
Definition: EMBDetectorRegion.h:163
FCALModule
Definition: FCALModule.h:33
green
@ green
Definition: BinsDiffFromStripMedian.h:18
Trk::iPhi
@ iPhi
Definition: ParamDefs.h:47
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
VP1CaloLegoSystem::~VP1CaloLegoSystem
~VP1CaloLegoSystem()
Definition: VP1CaloLegoSystem.cxx:76
LArCellBinning.etaMin
etaMin
Definition: LArCellBinning.py:84
y
#define y
FCALModule::getFullWidthY
double getFullWidthY(const FCALTile &tile) const
Gets Tile Full Width in Y.
Definition: FCALModule.cxx:84
VP1CaloLegoSystem::Clockwork::dummyCubeSep
SoSeparator * dummyCubeSep
Definition: VP1CaloLegoSystem.cxx:63
EMBDetectorManager::DetectorRegionConstIterator
std::vector< const EMBDetectorRegion * >::const_iterator DetectorRegionConstIterator
Definition: EMBDetectorManager.h:35
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
HECDetectorRegion::getHECCell
HECCellConstLink getHECCell(unsigned int ieta, unsigned int iphi) const
Retrieve a cell with eta index and phi index.
Definition: HECDetectorRegion.cxx:26
VP1CaloLegoSystem::Clockwork::EMECMap
std::map< SoNode *, EMECCellConstLink > EMECMap
Definition: VP1CaloLegoSystem.cxx:60
HECDetectorManager::DetectorRegionConstIterator
std::vector< const HECDetectorRegion * >::const_iterator DetectorRegionConstIterator
Definition: HECDetectorManager.h:33
VP1JobConfigInfo.h
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
xAOD::iEta
setScale setgFexType iEta
Definition: gFexJetRoI_v1.cxx:74
getReferenceRun.ls
def ls(fpath)
Definition: getReferenceRun.py:29
EMBDetectorRegion
Definition: EMBDetectorRegion.h:28
EMECDetectorRegion.h
FCALModule::beginTiles
FCALModule::ConstIterator beginTiles() const
Iteration over FCAL Tiles.
Definition: FCALModule.cxx:46
EMBDetectorManager.h
IVP1System::message
void message(const QString &) const
Definition: IVP1System.cxx:336
FCALModule.h
HECDetectorRegion::getSamplingIndex
unsigned int getSamplingIndex() const
Returns the Sampling Layer Index (0-3)
Definition: HECDetectorRegion.h:165
TrackingGeometryValidation.blue
blue
Definition: TrackingGeometryValidation.py:33
EMECDetectorManager::DetectorRegionConstIterator
std::vector< const EMECDetectorRegion * >::const_iterator DetectorRegionConstIterator
Definition: EMECDetectorManager.h:34
HECDetectorManager.h
python.handimod.cc
int cc
Definition: handimod.py:523
VP1CaloLegoSystem::saveState
QByteArray saveState()
Definition: VP1CaloLegoSystem.cxx:488
IVP1System::controllerWidget
QWidget * controllerWidget()
Definition: IVP1System.cxx:202
IVP1System::restoreFromState
virtual void restoreFromState(QByteArray)
Definition: IVP1System.cxx:302
Generated on Thu Nov 7 2024 21:31:36 for ATLAS Offline Software by   doxygen 1.8.18