ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
GPUToAthenaImporterWithMoments Class Reference

Tool to convert the GPU data representation back to CPU, with selected moments too. More...

#include <GPUToAthenaImporterWithMoments.h>

Inheritance diagram for GPUToAthenaImporterWithMoments:
Collaboration diagram for GPUToAthenaImporterWithMoments:

Classes

struct  MomentsOptionsArray
 

Public Member Functions

 GPUToAthenaImporterWithMoments (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual StatusCode initialize () override
 
virtual StatusCode convert (const EventContext &ctx, const CaloRecGPU::ConstantDataHolder &constant_data, CaloRecGPU::EventDataHolder &event_data, xAOD::CaloClusterContainer *cluster_collection) const override
 
virtual StatusCode finalize () override
 
virtual ~GPUToAthenaImporterWithMoments ()=default
 

Protected Member Functions

void record_times (const size_t event_num, const std::vector< size_t > &times) const
 
template<class ... Args>
void record_times (const size_t event_num, const size_t &value) const
 
template<class ... Args>
void record_times (const size_t event_num, const size_t &value, Args &&... args) const
 
void print_times (const std::string &header, const size_t time_size) const
 

Protected Attributes

std::shared_mutex m_timeMutex
 Mutex that is locked when recording times. More...
 
std::vector< size_t > m_times ATLAS_THREAD_SAFE
 Vector to hold execution times to be recorded if necessary. More...
 
std::vector< size_t > m_eventNumbers ATLAS_THREAD_SAFE
 Vector to hold the event numbers to be recorded if necessary. More...
 
Gaudi::Property< bool > m_measureTimes
 If true, times are recorded to the file given by m_timeFileName. More...
 
Gaudi::Property< std::string > m_timeFileName
 File to which times should be saved. More...
 

Private Member Functions

void record_times_helper (const size_t) const
 
template<class Arg >
void record_times_helper (const size_t index, Arg &&arg) const
 
template<class ... Args>
void record_times_helper (size_t index, Args &&... args) const
 

Private Attributes

Gaudi::Property< bool > m_keepGPUData {this, "KeepGPUData", true, "Keep GPU allocated data"}
 If true, do not delete the GPU data representation. More...
 
SG::ReadHandleKey< CaloCellContainer > m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}
 vector of names of the cell containers to use as input. More...
 
Gaudi::Property< std::string > m_clusterSizeString {this, "ClusterSize", "Topo_420", "The size/type of the clusters"}
 Cluster size. Should be set accordingly to the threshold. More...
 
xAOD::CaloCluster::ClusterSize m_clusterSize
 
const CaloCell_ID * m_calo_id {nullptr}
 Pointer to Calo ID Helper. More...
 
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
 Key for the CaloDetDescrManager in the Condition Store. More...
 
Gaudi::Property< bool > m_fillHVMoments {this, "FillHVMoments", false, "Fill the HV-related moments using the respective tools."}
 if set to true, fill the HV-related moments using the respective tools. More...
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_HVCablingKey {this, "LArCablingKey","LArOnOffIdMap","SG Key of LAr Cabling object"}
 Cabling for the CPU-based HV moments calculation. More...
 
SG::ReadCondHandleKey< ILArHVScaleCorr > m_HVScaleKey {this,"HVScaleCorrKey","LArHVScaleCorr","SG key of HVScaleCorr conditions object"}
 HV corrections for the CPU-based HV moments. More...
 
Gaudi::Property< float > m_HVthreshold {this,"HVThreshold",0.2,"Threshold to consider a cell 'affected' by HV issues"}
 Threshold above which a cell contributes to the HV moments. More...
 
Gaudi::Property< std::vector< int > > m_missingCellsToFill {this, "MissingCellsToFill", {}, "Force fill these cells as disabled on empty containers."}
 Cell indices to fill as disabled cells (useful if the cell vector is always missing the same cells). More...
 
Gaudi::Property< bool > m_saveUncalibrated {this, "SaveUncalibratedSignalState", true, "Use CaloClusterKineHelper::calculateKine instead of GPU-calculated cluster properties"}
 if set to true, the uncalibrated state is saved when importing the clusters. More...
 
Gaudi::Property< std::vector< std::string > > m_momentsNames {this, "MomentsNames", {}, "List of names of moments to calculate"}
 vector holding the input list of names of moments to calculate. More...
 
MomentsOptionsArray m_momentsToDo
 Holds (in a linearized way) the moments and whether to add them to the clusters. More...
 
bool m_doHVMoments
 To abbreviate checks of m_momentsToDo... More...
 

Detailed Description

Tool to convert the GPU data representation back to CPU, with selected moments too.

Author
Nuno Fernandes nuno..nosp@m.dos..nosp@m.santo.nosp@m.s.fe.nosp@m.rnand.nosp@m.es@c.nosp@m.ern.c.nosp@m.h
Date
30 May 2022

Definition at line 33 of file GPUToAthenaImporterWithMoments.h.

Constructor & Destructor Documentation

◆ GPUToAthenaImporterWithMoments()

GPUToAthenaImporterWithMoments::GPUToAthenaImporterWithMoments ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 25 of file GPUToAthenaImporterWithMoments.cxx.

25  :
26  base_class(type, name, parent),
27  CaloGPUTimed(this),
28  m_doHVMoments(false)
29 {
30 }

◆ ~GPUToAthenaImporterWithMoments()

virtual GPUToAthenaImporterWithMoments::~GPUToAthenaImporterWithMoments ( )
virtualdefault

Member Function Documentation

◆ convert()

StatusCode GPUToAthenaImporterWithMoments::convert ( const EventContext &  ctx,
const CaloRecGPU::ConstantDataHolder &  constant_data,
CaloRecGPU::EventDataHolder &  event_data,
xAOD::CaloClusterContainer *  cluster_collection 
) const
overridevirtual

Definition at line 220 of file GPUToAthenaImporterWithMoments.cxx.

