CaloGPUClusterAndCellDataMonitor.h

Go to the documentation of this file.

//
// Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
//
// Dear emacs, this is -*- c++ -*-
//
 
#ifndef CALORECGPU_CaloGPUClusterAndCellDataMonitor_H
#define CALORECGPU_CaloGPUClusterAndCellDataMonitor_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "CaloRecGPU/CaloClusterGPUTransformers.h"
#include "CaloRecGPU/CUDAFriendlyClasses.h"
#include "CaloRecGPU/Helpers.h"
#include <string>
#include <vector>
#include <utility>
#include <memory>
#include <mutex>
#include <tuple>
 
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
 
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
 
#include "CaloGPUClusterAndCellDataMonitorOptions.h"
 
class CaloCell_ID;
 
class CaloGPUClusterAndCellDataMonitor :
  public AthAlgTool, virtual public ICaloClusterGPUPlotter
{
 public:
 
  CaloGPUClusterAndCellDataMonitor(const std::string & type, const std::string & name, const IInterface * parent);
 
  virtual StatusCode initialize() override;
 
  virtual ~CaloGPUClusterAndCellDataMonitor() = default;
 
 
  virtual StatusCode update_plots_start(const EventContext & ctx,
                                        const CaloRecGPU::ConstantDataHolder & constant_data,
                                        const xAOD::CaloClusterContainer * cluster_collection_ptr) const override;
 
  virtual StatusCode update_plots_end(const EventContext & ctx,
                                      const CaloRecGPU::ConstantDataHolder & constant_data,
                                      const xAOD::CaloClusterContainer * cluster_collection_ptr) const override;
 
  virtual StatusCode update_plots(const EventContext & ctx,
                                  const CaloRecGPU::ConstantDataHolder & constant_data,
                                  const xAOD::CaloClusterContainer * cluster_collection_ptr,
                                  const CaloClusterCollectionProcessor * tool) const override;
 
  virtual StatusCode update_plots(const EventContext & ctx,
                                  const CaloRecGPU::ConstantDataHolder & constant_data,
                                  const xAOD::CaloClusterContainer * cluster_collection_ptr,
                                  const CaloRecGPU::EventDataHolder & event_data,
                                  const ICaloClusterGPUInputTransformer * tool) const override;
 
  virtual StatusCode update_plots(const EventContext & ctx,
                                  const CaloRecGPU::ConstantDataHolder & constant_data,
                                  const xAOD::CaloClusterContainer * cluster_collection_ptr,
                                  const CaloRecGPU::EventDataHolder & event_data,
                                  const CaloClusterGPUProcessor * tool) const override;
 
  virtual StatusCode update_plots(const EventContext & ctx,
                                  const CaloRecGPU::ConstantDataHolder & constant_data,
                                  const xAOD::CaloClusterContainer * cluster_collection_ptr,
                                  const CaloRecGPU::EventDataHolder & event_data,
                                  const ICaloClusterGPUOutputTransformer * tool) const override;
 
  virtual StatusCode finalize_plots() const override;
 
 private:
 
  StatusCode initialize_plotted_variables();
 
  StatusCode add_data(const EventContext & ctx,
                      const CaloRecGPU::ConstantDataHolder & constant_data,
                      const CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellInfoArr> & cell_info,
                      const CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellStateArr> & cell_state,
                      const CaloRecGPU::Helpers::CPU_object<CaloRecGPU::ClusterInfoArr> & clusters,
                      const CaloRecGPU::Helpers::CPU_object<CaloRecGPU::ClusterMomentsArr> & moments,
                      const std::string & tool_name) const;
 
 
  StatusCode add_combination(const EventContext & ctx,
                             const CaloRecGPU::ConstantDataHolder & constant_data,
                             const int index_1,
                             const int index_2,
                             const std::string & prefix,
                             const bool match_in_energy,
                             const bool match_without_shared,
                             const bool match_perfectly) const;
 
  bool filter_tool_by_name(const std::string & tool_name) const;
 
  StatusCode convert_to_GPU_data_structures(const EventContext & ctx,
                                            const CaloRecGPU::ConstantDataHolder & constant_data,
                                            const xAOD::CaloClusterContainer * cluster_collection_ptr,
                                            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellInfoArr> & cell_info,
                                            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellStateArr> & cell_state,
                                            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::ClusterInfoArr> & clusters,
                                            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::ClusterMomentsArr> & moments) const;
 
  StatusCode compactify_clusters(const EventContext & ctx,
                                 const CaloRecGPU::ConstantDataHolder & constant_data,
                                 const CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellInfoArr> & cell_info,
                                 CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellStateArr> & cell_state,
                                 CaloRecGPU::Helpers::CPU_object<CaloRecGPU::ClusterInfoArr> & clusters,
                                 CaloRecGPU::Helpers::CPU_object<CaloRecGPU::ClusterMomentsArr> & moments) const;
 
 
  struct sample_comparisons_holder
  {
    std::vector<int> r2t_table, t2r_table;
    std::vector<int> unmatched_ref_list, unmatched_test_list;
 
    int r2t(const int i) const
    {
      return r2t_table[i];
    }
    int t2r(const int i) const
    {
      return t2r_table[i];
    }
    int ref_unmatched() const
    {
      return unmatched_ref_list.size();
    }
    int test_unmatched() const
    {
      return unmatched_test_list.size();
    }
  };
 
  StatusCode match_clusters(sample_comparisons_holder & sch,
                            const CaloRecGPU::ConstantDataHolder & constant_data,
                            const CaloRecGPU::CellInfoArr & cell_info,
                            const CaloRecGPU::CellStateArr & cell_state_1,
                            const CaloRecGPU::CellStateArr & cell_state_2,
                            const CaloRecGPU::ClusterInfoArr & cluster_info_1,
                            const CaloRecGPU::ClusterInfoArr & cluster_info_2,
                            const CaloRecGPU::ClusterMomentsArr & /*moments_1*/,
                            const CaloRecGPU::ClusterMomentsArr & /*moments_2*/,
                            const bool match_in_energy,
                            const bool match_without_shared) const;
 
  StatusCode match_clusters_perfectly(sample_comparisons_holder & sch,
                                      const CaloRecGPU::ConstantDataHolder & constant_data,
                                      const CaloRecGPU::CellInfoArr & cell_info,
                                      const CaloRecGPU::CellStateArr & cell_state_1,
                                      const CaloRecGPU::CellStateArr & cell_state_2,
                                      const CaloRecGPU::ClusterInfoArr & cluster_info_1,
                                      const CaloRecGPU::ClusterInfoArr & cluster_info_2,
                                      const CaloRecGPU::ClusterMomentsArr & /*moments_1*/,
                                      const CaloRecGPU::ClusterMomentsArr & /*moments_2*/,
                                      const bool match_without_shared) const;
                                    
  //--------------------------------------------------
  //
  //             GENERAL OPTIONS/SETTINGS
  //
  //--------------------------------------------------
 
  Gaudi::Property<float> m_termThreshold {this, "CellThreshold", 0., "Cell (terminal) threshold (in units of noise Sigma)"};
 
  Gaudi::Property<float> m_growThreshold {this, "NeighborThreshold", 2., "Neighbor (grow) threshold (in units of noise Sigma)"};
 
  Gaudi::Property<float> m_seedThreshold {this, "SeedThreshold", 4., "Seed threshold (in units of noise Sigma)"};
 
  SG::ReadHandleKey<CaloCellContainer> m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"};
 
  ToolHandle< GenericMonitoringTool > m_moniTool { this, "MonitoringTool", "", "Monitoring tool" };
 
  //--------------------------------------------------
  //
  //                    PLOT OPTIONS
  //
  //--------------------------------------------------
 
  Gaudi::Property<std::vector<SimpleSingleTool>> m_toolsToPlot
  {this, "ToolsToPlot", {}, "Tools to be plotted individually"};
 
  Gaudi::Property< std::vector<SimpleToolPair> > m_pairsToPlot
  {this, "PairsToPlot", {}, "Pairs of tools to be compared and plotted"};
 
  Gaudi::Property<MatchingOptions> m_matchingOptions
  {this, "ClusterMatchingParameters", {}, "Parameters for the cluster matching algorithm"};
 
  //--------------------------------------------------
  //
  //              OTHER MEMBER VARIABLES
  //
  //--------------------------------------------------
 
  double m_min_similarity = 0.5, m_seed_weight = 5000., m_grow_weight = 250., m_terminal_weight = 10.;
 
  const CaloCell_ID * m_calo_id {nullptr};
 
  std::map<std::string, int> m_toolsToCheckFor;
 
  std::map<std::string, std::string> m_toolToIdMap;
 
  int m_numToolsToKeep = 0;
 
  struct pair_to_plot
  {
    int index_ref = -1, index_test = -1;
    std::string prefix;
    bool match_in_energy = false;
    bool match_without_shared = false;
    bool match_perfectly = false;
  };
 
  std::vector<pair_to_plot> m_toolCombinations;
 
  mutable std::map<std::string, std::atomic<size_t>> m_numClustersPerTool ATLAS_THREAD_SAFE;
 
  size_t m_numEvents = 0;
 
  struct per_tool_storage
  {
    CaloRecGPU::CellInfoArr cell_info;
    CaloRecGPU::CellStateArr cell_state;
    CaloRecGPU::ClusterInfoArr clusters;
    CaloRecGPU::ClusterMomentsArr moments;
  };
 
  mutable CaloRecGPU::Helpers::separate_thread_holder<std::vector<per_tool_storage>> m_storageHolder ATLAS_THREAD_SAFE;
 
  std::vector<bool> m_clusterPropertiesToDo, m_comparedClusterPropertiesToDo,
      m_extraComparedClusterPropertiesToDo, m_cellPropertiesToDo,
      m_comparedCellPropertiesToDo, m_cellTypesToDo,
      m_comparedCellTypesToDo, m_extraThingsToDo;
 
  bool m_doCells = false, m_doClusters = false, m_doCombinedCells = false, m_doCombinedClusters = false;
  
  
  mutable std::atomic<bool> m_plottedVariablesInitialized;
 
 
  mutable std::mutex m_mutex;
 
};
 
#endif //CALORECGPU_CaloGPUClusterAndCellDataMonitor_H