ATLAS Offline Software
Public Member Functions | Public Attributes | List of all members
VP1CaloCellSystem::Clockwork Class Reference
Collaboration diagram for VP1CaloCellSystem::Clockwork:

Public Member Functions

 Clockwork ()
 
 ~Clockwork ()
 
 Clockwork (const Clockwork &)=delete
 
Clockwork & operator= (const Clockwork &)=delete
 
void BuildCellManagers ()
 
void FillManagers ()
 
std::string SearchTileRawchanKeys (const std::vector< std::string > &inputKeys)
 

Public Attributes

VP1CaloCellController * controller {nullptr}
 
bool noCalo {false}
 
bool noLArDigitsGlobal {false}
 
bool noLArDigitsEvent {false}
 
bool noTileDigitsGlobal {false}
 
bool noTileDigitsEvent {false}
 
bool modeSimple {true}
 
const TileDetDescrManager * tile_dd_man {nullptr}
 
const CaloCell_ID * calo_id {nullptr}
 
const TileID * tile_id {nullptr}
 
const TileHWID * tile_hw_id {nullptr}
 
const TileInfo * tile_info {nullptr}
 
const TileCablingService * tile_cabling {nullptr}
 
const LArOnlineID * lar_onlineID {nullptr}
 
const ICaloBadChanTool * calo_badchannel {nullptr}
 
const CaloCellContainer * calocells {nullptr}
 
const LArDigitContainer * lar_digits {nullptr}
 
const TileDigitsContainer * tile_digits {nullptr}
 
const TileRawChannelContainer * tile_rawchannel {nullptr}
 
VP1CCManagerContainer cell_managers
 
VP1MbtsHelper * mbtsHelper
 
VP1CC_SoNode2CCMap node2ccMap
 
VP1CC_SeparatorMap sepHelperMap
 
VP1CC_SeparatorTypesSet sepTypes
 

Detailed Description

Definition at line 61 of file VP1CaloCellSystem.cxx.

Constructor & Destructor Documentation

◆ Clockwork() [1/2]

VP1CaloCellSystem::Clockwork::Clockwork ( )

Definition at line 161 of file VP1CaloCellSystem.cxx.

162 : mbtsHelper(new VP1MbtsHelper(false))
163 {
164  // Initialize set of available separator types besides MBTS
165  sepTypes.insert(VP1CC_SepLArEMBPos);
166  sepTypes.insert(VP1CC_SepLArEMECPos);
167  sepTypes.insert(VP1CC_SepLArHECPos);
168  sepTypes.insert(VP1CC_SepLArFCALPos);
169  sepTypes.insert(VP1CC_SepLArEMBNeg);
170  sepTypes.insert(VP1CC_SepLArEMECNeg);
171  sepTypes.insert(VP1CC_SepLArHECNeg);
172  sepTypes.insert(VP1CC_SepLArFCALNeg);
173  sepTypes.insert(VP1CC_SepTilePositiveUp);
174  sepTypes.insert(VP1CC_SepTilePositiveDown);
175  sepTypes.insert(VP1CC_SepTilePositiveNeg);
176  sepTypes.insert(VP1CC_SepTileNegativeUp);
177  sepTypes.insert(VP1CC_SepTileNegativeDown);
178  sepTypes.insert(VP1CC_SepTileNegativePos);
179 }

◆ ~Clockwork()

VP1CaloCellSystem::Clockwork::~Clockwork ( )

Definition at line 181 of file VP1CaloCellSystem.cxx.

182 {
183  if(mbtsHelper) delete mbtsHelper;
184 }

◆ Clockwork() [2/2]

VP1CaloCellSystem::Clockwork::Clockwork ( const Clockwork &  )
delete

Member Function Documentation

◆ BuildCellManagers()

void VP1CaloCellSystem::Clockwork::BuildCellManagers ( )

Definition at line 186 of file VP1CaloCellSystem.cxx.