224 {
225  using clock_type = boost::chrono::thread_clock;
226  auto time_cast = [](const auto & before, const auto & after)
227  {
228  return boost::chrono::duration_cast<boost::chrono::microseconds>(after - before).count();
229  };
230 
231 
232  const auto start = clock_type::now();
233 
234  SG::ReadHandle<CaloCellContainer> cell_collection(m_cellsKey, ctx);
235  if ( !cell_collection.isValid() )
236  {
237  ATH_MSG_ERROR( " Cannot retrieve CaloCellContainer: " << cell_collection.name() );
238  return StatusCode::FAILURE;
239  }
240  const DataLink<CaloCellContainer> cell_collection_link (cell_collection.name(), ctx);
241 
242  //ed.returnToCPU(!m_keepGPUData, true, true, true);
243 
244  const auto pre_processing = clock_type::now();
245 
246  ed.returnClusterNumberToCPU();
247  CaloRecGPU::CUDA_Helpers::GPU_synchronize();
248 
249 
250  const auto cluster_number = clock_type::now();
251 
252  ed.returnSomeClustersToCPU(ed.m_clusters->number);
253 
254  std::vector<std::unique_ptr<CaloClusterCellLink>> cell_links;
255 
256  cell_links.reserve(ed.m_clusters->number);
257 
258  CaloRecGPU::CUDA_Helpers::GPU_synchronize();
259 
260  const auto clusters = clock_type::now();
261 
262  ed.returnCellsToCPU();
263 
264  for (int i = 0; i < ed.m_clusters->number; ++i)
265  {
266  if (ed.m_clusters->seedCellID[i] >= 0)
267  {
268  cell_links.emplace_back(std::make_unique<CaloClusterCellLink>(cell_collection_link));
269  cell_links.back()->reserve(256);
270  //To be adjusted.
271  }
272  else
273  {
274  cell_links.emplace_back(nullptr);
275  //The excluded clusters don't have any cells.
276  }
277  }
278 
279  std::vector<float> HV_energy(ed.m_clusters->number * m_doHVMoments, 0.f);
280  std::vector<int> HV_number(ed.m_clusters->number * m_doHVMoments, 0 );
281 
282  const LArOnOffIdMapping * cabling = nullptr;
283  const ILArHVScaleCorr * hvcorr = nullptr;
284 
285  if (m_fillHVMoments)
286  {
287  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl(m_HVCablingKey, ctx);
288  SG::ReadCondHandle<ILArHVScaleCorr> hvScaleHdl(m_HVScaleKey, ctx);
289  cabling = *cablingHdl;
290  hvcorr = *hvScaleHdl;
291  }
292 
293  CaloRecGPU::CUDA_Helpers::GPU_synchronize();
294 
295  const auto cells = clock_type::now();
296 
297  ed.returnSomeMomentsToCPU(ed.m_clusters->number);
298 
299  //cell_index is the actual cell index in the full set of cells (identifier hash)
300  //cell_count is the cell position in the cell collection (what we want for the weight)
301  const auto process_cell = [&](const int cell_index, const int cell_count)
302  {
303  const ClusterTag this_tag = ed.m_cell_state->clusterTag[cell_index];
304  if (this_tag.is_part_of_cluster())
305  {
306  const int this_index = this_tag.cluster_index();
307  const int32_t weight_pattern = this_tag.secondary_cluster_weight();
308 
309  float tempf = 1.0f;
310 
311  std::memcpy(&tempf, &weight_pattern, sizeof(float));
312  //C++20 would give us bit cast to do this more properly.
313  //Still, given how the bit pattern is created,
314  //it should be safe.
315 
316  const float reverse_weight = tempf;
317 
318  const float this_weight = 1.0f - reverse_weight;
319 
320  if (cell_links[this_index])
321  {
322  cell_links[this_index]->addCell(cell_count, this_weight);
323 
324  if (cell_index == ed.m_clusters->seedCellID[this_index] && cell_links[this_index]->size() > 1)
325  //Seed cells aren't shared,
326  //so no need to check this on the other case.
327  {
328  CaloClusterCellLink::iterator begin_it = cell_links[this_index]->begin();
329  CaloClusterCellLink::iterator back_it = std::prev(cell_links[this_index]->end());
330 
331  const unsigned int first_idx = begin_it.index();
332  const double first_wgt = begin_it.weight();
333 
334  begin_it.reindex(back_it.index());
335  begin_it.reweight(back_it.weight());
336 
337  back_it.reindex(first_idx);
338  back_it.reweight(first_wgt);
339 
340  //Of course, this is to ensure the first cell is the seed cell,
341  //in accordance to the way some cluster properties
342  //(mostly phi-related) are calculated.
343  }
344  }
345 
346  if (this_tag.is_shared_between_clusters())
347  {
348  const int other_index = this_tag.secondary_cluster_index();
349  if (cell_links[other_index])
350  {
351  cell_links[other_index]->addCell(cell_count, reverse_weight);
352  }
353  }
354 
355  if (m_doHVMoments && !cdh.m_geometry->is_tile(cell_index))
356  {
357  HWIdentifier hwid = cabling->createSignalChannelIDFromHash((IdentifierHash) cell_index);
358  const float corr = hvcorr->HVScaleCorr(hwid);
359  if (corr > 0.f && corr < 100.f && fabsf(corr - 1.f) > m_HVthreshold)
360  {
361  const float abs_energy = fabsf(ed.m_cell_info->energy[cell_index]);
362  HV_energy[this_index] += abs_energy;
363  ++HV_number[this_index];
364  if (this_tag.is_shared_between_clusters())
365  {
366  const int other_index = this_tag.secondary_cluster_index();
367  HV_energy[other_index] += abs_energy;
368  ++HV_number[other_index];
369  }
370  }
371  }
372  }
373  };
374 
375  if (cell_collection->isOrderedAndComplete())
376  //Fast path: cell indices within the collection and identifierHashes match!
377  {
378  for (int cell_index = 0; cell_index < NCaloCells; ++cell_index)
379  {
380  process_cell(cell_index, cell_index);
381  }
382  }
383  else if (cell_collection->isOrdered() && m_missingCellsToFill.size() > 0)
384  {
385  size_t missing_cell_count = 0;
386  for (int cell_index = 0; cell_index < NCaloCells; ++cell_index)
387  {
388  if (missing_cell_count < m_missingCellsToFill.size() && cell_index == m_missingCellsToFill[missing_cell_count])
389  {
390  ++missing_cell_count;
391  continue;
392  }
393  process_cell(cell_index, cell_index - missing_cell_count);
394  }
395  }
396  else
397  //Slow path: be careful.
398  {
399  CaloCellContainer::const_iterator iCells = cell_collection->begin();
400 
401  for (int cell_count = 0; iCells != cell_collection->end(); ++iCells, ++cell_count)
402  {
403  const CaloCell * cell = (*iCells);
404 
405  //const int cell_index = m_calo_id->calo_cell_hash(cell->ID());
406  const int cell_index = cell->caloDDE()->calo_hash();
407 
408  process_cell(cell_index, cell_count);
409  }
410  }
411 
412  const auto end_cell_cycle = clock_type::now();
413 
414  std::vector<int> cluster_order(ed.m_clusters->number);
415 
416  std::iota(cluster_order.begin(), cluster_order.end(), 0);
417 
418  std::sort(cluster_order.begin(), cluster_order.end(), [&](const int a, const int b) -> bool
419  {
420  const bool a_valid = ed.m_clusters->seedCellID[a] >= 0;
421  const bool b_valid = ed.m_clusters->seedCellID[b] >= 0;
422  if (a_valid && b_valid)
423  {
424  return ed.m_clusters->clusterEt[a]
425  > ed.m_clusters->clusterEt[b];
426  }
427  else if (a_valid)
428  {
429  return true;
430  }
431  else if (b_valid)
432  {
433  return false;
434  }
435  else
436  {
437  return b > a;
438  }
439  } );
440 
441  //Ordered by Et as in the default algorithm...
442  //The fact that some invalid clusters
443  //(with possibly trash values for Et)
444  //can crop up is irrelevant since
445  //we don't add those anyway:
446  //the rest is still ordered like we want it to be.
447 
448  const auto ordered = clock_type::now();
449 
450  cluster_container->clear();
451  cluster_container->reserve(cell_links.size());
452 
453  std::vector<int> real_cluster_order;
454  real_cluster_order.reserve(cluster_order.size());
455 
456  for (size_t i = 0; i < cluster_order.size(); ++i)
457  {
458  const int cluster_index = cluster_order[i];
459 
460  if (cell_links[cluster_index] != nullptr && cell_links[cluster_index]->size() > 0)
461  {
462  xAOD::CaloCluster * cluster = new xAOD::CaloCluster();
463  cluster_container->push_back(cluster);
464 
465  cluster->addCellLink(cell_links[cluster_index].release());
466  cluster->setClusterSize(m_clusterSize);
467 
468  cluster->setEta(ed.m_clusters->clusterEta[cluster_index]);
469  cluster->setPhi(ed.m_clusters->clusterPhi[cluster_index]);
470 
471  cluster->setE(ed.m_clusters->clusterEnergy[cluster_index]);
472  cluster->setM(0.0);
473 
474 
475  if (m_saveUncalibrated)
476  {
477  cluster->setRawE(cluster->calE());
478  cluster->setRawEta(cluster->calEta());
479  cluster->setRawPhi(cluster->calPhi());
480  cluster->setRawM(cluster->calM());
481  }
482 
483  real_cluster_order.push_back(cluster_index);
484  }
485 
486  }
487 
488  const auto pre_moments = clock_type::now();
489 
490  CaloRecGPU::CUDA_Helpers::GPU_synchronize();
491 
492 
493  const auto post_moments = clock_type::now();
494 
495  for (size_t i = 0; i < cluster_container->size(); ++i)
496  {
497  xAOD::CaloCluster * cluster = (*cluster_container)[i];
498  const int cluster_index = real_cluster_order[i];
499 
500  cluster->setTime(ed.m_moments->time[cluster_index]);
501  cluster->setSecondTime(ed.m_moments->secondTime[cluster_index]);
502  cluster->clearSamplingData();
503 
504  uint32_t sampling_pattern = 0;
505  for (int sampl = 0; sampl < NumSamplings; ++sampl)
506  {
507  const int cells_per_sampling = ed.m_moments->nCellSampling[sampl][cluster_index];
508 
509  if (cells_per_sampling > 0)
510  {
511  sampling_pattern |= (0x1U << sampl);
512  }
513  }
514  cluster->setSamplingPattern(sampling_pattern);
515 
516  for (int sampl = 0; sampl < NumSamplings; ++sampl)
517  {
518  const int cells_per_sampling = ed.m_moments->nCellSampling[sampl][cluster_index];
519 
520  if (cells_per_sampling > 0)
521  {
522  cluster->setEnergy ((CaloSampling::CaloSample) sampl, ed.m_moments->energyPerSample [sampl][cluster_index]);
523  cluster->setEta ((CaloSampling::CaloSample) sampl, ed.m_moments->etaPerSample [sampl][cluster_index]);
524  cluster->setPhi ((CaloSampling::CaloSample) sampl, ed.m_moments->phiPerSample [sampl][cluster_index]);
525  cluster->setEmax ((CaloSampling::CaloSample) sampl, ed.m_moments->maxEPerSample [sampl][cluster_index]);
526  cluster->setEtamax ((CaloSampling::CaloSample) sampl, ed.m_moments->maxEtaPerSample [sampl][cluster_index]);
527  cluster->setPhimax ((CaloSampling::CaloSample) sampl, ed.m_moments->maxPhiPerSample [sampl][cluster_index]);
528  }
529 
530  if (m_momentsToDo[xAOD::CaloCluster::NCELL_SAMPLING])
531  {
532  cluster->setNumberCellsInSampling((CaloSampling::CaloSample) sampl, cells_per_sampling, false);
533  }
534  }
535 
536 #define CALORECGPU_MOMENTS_CONVERSION_HELPER(MOMENT_ENUM, MOMENT_ARRAY) \
537  if (m_momentsToDo[xAOD::CaloCluster:: MOMENT_ENUM ] ) \
538  { \
539  cluster->insertMoment(xAOD::CaloCluster:: MOMENT_ENUM , ed.m_moments-> MOMENT_ARRAY [cluster_index]); \
540  }
541 
542 
543 #define CALORECGPU_MOMENTS_CONVERSION_INVALID(MOMENT_ENUM) \
544  if (m_momentsToDo[xAOD::CaloCluster:: MOMENT_ENUM ] ) \
545  { \
546  ATH_MSG_WARNING("Moment '" << # MOMENT_ENUM << \
547  "' given as a calculated moment, but not yet supported on the GPU side..."); \
548  }
549 
550  CALORECGPU_MOMENTS_CONVERSION_HELPER(FIRST_PHI, firstPhi );
551  CALORECGPU_MOMENTS_CONVERSION_HELPER(FIRST_ETA, firstEta );
552  CALORECGPU_MOMENTS_CONVERSION_HELPER(SECOND_R, secondR );
553  CALORECGPU_MOMENTS_CONVERSION_HELPER(SECOND_LAMBDA, secondLambda );
554  CALORECGPU_MOMENTS_CONVERSION_HELPER(DELTA_PHI, deltaPhi );
555  CALORECGPU_MOMENTS_CONVERSION_HELPER(DELTA_THETA, deltaTheta );
556  CALORECGPU_MOMENTS_CONVERSION_HELPER(DELTA_ALPHA, deltaAlpha );
557  CALORECGPU_MOMENTS_CONVERSION_HELPER(CENTER_X, centerX );
558  CALORECGPU_MOMENTS_CONVERSION_HELPER(CENTER_Y, centerY );
559  CALORECGPU_MOMENTS_CONVERSION_HELPER(CENTER_Z, centerZ );
560  CALORECGPU_MOMENTS_CONVERSION_HELPER(CENTER_MAG, centerMag );
561  CALORECGPU_MOMENTS_CONVERSION_HELPER(CENTER_LAMBDA, centerLambda );
562  CALORECGPU_MOMENTS_CONVERSION_HELPER(LATERAL, lateral );
563  CALORECGPU_MOMENTS_CONVERSION_HELPER(LONGITUDINAL, longitudinal );
564  CALORECGPU_MOMENTS_CONVERSION_HELPER(ENG_FRAC_EM, engFracEM );
565  CALORECGPU_MOMENTS_CONVERSION_HELPER(ENG_FRAC_MAX, engFracMax );
566  CALORECGPU_MOMENTS_CONVERSION_HELPER(ENG_FRAC_CORE, engFracCore );
567  CALORECGPU_MOMENTS_CONVERSION_HELPER(FIRST_ENG_DENS, firstEngDens );
568  CALORECGPU_MOMENTS_CONVERSION_HELPER(SECOND_ENG_DENS, secondEngDens );
569  CALORECGPU_MOMENTS_CONVERSION_HELPER(ISOLATION, isolation );
570  CALORECGPU_MOMENTS_CONVERSION_HELPER(ENG_BAD_CELLS, engBadCells );
571  CALORECGPU_MOMENTS_CONVERSION_HELPER(N_BAD_CELLS, nBadCells );
572  CALORECGPU_MOMENTS_CONVERSION_HELPER(N_BAD_CELLS_CORR, nBadCellsCorr );
573  CALORECGPU_MOMENTS_CONVERSION_HELPER(BAD_CELLS_CORR_E, badCellsCorrE );
574  CALORECGPU_MOMENTS_CONVERSION_HELPER(BADLARQ_FRAC, badLArQFrac );
575  CALORECGPU_MOMENTS_CONVERSION_HELPER(ENG_POS, engPos );
576  CALORECGPU_MOMENTS_CONVERSION_HELPER(SIGNIFICANCE, significance );
577  CALORECGPU_MOMENTS_CONVERSION_HELPER(CELL_SIGNIFICANCE, cellSignificance );
578  CALORECGPU_MOMENTS_CONVERSION_HELPER(CELL_SIG_SAMPLING, cellSigSampling );
579  CALORECGPU_MOMENTS_CONVERSION_HELPER(AVG_LAR_Q, avgLArQ );
580  CALORECGPU_MOMENTS_CONVERSION_HELPER(AVG_TILE_Q, avgTileQ );
581 
582  if (m_doHVMoments && m_momentsToDo[xAOD::CaloCluster::ENG_BAD_HV_CELLS])
583  {
584  cluster->insertMoment(xAOD::CaloCluster::ENG_BAD_HV_CELLS, HV_energy[cluster_index]);
585  }
586  if (m_doHVMoments && m_momentsToDo[xAOD::CaloCluster::N_BAD_HV_CELLS])
587  {
588  cluster->insertMoment(xAOD::CaloCluster::N_BAD_HV_CELLS, HV_number[cluster_index]);
589  }
590 
591  CALORECGPU_MOMENTS_CONVERSION_HELPER(PTD, PTD );
592  CALORECGPU_MOMENTS_CONVERSION_HELPER(MASS, mass );
593 
594  CALORECGPU_MOMENTS_CONVERSION_INVALID(EM_PROBABILITY );
595  CALORECGPU_MOMENTS_CONVERSION_INVALID(HAD_WEIGHT );
596  CALORECGPU_MOMENTS_CONVERSION_INVALID(OOC_WEIGHT );
597  CALORECGPU_MOMENTS_CONVERSION_INVALID(DM_WEIGHT );
598  CALORECGPU_MOMENTS_CONVERSION_INVALID(TILE_CONFIDENCE_LEVEL );
599 
600 
601  CALORECGPU_MOMENTS_CONVERSION_HELPER(SECOND_TIME, secondTime);
602 
603  if (m_momentsToDo[xAOD::CaloCluster::NCELL_SAMPLING])
604  {
605  const int extra_sampling_count = ed.m_moments->nExtraCellSampling[cluster_index];
606  if (extra_sampling_count > 0)
607  {
608  cluster->setNumberCellsInSampling(CaloSampling::EME2, extra_sampling_count, true);
609  }
610  }
611 
612  CALORECGPU_MOMENTS_CONVERSION_INVALID(VERTEX_FRACTION );
613  CALORECGPU_MOMENTS_CONVERSION_INVALID(NVERTEX_FRACTION );
614  CALORECGPU_MOMENTS_CONVERSION_INVALID(ETACALOFRAME );
615  CALORECGPU_MOMENTS_CONVERSION_INVALID(PHICALOFRAME );
616  CALORECGPU_MOMENTS_CONVERSION_INVALID(ETA1CALOFRAME );
617  CALORECGPU_MOMENTS_CONVERSION_INVALID(PHI1CALOFRAME );
618  CALORECGPU_MOMENTS_CONVERSION_INVALID(ETA2CALOFRAME );
619  CALORECGPU_MOMENTS_CONVERSION_INVALID(PHI2CALOFRAME );
620  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_TOT );
621  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_OUT_L );
622  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_OUT_M );
623  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_OUT_T );
624  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_L );
625  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_M );
626  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_T );
627  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_EMB0 );
628  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_EME0 );
629  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_TILEG3 );
630  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_TOT );
631  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_EMB0 );
632  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_TILE0 );
633  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_TILEG3 );
634  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_EME0 );
635  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_HEC0 );
636  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_FCAL );
637  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_LEAKAGE );
638  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_DEAD_UNCLASS );
639  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_FRAC_EM );
640  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_FRAC_HAD );
641  CALORECGPU_MOMENTS_CONVERSION_INVALID(ENG_CALIB_FRAC_REST );
642 
643  //Maybe things to do with DigiHSTruth, if needed?
644  }
645 
646  const auto end = clock_type::now();
647 
648  if (!m_keepGPUData)
649  {
650  ed.clear_GPU();
651  }
652 
653 
654  if (m_measureTimes)
655  {
656  record_times(ctx.evt(),
657  time_cast(start, pre_processing),
658  time_cast(pre_processing, cluster_number),
659  time_cast(cluster_number, clusters),
660  time_cast(clusters, cells),
661  time_cast(cells, end_cell_cycle),
662  time_cast(end_cell_cycle, ordered),
663  time_cast(ordered, pre_moments),
664  time_cast(pre_moments, post_moments),
665  time_cast(post_moments, end)
666  );
667  }
668 
669 
670  return StatusCode::SUCCESS;
671 
672 }

