CaloPerformancePropertiesOutput.h

Go to the documentation of this file.

//
// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
//
// Dear emacs, this is -*- c++ -*-
//
 
#ifndef CALORECGPU_CALOPERFORMANCEPROPERTIESOUTPUT_H
#define CALORECGPU_CALOPERFORMANCEPROPERTIESOUTPUT_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "CaloUtils/CaloClusterCollectionProcessor.h"
 
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
 
#include "xAODCaloEvent/CaloClusterContainer.h"
#include "CaloConditions/CaloNoise.h"
 
#include <string>
#include <mutex>
#include <vector>
 
class CaloCell_ID;

 
class CaloPerformancePropertiesOutput :
  public extends<AthAlgTool, CaloClusterCollectionProcessor>
{
 public:
 
  CaloPerformancePropertiesOutput(const std::string & type, const std::string & name, const IInterface * parent);
  
  using CaloClusterCollectionProcessor::execute;
  
  virtual StatusCode initialize() override;
  
  virtual StatusCode execute (const EventContext& ctx, xAOD::CaloClusterContainer* cluster_collection) const override;
 
  virtual StatusCode finalize() override;
  
  virtual ~CaloPerformancePropertiesOutput() = default;
 
 private:

  Gaudi::Property<std::string> m_fileName{this, "FileName", "event_properties.txt", "File to save the performance-related info."};

  SG::ReadHandleKey<CaloCellContainer> m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"};
  
  SG::ReadCondHandleKey<CaloNoise> m_noiseCDOKey{this, "CaloNoiseKey", "totalNoise", "SG Key of CaloNoise data object"};
  
  Gaudi::Property<bool> m_twoGaussianNoise{this, "TwoGaussianNoise", false, "Use 2-gaussian noise description for TileCal"};
 

  Gaudi::Property<float> m_seedThreshold {this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"};
  
  Gaudi::Property<float> m_growThreshold {this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"};
  
  Gaudi::Property<float> m_cellThreshold {this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"};
  
  Gaudi::Property<bool> m_seedCutsInAbsE {this, "SeedCutsInAbsE", true, "Seed cuts in Abs E instead of E"};

  Gaudi::Property<bool> m_neighborCutsInAbsE {this, "NeighborCutsInAbsE", true, "Neighbor (grow) cuts in Abs E instead of E"};

  Gaudi::Property<bool> m_cellCutsInAbsE {this, "CellCutsInAbsE", true, "Cell (terminal) cuts in Abs E instead of E"};
  
  Gaudi::Property<std::string> m_growNeighborOptionString {this, "GrowingNeighborOption", "super3D",
                                                           "Neighbor option to be used for cell neighborhood relations during growing"};
  LArNeighbours::neighbourOption m_growNeighborOption;
  
  Gaudi::Property<std::string> m_splitNeighborOptionString {this, "SplittingNeighborOption", "super3D",
    "Neighbor option to be used for cell neighborhood relations during splitting"};
  LArNeighbours::neighbourOption m_splitNeighborOption;

  Gaudi::Property<bool> m_growRestrictHECIWandFCalNeighbors {this, "GrowingRestrictHECIWandFCalNeighbors",
    false, "Limit the neighbors in HEC IW and FCal2&3 for growing"};
    
  Gaudi::Property<bool> m_splitRestrictHECIWandFCalNeighbors {this, "SplittingRestrictHECIWandFCalNeighbors",
    false, "Limit the neighbors in HEC IW and FCal2&3 for splitting"};

  Gaudi::Property<bool> m_growRestrictPSNeighbors {this, "GrowingRestrictPSNeighbors",
    false, "Limit the neighbors in presampler Barrel and Endcap for growing"};
    
  Gaudi::Property<bool> m_splitRestrictPSNeighbors {this, "SplittingRestrictPSNeighbors",
    false, "Limit the neighbors in presampler Barrel and Endcap for splitting"};
    
    
  const CaloCell_ID* m_calo_id {nullptr};
  
  
  struct EventPerformanceInfo
  {
    int num_clusters = 0;
    
    int total_seed = 0;
    int total_grow = 0;
    int total_term = 0;
    int total_invalid = 0;
    
    int seed_in_cluster = 0;
    int grow_in_cluster = 0;
    int term_in_cluster = 0;
        
    struct Stats
    {      
      double min = 0., max = 0., avg = 0., stddev = 0.;
    };
    
    Stats cluster_size;
    Stats cluster_num_seed;
    Stats cluster_num_grow;
    Stats cluster_num_term;
    
    Stats cluster_seed_min_radius;
    Stats cluster_seed_max_radius;
    Stats cluster_first_max_radius;
  };
  
  
  mutable std::mutex m_mutex;
  
  mutable std::vector<EventPerformanceInfo> m_eventInfo ATLAS_THREAD_SAFE;
  //Mutexes should ensure no problems with thread safety.

  mutable std::vector<size_t> m_eventNumbers ATLAS_THREAD_SAFE;
  //Mutexes should ensure no problems with thread safety.
 
};
 
#endif //CALORECGPU_CALOPERFORMANCEPROPERTIESOUTPUT_H