187 {
188  // Populate cell_managers map
189  cell_managers[VP1CC_SelTypeEMB0] = new VP1CaloCellManager(VP1CC_SelTypeEMB0,&node2ccMap,
190  controller->energyModeEt(),controller->scale(),
191  controller->showVolumeOutLines(),controller->globalCuts());
192  cell_managers[VP1CC_SelTypeEMB1] = new VP1CaloCellManager(VP1CC_SelTypeEMB1,&node2ccMap,
193  controller->energyModeEt(),controller->scale(),
194  controller->showVolumeOutLines(),controller->globalCuts());
195  cell_managers[VP1CC_SelTypeEMB2] = new VP1CaloCellManager(VP1CC_SelTypeEMB2,&node2ccMap,
196  controller->energyModeEt(),controller->scale(),
197  controller->showVolumeOutLines(),controller->globalCuts());
198  cell_managers[VP1CC_SelTypeEMB3] = new VP1CaloCellManager(VP1CC_SelTypeEMB3,&node2ccMap,
199  controller->energyModeEt(),controller->scale(),
200  controller->showVolumeOutLines(),controller->globalCuts());
201  cell_managers[VP1CC_SelTypeEMEC0] = new VP1CaloCellManager(VP1CC_SelTypeEMEC0,&node2ccMap,
202  controller->energyModeEt(),controller->scale(),
203  controller->showVolumeOutLines(),controller->globalCuts());
204  cell_managers[VP1CC_SelTypeEMEC1] = new VP1CaloCellManager(VP1CC_SelTypeEMEC1,&node2ccMap,
205  controller->energyModeEt(),controller->scale(),
206  controller->showVolumeOutLines(),controller->globalCuts());
207  cell_managers[VP1CC_SelTypeEMEC2] = new VP1CaloCellManager(VP1CC_SelTypeEMEC2,&node2ccMap,
208  controller->energyModeEt(),controller->scale(),
209  controller->showVolumeOutLines(),controller->globalCuts());
210  cell_managers[VP1CC_SelTypeEMEC3] = new VP1CaloCellManager(VP1CC_SelTypeEMEC3,&node2ccMap,
211  controller->energyModeEt(),controller->scale(),
212  controller->showVolumeOutLines(),controller->globalCuts());
213  cell_managers[VP1CC_SelTypeHEC0] = new VP1CaloCellManager(VP1CC_SelTypeHEC0,&node2ccMap,
214  controller->energyModeEt(),controller->scale(),
215  controller->showVolumeOutLines(),controller->globalCuts());
216  cell_managers[VP1CC_SelTypeHEC1] = new VP1CaloCellManager(VP1CC_SelTypeHEC1,&node2ccMap,
217  controller->energyModeEt(),controller->scale(),
218  controller->showVolumeOutLines(),controller->globalCuts());
219  cell_managers[VP1CC_SelTypeHEC2] = new VP1CaloCellManager(VP1CC_SelTypeHEC2,&node2ccMap,
220  controller->energyModeEt(),controller->scale(),
221  controller->showVolumeOutLines(),controller->globalCuts());
222  cell_managers[VP1CC_SelTypeHEC3] = new VP1CaloCellManager(VP1CC_SelTypeHEC3,&node2ccMap,
223  controller->energyModeEt(),controller->scale(),
224  controller->showVolumeOutLines(),controller->globalCuts());
225  cell_managers[VP1CC_SelTypeFCAL1] = new VP1CaloCellManager(VP1CC_SelTypeFCAL1,&node2ccMap,
226  controller->energyModeEt(),controller->scale(),
227  controller->showVolumeOutLines(),controller->globalCuts());
228  cell_managers[VP1CC_SelTypeFCAL2] = new VP1CaloCellManager(VP1CC_SelTypeFCAL2,&node2ccMap,
229  controller->energyModeEt(),controller->scale(),
230  controller->showVolumeOutLines(),controller->globalCuts());
231  cell_managers[VP1CC_SelTypeFCAL3] = new VP1CaloCellManager(VP1CC_SelTypeFCAL3,&node2ccMap,
232  controller->energyModeEt(),controller->scale(),
233  controller->showVolumeOutLines(),controller->globalCuts());
234  cell_managers[VP1CC_SelTypeTileB] = new VP1CaloCellManager(VP1CC_SelTypeTileB,&node2ccMap,
235  controller->energyModeEt(),controller->scale(),
236  controller->showVolumeOutLines(),controller->globalCuts());
237  cell_managers[VP1CC_SelTypeTileEC] = new VP1CaloCellManager(VP1CC_SelTypeTileEC,&node2ccMap,
238  controller->energyModeEt(),controller->scale(),
239  controller->showVolumeOutLines(),controller->globalCuts());
240  cell_managers[VP1CC_SelTypeTileCrack] = new VP1CaloCellManager(VP1CC_SelTypeTileCrack,&node2ccMap,
241  controller->energyModeEt(),controller->scale(),
242  controller->showVolumeOutLines(),controller->globalCuts());
243 
244  // Connect controller signals to manager slots
245  for(VP1CCManagerContainer::iterator it=cell_managers.begin(); it!=cell_managers.end(); ++it) {
246  connect(controller,SIGNAL(selectionIntervalsChanged(VP1CCIntervalMap)),
247  it->second,SLOT(selectionUpdated(VP1CCIntervalMap)));
248  connect(controller,SIGNAL(scaleChanged(QPair<bool,double>)),
249  it->second,SLOT(scaleUpdated(QPair<bool,double>)));
250  connect(controller,SIGNAL(showVolumeOutLinesChanged(bool)),
251  it->second,SLOT(outlineUpdated(bool)));
252  connect(controller,SIGNAL(globalCutsChanged(VP1CC_GlobalCuts)),
253  it->second,SLOT(globalCutsUpdated(VP1CC_GlobalCuts)));
254  connect(controller->customTourEditor(),SIGNAL(clipVolumeRadiusChanged(double)),
255  it->second,SLOT(clipVolumeRadiusChanged(double)));
256  }
257 }