◆ finalize()

StatusCode GPUToAthenaImporterWithMoments::finalize ( )
overridevirtual

Definition at line 675 of file GPUToAthenaImporterWithMoments.cxx.

676 {
677  if (m_measureTimes)
678  {
679  print_times("Preprocessing Cluster_Number Clusters Cells Cell_Cycle Ordering Cluster_Creation Moments_Transfer Moments_Fill", 9);
680  }
681  return StatusCode::SUCCESS;
682 }

◆ initialize()

StatusCode GPUToAthenaImporterWithMoments::initialize ( )
overridevirtual

Definition at line 34 of file GPUToAthenaImporterWithMoments.cxx.

35 {
36  ATH_CHECK( m_cellsKey.initialize() );
37 
38  ATH_CHECK( detStore()->retrieve(m_calo_id, "CaloCell_ID") );
39 
40  ATH_CHECK(m_caloMgrKey.initialize());
41 
42  ATH_CHECK(m_HVCablingKey.initialize(m_fillHVMoments));
43  ATH_CHECK(m_HVScaleKey.initialize(m_fillHVMoments));
44 
45  auto get_cluster_size_from_string = [](const std::string & str, bool & failed)
46  {
47  failed = false;
48  CRGPU_RECURSIVE_MACRO(
49  CRGPU_CHEAP_STRING_TO_ENUM( str, xAOD::CaloCluster,
50  SW_55ele,
51  SW_35ele,
52  SW_37ele,
53  SW_55gam,
54  SW_35gam,
55  SW_37gam,
56  SW_55Econv,
57  SW_35Econv,
58  SW_37Econv,
59  SW_softe,
60  Topo_420,
61  Topo_633,
62  SW_7_11,
63  SuperCluster,
64  Tower_01_01,
65  Tower_005_005,
66  Tower_fixed_area
67  )
68  )
69  //I know Topological Clustering only supports a subset of those,
70  //but this is supposed to be a general data exporting tool...
71  else
72  {
73  //failed = true;
74  return xAOD::CaloCluster::CSize_Unknown;
75  }
76  };
77 
78  bool size_failed = false;
79  m_clusterSize = get_cluster_size_from_string(m_clusterSizeString, size_failed);
80 
81  if (m_clusterSize == xAOD::CaloCluster::CSize_Unknown)
82  {
83  ATH_MSG_ERROR("Invalid Cluster Size: " << m_clusterSizeString);
84  }
85 
86  if (size_failed)
87  {
88  return StatusCode::FAILURE;
89  }
90 
91 
92  auto get_moment_from_string = [](const std::string & str, bool & failed)
93  {
94  failed = false;
95  CRGPU_RECURSIVE_MACRO(
96  CRGPU_CHEAP_STRING_TO_ENUM( str, xAOD::CaloCluster,
97  FIRST_PHI,
98  FIRST_ETA,
99  SECOND_R,
100  SECOND_LAMBDA,
101  DELTA_PHI,
102  DELTA_THETA,
103  DELTA_ALPHA,
104  CENTER_X,
105  CENTER_Y,
106  CENTER_Z,
107  CENTER_MAG,
108  CENTER_LAMBDA,
109  LATERAL,
110  LONGITUDINAL,
111  ENG_FRAC_EM,
112  ENG_FRAC_MAX,
113  ENG_FRAC_CORE,
114  FIRST_ENG_DENS,
115  SECOND_ENG_DENS,
116  ISOLATION,
117  ENG_BAD_CELLS,
118  N_BAD_CELLS,
119  N_BAD_CELLS_CORR,
120  BAD_CELLS_CORR_E,
121  BADLARQ_FRAC,
122  ENG_POS,
123  SIGNIFICANCE,
124  CELL_SIGNIFICANCE,
125  CELL_SIG_SAMPLING,
126  AVG_LAR_Q,
127  AVG_TILE_Q,
128  ENG_BAD_HV_CELLS,
129  N_BAD_HV_CELLS,
130  PTD,
131  MASS,
132  EM_PROBABILITY,
133  HAD_WEIGHT,
134  OOC_WEIGHT,
135  DM_WEIGHT,
136  TILE_CONFIDENCE_LEVEL,
137  SECOND_TIME,
138  NCELL_SAMPLING,
139  VERTEX_FRACTION,
140  NVERTEX_FRACTION,
141  ETACALOFRAME,
142  PHICALOFRAME,
143  ETA1CALOFRAME,
144  PHI1CALOFRAME,
145  ETA2CALOFRAME,
146  PHI2CALOFRAME,
147  ENG_CALIB_TOT,
148  ENG_CALIB_OUT_L,
149  ENG_CALIB_OUT_M,
150  ENG_CALIB_OUT_T,
151  ENG_CALIB_DEAD_L,
152  ENG_CALIB_DEAD_M,
153  ENG_CALIB_DEAD_T,
154  ENG_CALIB_EMB0,
155  ENG_CALIB_EME0,
156  ENG_CALIB_TILEG3,
157  ENG_CALIB_DEAD_TOT,
158  ENG_CALIB_DEAD_EMB0,
159  ENG_CALIB_DEAD_TILE0,
160  ENG_CALIB_DEAD_TILEG3,
161  ENG_CALIB_DEAD_EME0,
162  ENG_CALIB_DEAD_HEC0,
163  ENG_CALIB_DEAD_FCAL,
164  ENG_CALIB_DEAD_LEAKAGE,
165  ENG_CALIB_DEAD_UNCLASS,
166  ENG_CALIB_FRAC_EM,
167  ENG_CALIB_FRAC_HAD,
168  ENG_CALIB_FRAC_REST)
169  )
170  else
171  {
172  failed = true;
173  return xAOD::CaloCluster::ENERGY_DigiHSTruth;
174  }
175  };
176 
177 
178  auto process_moments = [&](const std::vector<std::string> & moment_names, std::string & invalid_names)
179  {
180  for (const std::string & mom_name : moment_names)
181  {
182  bool failed = false;
183  const int linear_num = MomentsOptionsArray::moment_to_linear(get_moment_from_string(mom_name, failed));
184 
185  failed = failed || linear_num >= MomentsOptionsArray::num_moments;
186 
187  if (failed)
188  {
189  if (invalid_names.size() == 0)
190  {
191  invalid_names = "'" + mom_name + "'";
192  }
193  else
194  {
195  invalid_names += ", '" + mom_name + "'";
196  }
197  }
198  else
199  {
200  m_momentsToDo.array[linear_num] = true;
201  }
202  }
203  };
204 
205  std::string invalid_names;
206 
207  process_moments(m_momentsNames, invalid_names);
208 
209  if (invalid_names.size() > 0)
210  {
211  ATH_MSG_ERROR( "Moments " << invalid_names
212  << " are not valid moments and will be ignored!" );
213  }
214 
215  m_doHVMoments = (m_momentsToDo[xAOD::CaloCluster::ENG_BAD_HV_CELLS] || m_momentsToDo[xAOD::CaloCluster::N_BAD_HV_CELLS]) && m_fillHVMoments;
216  return StatusCode::SUCCESS;
217 }

◆ print_times()

void CaloGPUTimed::print_times ( const std::string &  header,
const size_t  time_size 
) const
inlineprotectedinherited

Definition at line 143 of file CaloGPUTimed.h.

144  {
145  std::shared_lock<std::shared_mutex> lock(m_timeMutex);
146 
147  if (m_timeFileName.size() == 0)
148  {
149  return;
150  }
151 
152  std::vector<size_t> indices(m_eventNumbers.size());
153 
154  std::iota(indices.begin(), indices.end(), 0);
155  std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b)
156  {
157  return m_eventNumbers[a] < m_eventNumbers[b];
158  }
159  );
160  std::ofstream out(m_timeFileName);
161 
162  out << "Event_Number Total " << header << "\n";
163 
164  for (const size_t idx : indices)
165  {
166  out << m_eventNumbers[idx] << " ";
167 
168  size_t total = 0;
169 
170  for (size_t i = 0; i < time_size; ++i)
171  {
172  total += m_times[idx * time_size + i];
173  }
174 
175  out << total << " ";
176 
177  for (size_t i = 0; i < time_size; ++i)
178  {
179  out << m_times[idx * time_size + i] << " ";
180  }
181  out << "\n";
182  }
183 
184  out << std::endl;
185 
186  out.close();
187  }