◆ FillManagers()

void VP1CaloCellSystem::Clockwork::FillManagers ( )

Definition at line 259 of file VP1CaloCellSystem.cxx.

260 {
261  // For events with no Calo Cells do nothing
262  if(!calocells) return;
263 
264  for(const CaloCell* cell : *calocells) {
265 
266  // for each cell:
267  // 1. determine its type
268  // 2. build VP1CaloCell of appropriate type
269  // 3. add it to the appropriate manager
270  try {
271  if(calo_id->is_em_barrel(cell->ID())) {
272  // ------- EMB ----------
273  VP1CC_LArEMB* embCC = new VP1CC_LArEMB(cell,&sepHelperMap);
274 
275  switch(calo_id->sampling(cell->ID())) {
276  case 0: {
277  cell_managers[VP1CC_SelTypeEMB0]->add(embCC);
278  break;
279  }
280  case 1: {
281  cell_managers[VP1CC_SelTypeEMB1]->add(embCC);
282  break;
283  }
284  case 2: {
285  cell_managers[VP1CC_SelTypeEMB2]->add(embCC);
286  break;
287  }
288  case 3: {
289  cell_managers[VP1CC_SelTypeEMB3]->add(embCC);
290  break;
291  }
292  default: { //unknown case, tidy up
293  delete embCC; embCC=nullptr;
294  break;
295  }
296  }
297  // ------- EMB ----------
298  }
299  else if(calo_id->is_em_endcap(cell->ID()) || calo_id->is_hec(cell->ID())) {
300  VP1CC_LArEMECHEC* emechecCC = new VP1CC_LArEMECHEC(cell,calo_id,&sepHelperMap);
301 
302  if(calo_id->is_em_endcap(cell->ID())) {
303  // ------- EMEC ----------
304  switch(calo_id->sampling(cell->ID())) {
305  case 0: {
306  cell_managers[VP1CC_SelTypeEMEC0]->add(emechecCC);
307  break;
308  }
309  case 1: {
310  cell_managers[VP1CC_SelTypeEMEC1]->add(emechecCC);
311  break;
312  }
313  case 2: {
314  cell_managers[VP1CC_SelTypeEMEC2]->add(emechecCC);
315  break;
316  }
317  case 3: {
318  cell_managers[VP1CC_SelTypeEMEC3]->add(emechecCC);
319  break;
320  }
321  default: { //unknown case, tidy up
322  delete emechecCC; emechecCC=nullptr;
323  break;
324  }
325  }
326  // ------- EMEC ----------
327  } else {
328  // ------- HEC ----------
329  switch(calo_id->sampling(cell->ID())) {
330  case 0: {
331  cell_managers[VP1CC_SelTypeHEC0]->add(emechecCC);
332  break;
333  }
334  case 1: {
335  cell_managers[VP1CC_SelTypeHEC1]->add(emechecCC);
336  break;
337  }
338  case 2: {
339  cell_managers[VP1CC_SelTypeHEC2]->add(emechecCC);
340  break;
341  }
342  case 3: {
343  cell_managers[VP1CC_SelTypeHEC3]->add(emechecCC);
344  break;
345  }
346  default: { //unknown case, tidy up
347  delete emechecCC; emechecCC=nullptr;
348  break;
349  }
350  }
351  // ------- EMEC ----------
352  }
353  }
354  else if(calo_id->is_fcal(cell->ID())) {
355  // ------- FCAL ----------
356  VP1CC_LArFCAL* fcalCC = new VP1CC_LArFCAL(cell,&sepHelperMap);
357 
358  switch(calo_id->sampling(cell->ID())) {
359  case 1: {
360  cell_managers[VP1CC_SelTypeFCAL1]->add(fcalCC);
361  break;
362  }
363  case 2: {
364  cell_managers[VP1CC_SelTypeFCAL2]->add(fcalCC);
365  break;
366  }
367  case 3: {
368  cell_managers[VP1CC_SelTypeFCAL3]->add(fcalCC);
369  break;
370  }
371  default: { //unknown case, tidy up
372  delete fcalCC; fcalCC=nullptr;
373  break;
374  }
375  }
376  // ------- FCAL ----------
377  }
378  else if(!calo_id->is_tile_gapscin(cell->ID())) {
379  // ------- Tile Barrel EC ----------
380  VP1CC_TileBarEc* tileCC = new VP1CC_TileBarEc(cell,tile_id,&sepHelperMap);
381 
382  if(calo_id->is_tile_barrel(cell->ID()))
383  cell_managers[VP1CC_SelTypeTileB]->add(tileCC);
384  else
385  cell_managers[VP1CC_SelTypeTileEC]->add(tileCC);
386  }
387  else if(calo_id->is_tile_gapscin(cell->ID())) {
388  // ------- Tile Crack ----------
389  VP1CC_TileCrack* tilecrackCC = new VP1CC_TileCrack(cell,tile_id,&sepHelperMap);
390 
391  cell_managers[VP1CC_SelTypeTileCrack]->add(tilecrackCC);
392  }
393  }
394  catch(std::runtime_error& err) {
395  // --- do nothing for now
396  std::cout << "RunTime exception caught! --> " << err.what() << std::endl;
397  }
398  } // iterate over cells
399 }

◆ operator=()

Clockwork& VP1CaloCellSystem::Clockwork::operator= ( const Clockwork &  )
delete

◆ SearchTileRawchanKeys()

std::string VP1CaloCellSystem::Clockwork::SearchTileRawchanKeys ( const std::vector< std::string > &  inputKeys)

Definition at line 401 of file VP1CaloCellSystem.cxx.

402 {
403  // Search order
404  std::vector<std::string> searchOrder;
405  searchOrder.push_back("TileRawChannelOpt2");
406  searchOrder.push_back("TileRawChannelOpt");
407  searchOrder.push_back("TileRawChannelFixed");
408  searchOrder.push_back("TileRawChannelFitCool");
409  searchOrder.push_back("TileRawChannelFit");
410  searchOrder.push_back("TileRawChannelCnt");
411  searchOrder.push_back("TileRawChannelFlt");
412 
413  for(size_t i=0; i<searchOrder.size(); ++i) {
414  std::string searchString = searchOrder[i];
415  for(size_t ii=0; ii<inputKeys.size(); ++ii)
416  if(inputKeys[ii]==searchString)
417  return searchString;
418  }
419  // No keys found from Search Order, return empty string
420  return std::string("");
421 }

Member Data Documentation

◆ calo_badchannel

const ICaloBadChanTool* VP1CaloCellSystem::Clockwork::calo_badchannel {nullptr}

Definition at line 120 of file VP1CaloCellSystem.cxx.

◆ calo_id

const CaloCell_ID* VP1CaloCellSystem::Clockwork::calo_id {nullptr}