◆ record_times() [1/3]

template<class ... Args>
void CaloGPUTimed::record_times ( const size_t  event_num,
const size_t &  value 
) const
inlineprotectedinherited

Definition at line 105 of file CaloGPUTimed.h.

106  {
107  const size_t time_size = 1;
108 
109  size_t old_size;
110 
111  {
112  std::unique_lock<std::shared_mutex> lock(m_timeMutex);
113  old_size = m_times.size();
114  m_times.resize(old_size + time_size);
115  m_eventNumbers.push_back(event_num);
116  }
117  {
118  std::shared_lock<std::shared_mutex> lock(m_timeMutex);
119  record_times_helper(old_size, value);
120  }
121  }

◆ record_times() [2/3]

template<class ... Args>
void CaloGPUTimed::record_times ( const size_t  event_num,
const size_t &  value,
Args &&...  args 
) const
inlineprotectedinherited

Definition at line 124 of file CaloGPUTimed.h.

125  {
126  const size_t time_size = sizeof...(args) + 1;
127 
128  size_t old_size;
129 
130  {
131  std::unique_lock<std::shared_mutex> lock(m_timeMutex);
132  old_size = m_times.size();
133  m_times.resize(old_size + time_size);
134  m_eventNumbers.push_back(event_num);
135  }
136  {
137  std::shared_lock<std::shared_mutex> lock(m_timeMutex);
138  record_times_helper(old_size, value, std::forward<Args>(args)...);
139  }
140 
141  }

◆ record_times() [3/3]

void CaloGPUTimed::record_times ( const size_t  event_num,
const std::vector< size_t > &  times 
) const
inlineprotectedinherited

Definition at line 86 of file CaloGPUTimed.h.

87  {
88  size_t old_size;
89  {
90  std::unique_lock<std::shared_mutex> lock(m_timeMutex);
91  old_size = m_times.size();
92  m_times.resize(old_size + times.size());
93  m_eventNumbers.push_back(event_num);
94  }
95  {
96  std::shared_lock<std::shared_mutex> lock(m_timeMutex);
97  for (size_t i = 0; i < times.size(); ++i)
98  {
99  m_times[old_size + i] = times[i];
100  }
101  }
102  }

◆ record_times_helper() [1/3]

template<class Arg >
void CaloGPUTimed::record_times_helper ( const size_t  index,
Arg &&  arg 
) const
inlineprivateinherited

Definition at line 70 of file CaloGPUTimed.h.

71  {
72  // coverity[missing_lock]
73  m_times[index] = std::forward<Arg>(arg);
74 
75  //This is called within a function that holds the lock itself.
76  }

◆ record_times_helper() [2/3]

void CaloGPUTimed::record_times_helper ( const  size_t) const
inlineprivateinherited

Definition at line 64 of file CaloGPUTimed.h.

65  {
66  //Do nothing
67  }

◆ record_times_helper() [3/3]

template<class ... Args>
void CaloGPUTimed::record_times_helper ( size_t  index,
Args &&...  args 
) const
inlineprivateinherited

Definition at line 79 of file CaloGPUTimed.h.

80  {
81  (record_times_helper(index++, std::forward<Args>(args)), ...);
82  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

std::vector<size_t> m_times CaloGPUTimed::ATLAS_THREAD_SAFE
mutableprotectedinherited

Vector to hold execution times to be recorded if necessary.

Definition at line 35 of file CaloGPUTimed.h.

◆ ATLAS_THREAD_SAFE [2/2]

std::vector<size_t> m_eventNumbers CaloGPUTimed::ATLAS_THREAD_SAFE
mutableprotectedinherited

Vector to hold the event numbers to be recorded if necessary.

Definition at line 40 of file CaloGPUTimed.h.

◆ m_calo_id

const CaloCell_ID* GPUToAthenaImporterWithMoments::m_calo_id {nullptr}
private

Pointer to Calo ID Helper.

Definition at line 70 of file GPUToAthenaImporterWithMoments.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> GPUToAthenaImporterWithMoments::m_caloMgrKey
private
Initial value:
{this, "CaloDetDescrManager", "CaloDetDescrManager",
"SG Key for CaloDetDescrManager in the Condition Store"}

Key for the CaloDetDescrManager in the Condition Store.

Definition at line 75 of file GPUToAthenaImporterWithMoments.h.

◆ m_cellsKey

SG::ReadHandleKey<CaloCellContainer> GPUToAthenaImporterWithMoments::m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}
private

vector of names of the cell containers to use as input.

Definition at line 60 of file GPUToAthenaImporterWithMoments.h.

◆ m_clusterSize

xAOD::CaloCluster::ClusterSize GPUToAthenaImporterWithMoments::m_clusterSize
private

Definition at line 65 of file GPUToAthenaImporterWithMoments.h.

◆ m_clusterSizeString

Gaudi::Property<std::string> GPUToAthenaImporterWithMoments::m_clusterSizeString {this, "ClusterSize", "Topo_420", "The size/type of the clusters"}
private

Cluster size. Should be set accordingly to the threshold.

Definition at line 63 of file GPUToAthenaImporterWithMoments.h.

◆ m_doHVMoments

bool GPUToAthenaImporterWithMoments::m_doHVMoments
private

To abbreviate checks of m_momentsToDo...

Definition at line 302 of file GPUToAthenaImporterWithMoments.h.

◆ m_fillHVMoments

Gaudi::Property<bool> GPUToAthenaImporterWithMoments::m_fillHVMoments {this, "FillHVMoments", false, "Fill the HV-related moments using the respective tools."}
private

if set to true, fill the HV-related moments using the respective tools.

Definition at line 83 of file GPUToAthenaImporterWithMoments.h.

◆ m_HVCablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> GPUToAthenaImporterWithMoments::m_HVCablingKey {this, "LArCablingKey","LArOnOffIdMap","SG Key of LAr Cabling object"}
private

Cabling for the CPU-based HV moments calculation.

Definition at line 86 of file GPUToAthenaImporterWithMoments.h.

◆ m_HVScaleKey

SG::ReadCondHandleKey<ILArHVScaleCorr> GPUToAthenaImporterWithMoments::m_HVScaleKey {this,"HVScaleCorrKey","LArHVScaleCorr","SG key of HVScaleCorr conditions object"}
private

HV corrections for the CPU-based HV moments.

Definition at line 89 of file GPUToAthenaImporterWithMoments.h.

◆ m_HVthreshold

Gaudi::Property<float> GPUToAthenaImporterWithMoments::m_HVthreshold {this,"HVThreshold",0.2,"Threshold to consider a cell 'affected' by HV issues"}
private

Threshold above which a cell contributes to the HV moments.

Definition at line 92 of file GPUToAthenaImporterWithMoments.h.

◆ m_keepGPUData

Gaudi::Property<bool> GPUToAthenaImporterWithMoments::m_keepGPUData {this, "KeepGPUData", true, "Keep GPU allocated data"}
private

If true, do not delete the GPU data representation.

Defaults to true.

Definition at line 55 of file GPUToAthenaImporterWithMoments.h.

◆ m_measureTimes

Gaudi::Property<bool> CaloGPUTimed::m_measureTimes
protectedinherited

If true, times are recorded to the file given by m_timeFileName.

Defaults to false.

Definition at line 46 of file CaloGPUTimed.h.

◆ m_missingCellsToFill

Gaudi::Property<std::vector<int> > GPUToAthenaImporterWithMoments::m_missingCellsToFill {this, "MissingCellsToFill", {}, "Force fill these cells as disabled on empty containers."}
private

Cell indices to fill as disabled cells (useful if the cell vector is always missing the same cells).

Definition at line 96 of file GPUToAthenaImporterWithMoments.h.

◆ m_momentsNames

Gaudi::Property<std::vector<std::string> > GPUToAthenaImporterWithMoments::m_momentsNames {this, "MomentsNames", {}, "List of names of moments to calculate"}
private

vector holding the input list of names of moments to calculate.

This is the list of desired names of moments given in the jobOptions.

Definition at line 110 of file GPUToAthenaImporterWithMoments.h.

◆ m_momentsToDo

MomentsOptionsArray GPUToAthenaImporterWithMoments::m_momentsToDo
private

Holds (in a linearized way) the moments and whether to add them to the clusters.

(on the GPU side, they are unconditionally calculated).

Definition at line 298 of file GPUToAthenaImporterWithMoments.h.

◆ m_saveUncalibrated

Gaudi::Property<bool> GPUToAthenaImporterWithMoments::m_saveUncalibrated {this, "SaveUncalibratedSignalState", true, "Use CaloClusterKineHelper::calculateKine instead of GPU-calculated cluster properties"}
private

if set to true, the uncalibrated state is saved when importing the clusters.

Default is true.

Definition at line 101 of file GPUToAthenaImporterWithMoments.h.

◆ m_timeFileName