Definition at line 108 of file VP1CaloCellSystem.cxx.

◆ calocells

const CaloCellContainer* VP1CaloCellSystem::Clockwork::calocells {nullptr}

Definition at line 127 of file VP1CaloCellSystem.cxx.

◆ cell_managers

VP1CCManagerContainer VP1CaloCellSystem::Clockwork::cell_managers

Definition at line 137 of file VP1CaloCellSystem.cxx.

◆ controller

VP1CaloCellController* VP1CaloCellSystem::Clockwork::controller {nullptr}

Definition at line 84 of file VP1CaloCellSystem.cxx.

◆ lar_digits

const LArDigitContainer* VP1CaloCellSystem::Clockwork::lar_digits {nullptr}

Definition at line 128 of file VP1CaloCellSystem.cxx.

◆ lar_onlineID

const LArOnlineID* VP1CaloCellSystem::Clockwork::lar_onlineID {nullptr}

Definition at line 119 of file VP1CaloCellSystem.cxx.

◆ mbtsHelper

VP1MbtsHelper* VP1CaloCellSystem::Clockwork::mbtsHelper

Definition at line 144 of file VP1CaloCellSystem.cxx.

◆ modeSimple

bool VP1CaloCellSystem::Clockwork::modeSimple {true}

Definition at line 97 of file VP1CaloCellSystem.cxx.

◆ noCalo

bool VP1CaloCellSystem::Clockwork::noCalo {false}

Definition at line 91 of file VP1CaloCellSystem.cxx.

◆ node2ccMap

VP1CC_SoNode2CCMap VP1CaloCellSystem::Clockwork::node2ccMap

Definition at line 152 of file VP1CaloCellSystem.cxx.

◆ noLArDigitsEvent

bool VP1CaloCellSystem::Clockwork::noLArDigitsEvent {false}

Definition at line 93 of file VP1CaloCellSystem.cxx.

◆ noLArDigitsGlobal

bool VP1CaloCellSystem::Clockwork::noLArDigitsGlobal {false}

Definition at line 92 of file VP1CaloCellSystem.cxx.

◆ noTileDigitsEvent

bool VP1CaloCellSystem::Clockwork::noTileDigitsEvent {false}

Definition at line 95 of file VP1CaloCellSystem.cxx.

◆ noTileDigitsGlobal

bool VP1CaloCellSystem::Clockwork::noTileDigitsGlobal {false}

Definition at line 94 of file VP1CaloCellSystem.cxx.

◆ sepHelperMap

VP1CC_SeparatorMap VP1CaloCellSystem::Clockwork::sepHelperMap

Definition at line 155 of file VP1CaloCellSystem.cxx.

◆ sepTypes

VP1CC_SeparatorTypesSet VP1CaloCellSystem::Clockwork::sepTypes

Definition at line 158 of file VP1CaloCellSystem.cxx.

◆ tile_cabling

const TileCablingService* VP1CaloCellSystem::Clockwork::tile_cabling {nullptr}

Definition at line 118 of file VP1CaloCellSystem.cxx.

◆ tile_dd_man

const TileDetDescrManager* VP1CaloCellSystem::Clockwork::tile_dd_man {nullptr}

Definition at line 105 of file VP1CaloCellSystem.cxx.

◆ tile_digits

const TileDigitsContainer* VP1CaloCellSystem::Clockwork::tile_digits {nullptr}

Definition at line 129 of file VP1CaloCellSystem.cxx.

◆ tile_hw_id

const TileHWID* VP1CaloCellSystem::Clockwork::tile_hw_id {nullptr}

Definition at line 110 of file VP1CaloCellSystem.cxx.

◆ tile_id

const TileID* VP1CaloCellSystem::Clockwork::tile_id {nullptr}

Definition at line 109 of file VP1CaloCellSystem.cxx.

◆ tile_info

const TileInfo* VP1CaloCellSystem::Clockwork::tile_info {nullptr}

Definition at line 117 of file VP1CaloCellSystem.cxx.

◆ tile_rawchannel

const TileRawChannelContainer* VP1CaloCellSystem::Clockwork::tile_rawchannel {nullptr}