Gaudi::Property<std::string> CaloGPUTimed::m_timeFileName
protectedinherited

File to which times should be saved.

Definition at line 50 of file CaloGPUTimed.h.

◆ m_timeMutex

std::shared_mutex CaloGPUTimed::m_timeMutex
mutableprotectedinherited

Mutex that is locked when recording times.

Definition at line 32 of file CaloGPUTimed.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
GPUToAthenaImporterWithMoments::MomentsOptionsArray::array
bool array[num_moments]
Definition: GPUToAthenaImporterWithMoments.h:116
GPUToAthenaImporterWithMoments::m_doHVMoments
bool m_doHVMoments
To abbreviate checks of m_momentsToDo...
Definition: GPUToAthenaImporterWithMoments.h:302
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:281
xAOD::CaloCluster_v1::CSize_Unknown
@ CSize_Unknown
Definition: CaloCluster_v1.h:115
TauGNNUtils::Variables::Cluster::CENTER_LAMBDA
bool CENTER_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:851
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
GPUToAthenaImporterWithMoments::m_HVCablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_HVCablingKey
Cabling for the CPU-based HV moments calculation.
Definition: GPUToAthenaImporterWithMoments.h:86
ILArHVScaleCorr
Definition: ILArHVScaleCorr.h:13
xAOD::CaloCluster_v1::setRawM
void setRawM(flt_t)
Set mass for singal state UNCALIBRATED.
Definition: CaloCluster_v1.cxx:299
header
Definition: hcg.cxx:526
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
CaloRecGPU::ClusterTag::secondary_cluster_index
constexpr int32_t secondary_cluster_index() const
Definition: TagDefinitions.h:253
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
TauGNNUtils::Variables::Cluster::EM_PROBABILITY
bool EM_PROBABILITY(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:920
python.CaloAddPedShiftConfig.args
args
Definition: CaloAddPedShiftConfig.py:47
CaloRecGPU::ClusterTag::is_shared_between_clusters
constexpr bool is_shared_between_clusters() const
Definition: TagDefinitions.h:273
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
xAOD::CaloCluster_v1::ENG_BAD_HV_CELLS
@ ENG_BAD_HV_CELLS
Total em-scale energy of cells with bad HV in this cluster.
Definition: CaloCluster_v1.h:170
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
CaloGPUTimed::m_timeMutex
std::shared_mutex m_timeMutex
Mutex that is locked when recording times.
Definition: CaloGPUTimed.h:32
GPUToAthenaImporterWithMoments::m_saveUncalibrated
Gaudi::Property< bool > m_saveUncalibrated
if set to true, the uncalibrated state is saved when importing the clusters.
Definition: GPUToAthenaImporterWithMoments.h:101
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:161
xAOD::CaloCluster_v1::calE
flt_t calE() const
Geet Energy in signal state CALIBRATED.
GPUToAthenaImporterWithMoments::m_momentsNames
Gaudi::Property< std::vector< std::string > > m_momentsNames
vector holding the input list of names of moments to calculate.
Definition: GPUToAthenaImporterWithMoments.h:110
GPUToAthenaImporterWithMoments::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Key for the CaloDetDescrManager in the Condition Store.
Definition: GPUToAthenaImporterWithMoments.h:75
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
xAOD::CaloCluster_v1::clearSamplingData
void clearSamplingData()
Clear the sampling data.
Definition: CaloCluster_v1.cxx:671
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
xAOD::CaloCluster_v1::calEta
flt_t calEta() const
Get in signal state CALIBRATED.
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
CaloRecGPU::CUDA_Helpers::GPU_synchronize
void GPU_synchronize(CUDAStreamPtrHolder stream={})
Synchronizes the stream.
CaloGPUTimed::m_timeFileName
Gaudi::Property< std::string > m_timeFileName
File to which times should be saved.
Definition: CaloGPUTimed.h:50
xAOD::CaloCluster_v1::insertMoment
void insertMoment(MomentType type, double value)
Definition: CaloCluster_v1.cxx:708
athena.value
value
Definition: athena.py:124
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
GPUToAthenaImporterWithMoments::m_clusterSize
xAOD::CaloCluster::ClusterSize m_clusterSize
Definition: GPUToAthenaImporterWithMoments.h:65
xAOD::CaloCluster_v1::setSamplingPattern
void setSamplingPattern(const unsigned sp, const bool clearSamplingVars=false)
Set sampling pattern (one bit per sampling.
Definition: CaloCluster_v1.cxx:81
xAOD::CaloCluster_v1::setEnergy
bool setEnergy(const CaloSample sampling, const float e)
Set energy for a given sampling. Returns false if the sample isn't part of the cluster.
Definition: CaloCluster_v1.cxx:519
CaloRecGPU::NumSamplings
constexpr int NumSamplings
Definition: BaseDefinitions.h:43
xAOD::CaloCluster_v1::calM
flt_t calM() const
Get mass in signal state CALIBRATED.
xAOD::CaloCluster_v1::setTime
void setTime(flt_t)
Set cluster time.
xAOD::CaloCluster_v1::setEmax
bool setEmax(const CaloSample sampling, const float eMax)
Set the Energy of the cell with the highest energy in a particular sampling.
Definition: CaloCluster_v1.cxx:564
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::CaloCluster
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.
Definition: Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloCluster.h:19
CaloRecGPU::ClusterTag
Definition: TagDefinitions.h:222
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
xAOD::CaloCluster_v1::NCELL_SAMPLING
@ NCELL_SAMPLING
Number of cells in sampling layer.
Definition: CaloCluster_v1.h:185
xAOD::CaloCluster_v1::setSecondTime
void setSecondTime(flt_t stime)
Set second moment of cell timing distribution.
Definition: CaloCluster_v1.cxx:939
CRGPU_CHEAP_STRING_TO_ENUM
#define CRGPU_CHEAP_STRING_TO_ENUM(VAR, PREFIX, ONE,...)
Checks a string variable, VAR, for matching enum identifiers (ONE and the remaining variadic argument...
Definition: MacroHelpers.h:148
GPUToAthenaImporterWithMoments::m_momentsToDo
MomentsOptionsArray m_momentsToDo
Holds (in a linearized way) the moments and whether to add them to the clusters.
Definition: GPUToAthenaImporterWithMoments.h:298
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
CaloRecGPU::ClusterTag::cluster_index
constexpr int32_t cluster_index() const
Definition: TagDefinitions.h:243
xAOD::CaloCluster_v1::setE
void setE(flt_t)
Definition: CaloCluster_v1.cxx:375
GPUToAthenaImporterWithMoments::m_keepGPUData
Gaudi::Property< bool > m_keepGPUData
If true, do not delete the GPU data representation.
Definition: GPUToAthenaImporterWithMoments.h:55
xAOD::CaloCluster_v1::setPhimax
bool setPhimax(const CaloSample sampling, const float phiMax)
Set the phi of the cell with the highest energy in a particular sampling.
Definition: CaloCluster_v1.cxx:590
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
python.handimod.now
now
Definition: handimod.py:674
xAOD::CaloCluster_v1::setRawE
void setRawE(flt_t)
Set Energy for signal state UNCALIBRATED.
Definition: CaloCluster_v1.cxx:284
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
CRGPU_RECURSIVE_MACRO
#define CRGPU_RECURSIVE_MACRO(...)
Expands recursive macros.
Definition: MacroHelpers.h:70
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
CaloGPUTimed::print_times
void print_times(const std::string &header, const size_t time_size) const
Definition: CaloGPUTimed.h:143
test_pyathena.parent
parent
Definition: test_pyathena.py:15
xAOD::CaloCluster_v1::setRawEta
void setRawEta(flt_t)
Set for signal state UNCALIBRATED.
Definition: CaloCluster_v1.cxx:289
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::CaloCluster_v1::calPhi
flt_t calPhi() const
Get in signal state CALIBRATED.
GPUToAthenaImporterWithMoments::m_cellsKey
SG::ReadHandleKey< CaloCellContainer > m_cellsKey
vector of names of the cell containers to use as input.
Definition: GPUToAthenaImporterWithMoments.h:60
hist_file_dump.f
f
Definition: hist_file_dump.py:140
CaloRecGPU::NCaloCells
constexpr int NCaloCells
Definition: BaseDefinitions.h:12
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TauGNNUtils::Variables::Cluster::SECOND_LAMBDA
bool SECOND_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:846
GPUToAthenaImporterWithMoments::MomentsOptionsArray::num_moments
static constexpr int num_moments
Definition: GPUToAthenaImporterWithMoments.h:115
GPUToAthenaImporterWithMoments::m_clusterSizeString
Gaudi::Property< std::string > m_clusterSizeString
Cluster size. Should be set accordingly to the threshold.
Definition: GPUToAthenaImporterWithMoments.h:63
GPUToAthenaImporterWithMoments::m_calo_id
const CaloCell_ID * m_calo_id
Pointer to Calo ID Helper.
Definition: GPUToAthenaImporterWithMoments.h:70
create_dcsc_inputs_sqlite.arg
list arg
Definition: create_dcsc_inputs_sqlite.py:48
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
python.EventInfoMgtInit.release
release
Definition: EventInfoMgtInit.py:23
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
GPUToAthenaImporterWithMoments::m_HVScaleKey
SG::ReadCondHandleKey< ILArHVScaleCorr > m_HVScaleKey
HV corrections for the CPU-based HV moments.
Definition: GPUToAthenaImporterWithMoments.h:89
xAOD::CaloCluster_v1::setNumberCellsInSampling
void setNumberCellsInSampling(CaloSampling::CaloSample samp, int ncells, bool isInnerWheel=false)
Set the number of cells in a sampling layer.
Definition: CaloCluster_v1.cxx:744
GPUToAthenaImporterWithMoments::m_fillHVMoments
Gaudi::Property< bool > m_fillHVMoments
if set to true, fill the HV-related moments using the respective tools.
Definition: GPUToAthenaImporterWithMoments.h:83
TauGNNUtils::Variables::Cluster::SECOND_R
bool SECOND_R(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:841
CaloGPUTimed::CaloGPUTimed
CaloGPUTimed(T *ptr)
Definition: CaloGPUTimed.h:55
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
xAOD::CaloCluster_v1::ENERGY_DigiHSTruth
@ ENERGY_DigiHSTruth
First Moment in .
Definition: CaloCluster_v1.h:259
CaloRecGPU::ClusterTag::is_part_of_cluster
constexpr bool is_part_of_cluster() const
Definition: TagDefinitions.h:233
CALORECGPU_MOMENTS_CONVERSION_INVALID
#define CALORECGPU_MOMENTS_CONVERSION_INVALID(MOMENT_ENUM)
CaloGPUTimed::record_times_helper
void record_times_helper(const size_t) const
Definition: CaloGPUTimed.h:64
TauGNNUtils::Variables::Cluster::CENTER_MAG
bool CENTER_MAG(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:927
DeMoScan.index
string index
Definition: DeMoScan.py:362
a
TList * a
Definition: liststreamerinfos.cxx:10
xAOD::CaloCluster_v1::addCellLink
void addCellLink(CaloClusterCellLink *CCCL)
Definition: CaloCluster_v1.h:724
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
xAOD::CaloCluster_v1::setClusterSize
void setClusterSize(const ClusterSize)
Get cluster size.
Definition: CaloCluster_v1.cxx:369
CaloGPUTimed::record_times
void record_times(const size_t event_num, const std::vector< size_t > &times) const
Definition: CaloGPUTimed.h:86
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
CaloGPUTimed::m_measureTimes
Gaudi::Property< bool > m_measureTimes
If true, times are recorded to the file given by m_timeFileName.
Definition: CaloGPUTimed.h:46
xAOD::CaloCluster_v1::N_BAD_HV_CELLS
@ N_BAD_HV_CELLS
number of cells with bad HV
Definition: CaloCluster_v1.h:171
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
TauGNNUtils::Variables::Cluster::FIRST_ENG_DENS
bool FIRST_ENG_DENS(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:913
xAOD::CaloCluster_v1::setPhi
bool setPhi(const CaloSample sampling, const float phi)
Set in a given sampling. Returns false if the sample isn't part of the cluster.
Definition: CaloCluster_v1.cxx:549
xAOD::CaloCluster_v1::setEtamax
bool setEtamax(const CaloSample sampling, const float etaMax)
Set the eta of the cell with the highest energy in a particular sampling.
Definition: CaloCluster_v1.cxx:577
str
Definition: BTagTrackIpAccessor.cxx:11
ILArHVScaleCorr::HVScaleCorr
virtual const float & HVScaleCorr(const HWIdentifier &id) const =0
xAOD::CaloCluster_v1::setEta
bool setEta(const CaloSample sampling, const float eta)
Set in a given sampling. Returns false if the sample isn't part of the cluster.
Definition: CaloCluster_v1.cxx:534
CALORECGPU_MOMENTS_CONVERSION_HELPER
#define CALORECGPU_MOMENTS_CONVERSION_HELPER(MOMENT_ENUM, MOMENT_ARRAY)
GPUToAthenaImporterWithMoments::m_missingCellsToFill
Gaudi::Property< std::vector< int > > m_missingCellsToFill
Cell indices to fill as disabled cells (useful if the cell vector is always missing the same cells).
Definition: GPUToAthenaImporterWithMoments.h:96
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
CaloRecGPU::ClusterTag::secondary_cluster_weight
constexpr int32_t secondary_cluster_weight() const
Definition: TagDefinitions.h:263
plot_times.times
def times(fn)
Definition: plot_times.py:10
xAOD::CaloCluster_v1::setM
void setM(flt_t)
Set Mass for the current signal state.
Definition: CaloCluster_v1.cxx:424
xAOD::CaloCluster_v1::setRawPhi
void setRawPhi(flt_t)
Set for signal state UNCALIBRATED.
Definition: CaloCluster_v1.cxx:294
GPUToAthenaImporterWithMoments::m_HVthreshold
Gaudi::Property< float > m_HVthreshold
Threshold above which a cell contributes to the HV moments.
Definition: GPUToAthenaImporterWithMoments.h:92
GPUToAthenaImporterWithMoments::MomentsOptionsArray::moment_to_linear
static constexpr int moment_to_linear(const xAOD::CaloCluster::MomentType moment)
Definition: GPUToAthenaImporterWithMoments.h:123
Generated on Mon Sep 1 2025 21:35:29 for ATLAS Offline Software by   doxygen 1.8.18