Definition at line 130 of file VP1CaloCellSystem.cxx.

The documentation for this class was generated from the following file:
VP1CC_SelTypeTileB
@ VP1CC_SelTypeTileB
Definition: VP1CaloCells.h:83
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
VP1CC_SelTypeFCAL1
@ VP1CC_SelTypeFCAL1
Definition: VP1CaloCells.h:80
VP1CC_SepTileNegativeUp
@ VP1CC_SepTileNegativeUp
Definition: VP1CaloCells.h:102
VP1CC_LArEMB
Definition: VP1CaloCells.h:230
VP1CC_LArEMECHEC
Definition: VP1CaloCells.h:250
VP1CC_SepTilePositiveNeg
@ VP1CC_SepTilePositiveNeg
Definition: VP1CaloCells.h:101
VP1CC_SepTilePositiveUp
@ VP1CC_SepTilePositiveUp
Definition: VP1CaloCells.h:99
VP1CC_SepLArFCALPos
@ VP1CC_SepLArFCALPos
Definition: VP1CaloCells.h:94
CaloCell_Base_ID::is_em_endcap
bool is_em_endcap(const Identifier id) const
test if the id belongs to the EM Endcap
fillPileUpNoiseLumi.connect
string connect
Definition: fillPileUpNoiseLumi.py:70
skel.it
it
Definition: skel.GENtoEVGEN.py:396
VP1CaloCellSystem::Clockwork::controller
VP1CaloCellController * controller
Definition: VP1CaloCellSystem.cxx:84
VP1CC_TileBarEc
Definition: VP1CaloCells.h:314
VP1CC_SepLArEMBPos
@ VP1CC_SepLArEMBPos
Definition: VP1CaloCells.h:91
VP1CC_GlobalCuts
Definition: VP1CaloCells.h:47
VP1CC_SelTypeEMEC3
@ VP1CC_SelTypeEMEC3
Definition: VP1CaloCells.h:75
VP1CCIntervalMap
QMap< VP1CC_SelectionTypes, VP1CCIntervalPair > VP1CCIntervalMap
Definition: VP1CaloCells.h:119
VP1CC_SepTileNegativeDown
@ VP1CC_SepTileNegativeDown
Definition: VP1CaloCells.h:103
CaloCell_Base_ID::is_tile_barrel
bool is_tile_barrel(const Identifier id) const
test if the id belongs to the Tiles barrel
CaloCell_Base_ID::is_hec
bool is_hec(const Identifier id) const
test if the id belongs to the HEC
VP1CC_SelTypeEMB2
@ VP1CC_SelTypeEMB2
Definition: VP1CaloCells.h:70
VP1CC_SelTypeHEC1
@ VP1CC_SelTypeHEC1
Definition: VP1CaloCells.h:77
VP1Controller::customTourEditor
static VP1CustomTourEditor * customTourEditor()
Definition: VP1Controller.h:61
VP1CC_LArFCAL
Definition: VP1CaloCells.h:273
VP1CaloCellSystem::Clockwork::sepHelperMap
VP1CC_SeparatorMap sepHelperMap
Definition: VP1CaloCellSystem.cxx:155
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
VP1CaloCellSystem::Clockwork::sepTypes
VP1CC_SeparatorTypesSet sepTypes
Definition: VP1CaloCellSystem.cxx:158
lumiFormat.i
int i
Definition: lumiFormat.py:85
VP1CC_SepTileNegativePos
@ VP1CC_SepTileNegativePos
Definition: VP1CaloCells.h:104
CaloCell_Base_ID::is_fcal
bool is_fcal(const Identifier id) const
test if the id belongs to the FCAL - true also for MiniFCAL
CaloCell_Base_ID::sampling
int sampling(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
VP1CC_SelTypeHEC2
@ VP1CC_SelTypeHEC2
Definition: VP1CaloCells.h:78
VP1CaloCellSystem::Clockwork::cell_managers
VP1CCManagerContainer cell_managers
Definition: VP1CaloCellSystem.cxx:137
VP1CC_SelTypeHEC3
@ VP1CC_SelTypeHEC3
Definition: VP1CaloCells.h:79
VP1CaloCellSystem::Clockwork::tile_id
const TileID * tile_id
Definition: VP1CaloCellSystem.cxx:109
VP1CC_SepLArFCALNeg
@ VP1CC_SepLArFCALNeg
Definition: VP1CaloCells.h:98
VP1CaloCellSystem::Clockwork::calo_id
const CaloCell_ID * calo_id
Definition: VP1CaloCellSystem.cxx:108
VP1CaloCellManager
Definition: VP1CaloCellManager.h:39
CaloCell_Base_ID::is_em_barrel
bool is_em_barrel(const Identifier id) const
test if the id belongs to the EM barrel
VP1CC_SelTypeFCAL3
@ VP1CC_SelTypeFCAL3
Definition: VP1CaloCells.h:82
VP1CC_SelTypeHEC0
@ VP1CC_SelTypeHEC0
Definition: VP1CaloCells.h:76
VP1CC_SelTypeEMB1
@ VP1CC_SelTypeEMB1
Definition: VP1CaloCells.h:69
VP1CC_SelTypeFCAL2
@ VP1CC_SelTypeFCAL2
Definition: VP1CaloCells.h:81
VP1CC_SepTilePositiveDown
@ VP1CC_SepTilePositiveDown
Definition: VP1CaloCells.h:100
VP1CC_SelTypeTileEC
@ VP1CC_SelTypeTileEC
Definition: VP1CaloCells.h:84
VP1CC_SepLArHECNeg
@ VP1CC_SepLArHECNeg
Definition: VP1CaloCells.h:97
VP1CC_SepLArEMECNeg
@ VP1CC_SepLArEMECNeg
Definition: VP1CaloCells.h:96
VP1CC_SelTypeEMEC0
@ VP1CC_SelTypeEMEC0
Definition: VP1CaloCells.h:72
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
VP1CC_TileCrack
Definition: VP1CaloCells.h:351
VP1MbtsHelper
Definition: VP1MbtsHelper.h:19
VP1CaloCellController::scale
QPair< bool, double > scale() const
Definition: VP1CaloCellController.cxx:1136
VP1CC_SepLArEMBNeg
@ VP1CC_SepLArEMBNeg
Definition: VP1CaloCells.h:95
VP1CC_SepLArEMECPos
@ VP1CC_SepLArEMECPos
Definition: VP1CaloCells.h:92
VP1CaloCellController::energyModeEt
bool energyModeEt() const
Definition: VP1CaloCellController.cxx:1164
VP1CC_SepLArHECPos
@ VP1CC_SepLArHECPos
Definition: VP1CaloCells.h:93
CaloCell_Base_ID::is_tile_gapscin
bool is_tile_gapscin(const Identifier id) const
VP1CC_SelTypeEMB0
@ VP1CC_SelTypeEMB0
Definition: VP1CaloCells.h:68
VP1CaloCellSystem::Clockwork::node2ccMap
VP1CC_SoNode2CCMap node2ccMap
Definition: VP1CaloCellSystem.cxx:152
VP1CaloCellSystem::Clockwork::calocells
const CaloCellContainer * calocells
Definition: VP1CaloCellSystem.cxx:127
VP1CC_SelTypeEMB3
@ VP1CC_SelTypeEMB3
Definition: VP1CaloCells.h:71
VP1CaloCellSystem::Clockwork::mbtsHelper
VP1MbtsHelper * mbtsHelper
Definition: VP1CaloCellSystem.cxx:144
VP1CaloCellController::showVolumeOutLines
bool showVolumeOutLines() const
Definition: VP1CaloCellController.cxx:1159
VP1CaloCellController::globalCuts
VP1CC_GlobalCuts globalCuts() const
Definition: VP1CaloCellController.cxx:1169
VP1CC_SelTypeTileCrack
@ VP1CC_SelTypeTileCrack
Definition: VP1CaloCells.h:85
VP1CC_SelTypeEMEC2
@ VP1CC_SelTypeEMEC2
Definition: VP1CaloCells.h:74
VP1CC_SelTypeEMEC1
@ VP1CC_SelTypeEMEC1
Definition: VP1CaloCells.h:73
Generated on Thu Nov 7 2024 22:07:38 for ATLAS Offline Software by   doxygen 1.8.18