diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/HolderTemplate.h b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/HolderTemplate.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6bc1e50a208dfa69f738e677e5de8acde9af968
--- /dev/null
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/HolderTemplate.h
@@ -0,0 +1,141 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef HOLDERTEMPLATE_H_
+#define HOLDERTEMPLATE_H_
+#include "AthenaMonitoring/ManagedMonitorToolBase.h"
+#include "GaudiKernel/StatusCode.h"
+#include "InDetIdentifier/PixelID.h"
+
+class array;
+class string;
+
+namespace PixMon {
+enum class HistConf;
+
+/**
+ * Template structure to delete light-weight histograms. The implementation of
+ * this deleter is intentionally left empty: all histograms and their memory are
+ * taken care of by the central monitoring tools (i.e. the monitoring group
+ * classes in which the histograms are registered).
+ */
+template <typename T>
+struct LWHistDeleter {
+ void operator() (T* hist) {
+ // To avoid "unused variable" compiler warnings for the parameter.
+ (void)hist;
+ }
+};
+
+/**
+ * Template class to hold a set of histogram for the different pixel components.
+ * The class holds a maxmium of 10 histograms; the initialisation can be
+ * controlled with the HistConf parameter given as input to the constructor.
+ *
+ * This class serves as template for various histogram holder classes.
+ */
+template <typename T>
+class HolderTemplate {
+ public:
+ /**
+ * Default constructor of the template class. Sets all pointers to null
+ * and saves the configuration option as member variables.
+ *
+ * @param config: the histogram configuration
+ * @param copy2DFEval: boolean whether to copy IBL values to neighbouring FE
+ */
+ inline HolderTemplate(const HistConf& config, bool copy2DFEval = false)
+ : IBL{nullptr},
+ IBL2D{nullptr},
+ IBL3D{nullptr},
+ B0{nullptr},
+ B1{nullptr},
+ B2{nullptr},
+ A{nullptr},
+ C{nullptr},
+ DBMA{nullptr},
+ DBMC{nullptr},
+ m_histograms{{nullptr}},
+ m_config{config},
+ m_copy2DFEval{copy2DFEval},
+ m_doIBL{true} {}
+
+ //! Function for histogram formatting. To be reimplemented in derived classes.
+ virtual void formatHist() = 0;
+
+ //! Register the histograms in the monitoring group.
+ StatusCode regHist(ManagedMonitorToolBase::MonGroup& group) {
+ StatusCode sc = StatusCode::SUCCESS;
+ for (auto& hist : m_histograms) {
+ if (hist && group.regHist(hist.get()).isFailure()) {
+ sc = StatusCode::FAILURE;
+ }
+ }
+ return sc;
+ }
+
+ /**
+ * Function to set the individual (raw) pointers declared below to the correct
+ * memory addresses. This function is to be called *after* the histograms in
+ * m_histograms are initialised in the class constructor.
+ */
+ inline void setHistogramPointers() {
+ IBL = m_histograms.at(0).get();
+ IBL2D = m_histograms.at(1).get();
+ IBL3D = m_histograms.at(2).get();
+ B0 = m_histograms.at(3).get();
+ B1 = m_histograms.at(4).get();
+ B2 = m_histograms.at(5).get();
+ A = m_histograms.at(6).get();
+ C = m_histograms.at(7).get();
+ DBMA = m_histograms.at(8).get();
+ DBMC = m_histograms.at(9).get();
+ }
+
+ //! Pointer to individal histogram: IBL (both 2D/3D modules).
+ T* IBL;
+
+ //! Pointer to individal histogram: IBL 2D histogram (2D modules only).
+ T* IBL2D;
+
+ //! Pointer to individal histogram: IBL 3D histogram (3D modules only).
+ T* IBL3D;
+
+ //! Pointer to individal histogram: barrel layer 0.
+ T* B0;
+
+ //! Pointer to individal histogram: barrel layer 1.
+ T* B1;
+
+ //! Pointer to individal histogram: barrel layer 2.
+ T* B2;
+
+ //! Pointer to individal histogram: end-cap side A.
+ T* A;
+
+ //! Pointer to individal histogram: end-cap side C.
+ T* C;
+
+ //! Pointer to individal histogram: DBM side A.
+ T* DBMA;
+
+ //! Pointer to individal histogram: DBM side C.
+ T* DBMC;
+
+ protected:
+ //! Array containing unique pointers to all histograms.
+ std::array<std::unique_ptr<T, LWHistDeleter<T>>, 10> m_histograms;
+
+ //! Configuration which histograms are to be initialised.
+ const HistConf m_config;
+
+ //! Boolean whether IBL values should be copied to neighbouring FE.
+ const bool m_copy2DFEval;
+
+ //! Boolean for job option 'doIBL'. --> TO BE REMOVED
+ const bool m_doIBL;
+};
+}
+
+#endif // HOLDERTEMPLATE_H_
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMainMon.h b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMainMon.h
index 185c1de10d38b4e4c52ef5a50125facbc55a97cd..68af156cd96a8ef4654290de78d831635c10d7c9 100755
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMainMon.h
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMainMon.h
@@ -321,8 +321,8 @@ private:
/// the number of hits
TProfile_LW* m_hits_per_lumi;
TH1I_LW* m_num_hits;
- PixelMon2DMapsLW* m_hitmap_mon;
- PixelMon2DMapsLW* m_hitmap_tmp;
+ std::unique_ptr<PixelMon2DMapsLW> m_hitmap_mon;
+ std::unique_ptr<PixelMon2DMapsLW> m_hitmap_tmp;
TH1F_LW* m_nhits_mod[PixLayer::COUNT];
TProfile_LW* m_hits_per_lumi_mod[PixLayer::COUNT];
TH1F_LW* m_nlargeevt_per_lumi_mod[PixLayerIBL2D3D::COUNT];
@@ -337,10 +337,10 @@ private:
TH2F_LW* m_maxocc_per_lumi_mod[PixLayerIBL2D3D::COUNT];
TH2F_LW* m_modocc_per_lumi[PixLayer::COUNT];
TH1F_LW* m_maxocc_per_bcid_mod[PixLayerIBL2D3D::COUNT];
- PixelMon2DMapsLW* m_occupancy;
- PixelMon2DMapsLW* m_average_pixocc;
- PixelMon2DProfilesLW* m_occupancy_pix_evt;
- PixelMon2DMapsLW* m_occupancy_10min;
+ std::unique_ptr<PixelMon2DMapsLW> m_occupancy;
+ std::unique_ptr<PixelMon2DMapsLW> m_average_pixocc;
+ std::unique_ptr<PixelMon2DProfilesLW> m_occupancy_pix_evt;
+ std::unique_ptr<PixelMon2DMapsLW> m_occupancy_10min;
TProfile* m_occupancy_time1;
TProfile* m_occupancy_time2;
TProfile* m_occupancy_time3;
@@ -365,17 +365,17 @@ private:
TH1F_LW* m_Lvl1A_10min_mod[PixLayer::COUNT];
TH1I_LW* m_Lvl1ID_diff_mod_ATLAS_mod[PixLayer::COUNT];
TH1I_LW* m_diff_ROD_vs_Module_BCID_mod[PixLayer::COUNT];
- PixelMon2DLumiProfiles* m_Lvl1ID_diff_mod_ATLAS_per_LB;
- PixelMon2DLumiProfiles* m_Lvl1ID_absdiff_mod_ATLAS_per_LB;
+ std::unique_ptr<PixelMon2DLumiProfiles> m_Lvl1ID_diff_mod_ATLAS_per_LB;
+ std::unique_ptr<PixelMon2DLumiProfiles> m_Lvl1ID_absdiff_mod_ATLAS_per_LB;
/// Quick status
TH2F_LW* m_nhits_L0_B11_S2_C6;
TProfile2D_LW* m_occupancy_L0_B11_S2_C6;
/// module histo
- PixelMonModules1D* m_hit_num_mod;
- PixelMonModulesProf* m_hiteff_mod;
- PixelMonModules1D* m_FE_chip_hit_summary;
- PixelMonModules2D* m_pixel_occupancy;
+ std::unique_ptr<PixelMonModules1D> m_hit_num_mod;
+ std::unique_ptr<PixelMonModulesProf> m_hiteff_mod;
+ std::unique_ptr<PixelMonModules1D> m_FE_chip_hit_summary;
+ std::unique_ptr<PixelMonModules2D> m_pixel_occupancy;
/// details
TH1F_LW* m_Details_mod1_num_hits;
TH1F_LW* m_Details_mod2_num_hits;
@@ -404,16 +404,16 @@ private:
TProfile_LW* m_tracksPerEvt_per_lumi;
TProfile_LW* m_tracksPerEvtPerMu_per_lumi;
/// track state on surface
- PixelMon2DMapsLW* m_tsos_hitmap;
- PixelMon2DMapsLW* m_tsos_holemap;
- PixelMon2DMapsLW* m_tsos_outliermap;
- //PixelMon2DProfilesLW* m_tsos_measratio;
- //PixelMon2DProfilesLW* m_tsos_holeratio;
- PixelMon2DProfilesLW* m_misshits_ratio;
- PixelMon2DProfilesLW* m_tsos_holeratio_tmp;
- PixelMon2DProfilesLW* m_tsos_holeratio_mon;
- PixelMon2DProfilesLW* m_misshits_ratio_tmp;
- PixelMon2DProfilesLW* m_misshits_ratio_mon;
+ std::unique_ptr<PixelMon2DMapsLW> m_tsos_hitmap;
+ std::unique_ptr<PixelMon2DMapsLW> m_tsos_holemap;
+ std::unique_ptr<PixelMon2DMapsLW> m_tsos_outliermap;
+ //std::unique_ptr<PixelMon2DProfilesLW> m_tsos_measratio;
+ //std::unique_ptr<PixelMon2DProfilesLW> m_tsos_holeratio;
+ std::unique_ptr<PixelMon2DProfilesLW> m_misshits_ratio;
+ std::unique_ptr<PixelMon2DProfilesLW> m_tsos_holeratio_tmp;
+ std::unique_ptr<PixelMon2DProfilesLW> m_tsos_holeratio_mon;
+ std::unique_ptr<PixelMon2DProfilesLW> m_misshits_ratio_tmp;
+ std::unique_ptr<PixelMon2DProfilesLW> m_misshits_ratio_mon;
/// hit efficiency
TProfile_LW* m_hiteff_incl_mod[PixLayerDisk::COUNT];
/// Lorentz Angle
@@ -441,7 +441,7 @@ private:
TH1F_LW* m_clustot_highpt;
TH1F_LW* m_1hitclustot_highpt;
TH1F_LW* m_2hitclustot_highpt;
- PixelMonModulesProf* m_tsos_hiteff_vs_lumi;
+ std::unique_ptr<PixelMonModulesProf> m_tsos_hiteff_vs_lumi;
///
@@ -469,9 +469,9 @@ private:
TH1F_LW* m_2cluster_Q_mod[PixLayer::COUNT];
TH1F_LW* m_3cluster_Q_mod[PixLayer::COUNT];
TH1F_LW* m_bigcluster_Q_mod[PixLayer::COUNT];
- PixelMon2DProfilesLW* m_clussize_map;
- PixelMon2DProfilesLW* m_cluscharge_map;
- PixelMon2DProfilesLW* m_clusToT_map;
+ std::unique_ptr<PixelMon2DProfilesLW> m_clussize_map;
+ std::unique_ptr<PixelMon2DProfilesLW> m_cluscharge_map;
+ std::unique_ptr<PixelMon2DProfilesLW> m_clusToT_map;
TH1F_LW* m_cluster_groupsize;
TH1F_LW* m_cluster_col_width;
TH1F_LW* m_cluster_row_width;
@@ -485,25 +485,25 @@ private:
TH2F_LW* m_ToT_vs_clussize_mod[PixLayer::COUNT];
TProfile_LW* m_clussize_vs_eta_mod[PixLayer::COUNT];
- PixelMon2DMapsLW* m_clustermap_mon;
- PixelMon2DMapsLW* m_clustermap_tmp;
- PixelMon2DMapsLW* m_cluster_occupancy;
+ std::unique_ptr<PixelMon2DMapsLW> m_clustermap_mon;
+ std::unique_ptr<PixelMon2DMapsLW> m_clustermap_tmp;
+ std::unique_ptr<PixelMon2DMapsLW> m_cluster_occupancy;
TH2F_LW* m_cluster_occupancy_FE_B0_mon;
TProfile* m_cluster_occupancy_time1;
TProfile* m_cluster_occupancy_time2;
TProfile* m_cluster_occupancy_time3;
- PixelMon2DMapsLW* m_clusocc_sizenot1;
- PixelMonModulesProf* m_cluseff_mod;
- PixelMonModules1D* m_cluster_ToT_mod;
- PixelMonModules1D* m_cluster_size_mod;
- PixelMonModules1D* m_cluster_num_mod;
+ std::unique_ptr<PixelMon2DMapsLW> m_clusocc_sizenot1;
+ std::unique_ptr<PixelMonModulesProf> m_cluseff_mod;
+ std::unique_ptr<PixelMonModules1D> m_cluster_ToT_mod;
+ std::unique_ptr<PixelMonModules1D> m_cluster_size_mod;
+ std::unique_ptr<PixelMonModules1D> m_cluster_num_mod;
TH1I_LW* m_num_clusters;
TProfile_LW* m_clusters_per_track_per_lumi_mod[PixLayer::COUNT];
TH1I_LW* m_num_clusters_mod[PixLayer::COUNT];
TH1F_LW* m_cluster_occupancy_summary_mod[PixLayer::COUNT];
- PixelMon2DProfilesLW* m_cluster_LVL1A_mod;
- PixelMon2DProfilesLW* m_clus_LVL1A_sizenot1;
+ std::unique_ptr<PixelMon2DProfilesLW> m_cluster_LVL1A_mod;
+ std::unique_ptr<PixelMon2DProfilesLW> m_clus_LVL1A_sizenot1;
TProfile_LW* m_clustersOnOffTrack_per_lumi;
/// Quick status
TH2F_LW* m_clusters_onTrack_L0_B11_S2_C6;
@@ -513,11 +513,11 @@ private:
///
///Status histograms
///
- PixelMonModules1D* m_Status_modules;
- PixelMon2DProfilesLW* m_status;
- PixelMon2DProfilesLW* m_status_mon;
- PixelMon2DProfilesLW* m_status_LB;
- PixelMon2DMapsLW* m_dqStatus;
+ std::unique_ptr<PixelMonModules1D> m_Status_modules;
+ std::unique_ptr<PixelMon2DProfilesLW> m_status;
+ std::unique_ptr<PixelMon2DProfilesLW> m_status_mon;
+ std::unique_ptr<PixelMon2DProfilesLW> m_status_LB;
+ std::unique_ptr<PixelMon2DMapsLW> m_dqStatus;
TProfile_LW* m_disabledModules_per_lumi_PIX;
TProfile_LW* m_badModules_per_lumi_mod[PixLayerIBL2D3D::COUNT];
TProfile_LW* m_disabledModules_per_lumi_mod[PixLayerIBL2D3D::COUNT];
@@ -531,8 +531,8 @@ private:
static const int kNumErrorStatesIBL{27};
TProfile_LW* m_errhist_errcat_LB[PixLayerIBL2D3D::COUNT][ErrorCategory::COUNT];
TProfile_LW* m_errhist_errtype_LB[PixLayerIBL2D3D::COUNT][ErrorCategoryMODROD::COUNT - 3];
- PixelMon2DMapsLW* m_errhist_errcat_map[ErrorCategory::COUNT];
- PixelMon2DMapsLW* m_errhist_errtype_map[ErrorCategoryMODROD::COUNT];
+ std::unique_ptr<PixelMon2DMapsLW> m_errhist_errcat_map[ErrorCategory::COUNT];
+ std::unique_ptr<PixelMon2DMapsLW> m_errhist_errtype_map[ErrorCategoryMODROD::COUNT];
TProfile_LW* m_errhist_errcat_avg[ErrorCategory::COUNT][PixLayerIBL2D3D::COUNT];
TProfile_LW* m_errhist_errtype_avg[ErrorCategoryMODROD::COUNT - 3][PixLayerIBL2D3D::COUNT];
TProfile_LW* m_errhist_tot_LB[PixLayerIBL2D3D::COUNT];
@@ -542,12 +542,12 @@ private:
TProfile* m_error_time1;
TProfile* m_error_time2;
TProfile* m_error_time3;
- PixelMonModules1D* m_errors;
- PixelMon2DProfilesLW* m_errhist_femcc_errwords_map;
+ std::unique_ptr<PixelMonModules1D> m_errors;
+ std::unique_ptr<PixelMon2DProfilesLW> m_errhist_femcc_errwords_map;
// Histograms in 'ErrorsExpert' folder
- PixelMon2DLumiMaps* m_errhist_expert_LB_maps[kNumErrorStates + kNumErrorStatesIBL];
- PixelMon2DMapsLW* m_errhist_expert_maps[kNumErrorStates + kNumErrorStatesIBL];
+ std::unique_ptr<PixelMon2DLumiMaps> m_errhist_expert_LB_maps[kNumErrorStates + kNumErrorStatesIBL];
+ std::unique_ptr<PixelMon2DMapsLW> m_errhist_expert_maps[kNumErrorStates + kNumErrorStatesIBL];
TProfile_LW* m_errhist_expert_LB[PixLayer::COUNT-1][kNumErrorStates];
TProfile_LW* m_errhist_expert_IBL_LB[kNumErrorStatesIBL];
TH3F* m_errhist_expert_fe_trunc_err_3d[PixLayer::COUNT];
@@ -556,9 +556,9 @@ private:
TH1F_LW* m_errhist_expert_servrec_ibl_count;
// Histograms in low-stat folder
- PixelMon2DMapsLW* m_errors_LB;
- PixelMon2DMapsLW* m_errors_RODSync_mod;
- PixelMon2DMapsLW* m_errors_ModSync_mod;
+ std::unique_ptr<PixelMon2DMapsLW> m_errors_LB;
+ std::unique_ptr<PixelMon2DMapsLW> m_errors_RODSync_mod;
+ std::unique_ptr<PixelMon2DMapsLW> m_errors_ModSync_mod;
///
/// SP Histograms
@@ -574,10 +574,10 @@ private:
TH2F_LW* m_spHit_rz;
//Histograms stored for certain number of LB at a time
- PixelMon2DMapsLW* m_cluster_occupancy_LB; //cluster occupancy (shows module status)
- PixelMonModules1D* m_cluster_ToT_mod_LB;
- PixelMonModules1D* m_cluster_num_mod_LB;
- PixelMonModules1D* m_hit_num_mod_LB;
+ std::unique_ptr<PixelMon2DMapsLW> m_cluster_occupancy_LB; //cluster occupancy (shows module status)
+ std::unique_ptr<PixelMonModules1D> m_cluster_ToT_mod_LB;
+ std::unique_ptr<PixelMonModules1D> m_cluster_num_mod_LB;
+ std::unique_ptr<PixelMonModules1D> m_hit_num_mod_LB;
TH1I_LW* m_num_hits_LB;
TH1F_LW* m_hit_ToT_LB_mod[PixLayer::COUNT];
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiMaps.h b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiMaps.h
index bef854c508c0248e8723962a9668fff89e08dddf..ecd0bcc8e4ed7d8ecb2a7a9f3268890a595e105b 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiMaps.h
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiMaps.h
@@ -4,50 +4,51 @@
#ifndef PIXELMON2DLUMIMAPS_H_
#define PIXELMON2DLUMIMAPS_H_
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include <array>
-#include <string.h>
+#include "PixelMonitoring/HolderTemplate.h"
+class string;
class TH2F_LW;
class Identifier;
class PixelID;
class StatusCode;
+namespace PixMon { enum class HistConf; }
-namespace PixMon {
-enum class HistConf;
-}
+/**
+ * PixelMon2DLumiMaps histogram holder class
+ * --> Base type: 2D Maps (TH2F_LW)
+ * --> Supports: IBL
+ * B0, B1, B2
+ * ECA/C
+ * DBMA/C
+ *
+ * Collection of 2D pixel component maps, based on the TH2F_LW histogram class.
+ * The initialisation of the components is controlled by the HistConf object.
+ * The fill method will take the identifier as the input and fill the correct
+ * histogram and bin. The histograms are also public so that they can be
+ * formatted/accessed like any other histograms in the monitoring.
+ *
+ * N.B. Currently no support for IBL2D/3D histograms. Should this be added?
+ * Also, if the histogram configuration contains unsupported histograms, this is
+ * completely ignored. Should we do anything against it?
+ */
+class PixelMon2DLumiMaps : public PixMon::HolderTemplate<TH2F_LW> {
+ public:
+ //! Constructor for 2D lumi objects
+ PixelMon2DLumiMaps(std::string name, std::string title, std::string zlabel, const PixMon::HistConf& config);
-// A helper class to remove a lot of the code duplication.
-// This is a collection of 6 2D histograms which make up the '2D luminosity maps' used a lot of in the monitoring.
-// Each of the 2D maps correspond to a detector region (IBL, B0, B1, B2, ECA, ECC).
-// This books and formats the histograms in the constructor. The fill method will take the identifier
-// as the input and fill the correct histogram and bin. The histograms are also public so that they
-// can be formated/accessed like any other histograms in the monitoring.
-//
-// N.B. Currently no support for IBL2D/3D histograms as well as DBM monitoring. Should this be added?
-// Also, if the histogram configuration contains unsupported histograms, this is completely ignored.
-// Should we do anything against it?
-
-class PixelMon2DLumiMaps
-{
- public:
- PixelMon2DLumiMaps(std::string name, std::string title, std::string zlabel, const PixMon::HistConf& config);
- ~PixelMon2DLumiMaps();
- TH2F_LW* IBLlbm;
- TH2F_LW* B0lbm;
- TH2F_LW* B1lbm;
- TH2F_LW* B2lbm;
- TH2F_LW* Albm;
- TH2F_LW* Clbm;
- TH2F_LW* DBMAlbm;
- TH2F_LW* DBMClbm;
- void Fill(double LB,Identifier &id, const PixelID* pixID, double weight = 1);
- StatusCode regHist(ManagedMonitorToolBase::MonGroup &group);
-private:
- void formatHist();
- std::array<TH2F_LW*, 10> m_histograms;
- const PixMon::HistConf m_config;
- static const bool m_doIBL;
+ /**
+ * Standard method to fill the histograms of this container.
+ *
+ * @param LB: the luminosity block number
+ * @param id: the identifier of the pixel unit
+ * @param pixID: instance of the class which translates the above ID
+ * into readable info (e.g. eta/phi module index)
+ * @param weight: optional weighting factor
+ */
+ void Fill(double LB, Identifier &id, const PixelID* pixID, float weight = 1.0);
+
+ //! Formatting function for histograms (reimplemented from template)
+ virtual void formatHist() override;
};
-#endif
+#endif // PIXELMON2DLUMIMAPS_H_
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiProfiles.h b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiProfiles.h
index 83925fdbcc42ef6ae5f2b7b36d6e46de226ac128..a5cef713cdeb5abfcf463f2b448551129b985b68 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiProfiles.h
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DLumiProfiles.h
@@ -4,50 +4,52 @@
#ifndef PIXELMON2DLUMIPROFILES_H_
#define PIXELMON2DLUMIPROFILES_H_
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include <array>
-#include <string.h>
+#include "PixelMonitoring/HolderTemplate.h"
+class string;
class TProfile2D_LW;
class Identifier;
class PixelID;
class StatusCode;
+namespace PixMon { enum class HistConf; }
-namespace PixMon {
-enum class HistConf;
-}
+/**
+ * PixelMon2DMapsLW histogram holder class
+ * --> Base type: 2D Profiles (TProfile2D_LW)
+ * --> Supports: IBL
+ * IBL 2D/3D
+ * B0, B1, B2
+ * ECA/C
+ * DBMA/C
+ *
+ * Collection of 2D pixel component maps, based on the TH2F_LW histogram class.
+ * The initialisation of the components is controlled by the HistConf object.
+ * The fill method will take the identifier as the input and fill the correct
+ * histogram and bin. The histograms are also public so that they can be
+ * formatted/accessed like any other histograms in the monitoring.
+ *
+ * N.B. Currently no support for IBL2D/3D histograms. Should this be added?
+ * Also, if the histogram configuration contains unsupported histograms, this is
+ * completely ignored. Should we do anything against it?
+ */
+class PixelMon2DLumiProfiles : public PixMon::HolderTemplate<TProfile2D_LW> {
+ public:
+ //! Constructor for 2D lumi profiles
+ PixelMon2DLumiProfiles(std::string name, std::string title, std::string zlabel, const PixMon::HistConf& config);
-// A helper class to remove a lot of the code duplication.
-// This is a collection of 6 2D histograms which make up the '2D lumi profiles' used a lot of in the monitoring.
-// Each of the 2D maps correspond to a detector region (IBL, B0, B1, B2, ECA, ECC).
-// This books and formats the histograms in the constructor. The fill method will take the identifier
-// as the input and fill the correct histogram and bin. The histograms are also public so that they
-// can be formated/accessed like any other histograms in the monitoring.
-//
-// N.B. Currently no support for IBL2D/3D histograms as well as DBM monitoring. Should this be added?
-// Also, if the histogram configuration contains unsupported histograms, this is completely ignored.
-// Should we do anything against it?
+ /**
+ * Standard method to fill the histograms of this container.
+ *
+ * @param LB: the luminosity block number
+ * @param id: the identifier of the pixel unit
+ * @param pixID: instance of the class which translates the above ID
+ * into readable info (e.g. eta/phi module index)
+ * @param weight: optional weighting factor
+ */
+ void Fill(double LB, Identifier &id, const PixelID* pixID, double weight = 1.0);
-class PixelMon2DLumiProfiles
-{
- public:
- PixelMon2DLumiProfiles(std::string name, std::string title, std::string zlabel, const PixMon::HistConf& config);
- ~PixelMon2DLumiProfiles();
- TProfile2D_LW* IBLlbp;
- TProfile2D_LW* B0lbp;
- TProfile2D_LW* B1lbp;
- TProfile2D_LW* B2lbp;
- TProfile2D_LW* Albp;
- TProfile2D_LW* Clbp;
- TProfile2D_LW* DBMAlbp;
- TProfile2D_LW* DBMClbp;
- void Fill(double LB, Identifier &id, const PixelID* pixID, double weight = 1);
- StatusCode regHist(ManagedMonitorToolBase::MonGroup &group);
-private:
- void formatHist();
- std::array<TProfile2D_LW*, 10> m_histograms;
- const PixMon::HistConf m_config;
- static const bool m_doIBL;
+ //! Formatting function for histograms (reimplemented from template)
+ void formatHist();
};
-#endif
+#endif // PIXELMON2DLUMIPROFILES_H_
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DMapsLW.h b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DMapsLW.h
index 1edcf7452fb12a1832dddc779d36d65549998f7a..f0c81cc8b73fa82edb6718af5df5e8781c82563c 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DMapsLW.h
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DMapsLW.h
@@ -4,51 +4,53 @@
#ifndef PIXELMON2DMAPSLW_H_
#define PIXELMON2DMAPSLW_H_
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include <array>
-#include <string.h>
+#include "PixelMonitoring/HolderTemplate.h"
+class string;
class TH2F_LW;
class Identifier;
class PixelID;
class StatusCode;
-namespace PixMon {
-enum class HistConf;
-}
-
-// A helper class to remove a lot of the code duplication.
-// This is a collection of 5 2D histograms which make up the '2D mapsLW' used a lot of in the monitoring.
-// Each of the 2D mapsLW correspond to a detector region (B0, B1, B2, ECA, ECC).
-// This books and formats the histograms in the constructor. The fill method will take the identifier
-// as the input and fill the correct histogram and bin. The histograms are also public so that they
-// can be formated/accessed like any other histograms in the monitoring.
-
-class PixelMon2DMapsLW
-{
- public:
- PixelMon2DMapsLW(std::string name, std::string title, const PixMon::HistConf& config, bool copy2DFEval = false);
- ~PixelMon2DMapsLW();
- TH2F_LW* IBL;
- TH2F_LW* IBL2D;
- TH2F_LW* IBL3D;
- TH2F_LW* B0;
- TH2F_LW* B1;
- TH2F_LW* B2;
- TH2F_LW* A;
- TH2F_LW* C;
- TH2F_LW* DBMA;
- TH2F_LW* DBMC;
- void Fill(Identifier &id, const PixelID* pixID);
- void WeightingFill(Identifier &id, const PixelID* pixID, float weight);
- void Fill2DMon(PixelMon2DMapsLW* oldmap);
- StatusCode regHist(ManagedMonitorToolBase::MonGroup &group);
-private:
- friend class PixelMon2DProfilesLW;
- void formatHist();
- std::array<TH2F_LW*, 10> m_histograms;
- const PixMon::HistConf m_config;
- static const bool m_doIBL;
- const bool m_copy2DFEval;
+namespace PixMon { enum class HistConf; }
+
+/**
+ * PixelMon2DMapsLW histogram holder class
+ * --> Base type: 2D Maps (TH2F_LW)
+ * --> Supports: IBL
+ * IBL 2D/3D
+ * B0, B1, B2
+ * ECA/C
+ * DBMA/C
+ *
+ * Collection of 2D pixel component maps, based on the TH2F_LW histogram class.
+ * The initialisation of the components is controlled by the HistConf object.
+ * The fill method will take the identifier as the input and fill the correct
+ * histogram and bin. The histograms are also public so that they can be
+ * formatted/accessed like any other histograms in the monitoring.
+ */
+class PixelMon2DMapsLW : public PixMon::HolderTemplate<TH2F_LW> {
+ public:
+ //! Constructor for 2D map objects
+ PixelMon2DMapsLW(std::string name, std::string title, const PixMon::HistConf& config, bool copy2DFEval = false);
+
+ /**
+ * Standard method to fill the histograms of this container.
+ *
+ * @param id: the identifier of the pixel unit
+ * @param pixID: instance of the class which translates the above ID
+ * into readable info (e.g. eta/phi module index)
+ * @param weight: optional weighting factor
+ */
+ void Fill(Identifier &id, const PixelID* pixID, float weight = 1.0);
+
+ //! Fill method which takes values from another map
+ void Fill2DMon(PixelMon2DMapsLW* oldmap);
+
+ //! Formatting function for histograms (reimplemented from template)
+ virtual void formatHist() override;
+
+ protected:
+ friend class PixelMon2DProfilesLW;
};
-#endif
+#endif // PIXELMON2DMAPSLW_H_
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DProfilesLW.h b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DProfilesLW.h
index 83cffbcc8d6d25cb10a3193f0e251dfef35cbe8d..f8772336fe96b63c912901c080cce8f9fd444763 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DProfilesLW.h
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMon2DProfilesLW.h
@@ -4,53 +4,60 @@
#ifndef PIXELMON2DPROFILESLW_H_
#define PIXELMON2DPROFILESLW_H_
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include <string.h>
+#include "PixelMonitoring/HolderTemplate.h"
+class string;
class TProfile2D_LW;
class Identifier;
class PixelID;
class StatusCode;
+namespace PixMon { enum class HistConf; }
class PixelMon2DMapsLW;
-namespace PixMon {
-enum class HistConf;
-}
-
-// A helper class to facilitate definition of per-layer 2D profile maps.
-// It defines a collection of TProfile2D_LW histograms for each pixel layer, which then can be declared or
-// filled in a single call.
-// This books and formats the histograms in the constructor. The fill method will take the identifier
-// as the input and fill the correct histogram and bin. The histograms are also public so that they
-// can be formated/accessed like any other histograms in the monitoring.
-
-class PixelMon2DProfilesLW
-{
+/**
+ * PixelMon2DProfilesLW histogram holder class
+ * --> Base type: 2D Profiles (TProfile2D_LW)
+ * --> Supports: IBL
+ * IBL 2D/3D
+ * B0, B1, B2
+ * ECA/C
+ * DBMA/C
+ *
+ * Collection of 2D pixel component maps, based on the TH2F_LW histogram class.
+ * The initialisation of the components is controlled by the HistConf object.
+ * The fill method will take the identifier as the input and fill the correct
+ * histogram and bin. The histograms are also public so that they can be
+ * formatted/accessed like any other histograms in the monitoring.
+ */
+class PixelMon2DProfilesLW : public PixMon::HolderTemplate<TProfile2D_LW> {
public:
+ //! Constructor for 2D map profiles
PixelMon2DProfilesLW(std::string name, std::string title, const PixMon::HistConf& config, bool copy2DFEval = false);
- ~PixelMon2DProfilesLW();
- TProfile2D_LW* IBL3D;
- TProfile2D_LW* IBL2D;
- TProfile2D_LW* IBL;
- TProfile2D_LW* B0;
- TProfile2D_LW* B1;
- TProfile2D_LW* B2;
- TProfile2D_LW* A;
- TProfile2D_LW* C;
- TProfile2D_LW* DBMA;
- TProfile2D_LW* DBMC;
+
+ /**
+ * Standard method to fill the histograms of this container.
+ *
+ * @param id: the identifier of the pixel unit
+ * @param pixID: instance of the class which translates the above ID
+ * into readable info (e.g. eta/phi module index)
+ * @param value: the fill value
+ */
void Fill(Identifier &id, const PixelID* pixID, float value);
+
+ //! Fill method which takes values from another 2D profile
void Fill2DMon(PixelMon2DProfilesLW* oldmap);
+
+ //! Fill method which takes values from a 2D map object
void FillFromMap(PixelMon2DMapsLW* inputmap, bool clear_inputmap);
+
+ //! Set maximal value of the 2D profile bins
void SetMaxValue(float max);
+
+ //! Reset the 2D profiles
void Reset();
- StatusCode regHist(ManagedMonitorToolBase::MonGroup &group);
-private:
- void formatHist();
- std::array<TProfile2D_LW*, 10> m_histograms;
- const PixMon::HistConf m_config;
- static const bool m_doIBL;
- const bool m_copy2DFEval;
+
+ //! Formatting function for histograms (reimplemented from template)
+ virtual void formatHist() override;
};
-#endif
+#endif // PIXELMON2DPROFILESLW_H_
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMonModules.h b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMonModules.h
index a7677590ec814b220393aad5322c46750975e21b..26e416271eaf5f44fdcd38aec9868b24c433d2a6 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMonModules.h
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/PixelMonitoring/PixelMonModules.h
@@ -25,7 +25,6 @@ class PixelMonModules
{
public:
//PixelMonModules();
- virtual ~PixelMonModules() = 0;
virtual void formatHist(std::string) = 0; //pass the bin labels here if needed
virtual void Reset() = 0;
virtual StatusCode regHist(ManagedMonitorToolBase* thisptr, std::string path, ManagedMonitorToolBase::Interval_t Run) = 0;
@@ -40,7 +39,6 @@ class PixelMonModules1D : public PixelMonModules
public:
PixelMonModules1D(std::string name, std::string title, int nbins, double low, double high);
PixelMonModules1D(std::string name, std::string title, int nbins, double *arr);
- virtual ~PixelMonModules1D();
StatusCode regHist(ManagedMonitorToolBase* thisptr, std::string path, ManagedMonitorToolBase::Interval_t Run);
TH1F* IBL[20][14];
TH1F* B0[13][22];
@@ -63,7 +61,6 @@ class PixelMonModulesProf : public PixelMonModules
public:
PixelMonModulesProf(std::string name, std::string title, int nbins, double low, double high);
PixelMonModulesProf(std::string name, std::string title, int nbins, double *arr);
- virtual ~PixelMonModulesProf();
StatusCode regHist(ManagedMonitorToolBase* thisptr, std::string path, ManagedMonitorToolBase::Interval_t Run);
TProfile_LW* IBL[20][14];
TProfile_LW* B0[13][22];
@@ -84,7 +81,6 @@ class PixelMonModules2D : public PixelMonModules
{
public:
PixelMonModules2D(std::string name, std::string title, int nbins0, double low0, double high0,int nbins1, double low1, double high1);
- virtual ~PixelMonModules2D();
StatusCode regHist(ManagedMonitorToolBase* thisptr, std::string path, ManagedMonitorToolBase::Interval_t Run);
TH2F* IBL[20][14];
TH2F* B0[13][22];
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Clusters.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Clusters.cxx
index 5cca08c061e423f20467a966c86a2f4abf3825cd..9a1e7101eb5b57ea2ddebffdf8435fcce9fc458c 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Clusters.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Clusters.cxx
@@ -60,7 +60,7 @@ StatusCode PixelMainMon::BookClustersMon(void)
int nbins_eta = 13; double min_eta = -6.5; double max_eta = min_eta + (1.0*nbins_eta);
int nbins_tot = 300; double min_tot = -0.5; double max_tot = min_tot + (1.0*nbins_tot);
int nbins_ibl_tot = 150; double min_ibl_tot = -0.5; double max_ibl_tot = min_tot + (1.0*nbins_tot);
- int nbins_Q = 140; double min_Q = -0.5; double max_Q = min_Q + (1500.0*nbins_Q);
+ int nbins_Q = 70; double min_Q = -0.5; double max_Q = min_Q + (3000.0*nbins_Q);
int nbins_lvl1 = 14; double min_lvl1 = -1.5; double max_lvl1 = min_lvl1 + (1.0*nbins_lvl1);
std::string atext_LB = ";lumi block";
std::string atext_BCID = ";BCID";
@@ -248,41 +248,41 @@ StatusCode PixelMainMon::BookClustersMon(void)
if (m_do2DMaps)
{
tmp = "Cluster_Occupancy"; tmp2 = "Cluster occupancy";
- m_cluster_occupancy = new PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_cluster_occupancy = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_cluster_occupancy->regHist(clusterShift);
tmp = "Cluster_LVL1A_Mod"; tmp2 = "Average cluster Level 1 Accept";
- m_cluster_LVL1A_mod = new PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_cluster_LVL1A_mod = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_cluster_LVL1A_mod->regHist(timeShift);
tmp = "Clus_Occ_SizeCut"; tmp2 = "Size>1 Cluster occupancy";
- m_clusocc_sizenot1 = new PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_clusocc_sizenot1 = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_clusocc_sizenot1->regHist(clusterShift);
tmp = "Clus_LVL1A_SizeCut"; tmp2 = "Average Size>1 Cluster Level 1 Accept";
- m_clus_LVL1A_sizenot1 = new PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_clus_LVL1A_sizenot1 = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_clus_LVL1A_sizenot1->regHist(timeShift);
if (m_doOnline){
tmp = "ClusterMap_Mon"; tmp2 = "Cluster map for monitoring";
- m_clustermap_mon = new PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_clustermap_mon = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_clustermap_mon->regHist(clusterShift);
tmp = "ClusterMap_tmp"; tmp2 = "Cluster map for monitoring";
- m_clustermap_tmp = new PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_clustermap_tmp = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_clustermap_tmp->regHist(clusterShift);
}
if (!m_doOnline){
tmp = "Cluster_Size_Map"; tmp2 = "Average cluster size map";
- m_clussize_map = new PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_clussize_map = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_clussize_map->regHist(clusterExpert);
tmp = "Cluster_Charge_Map"; tmp2 = "Average cluster charge map";
- m_cluscharge_map = new PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_cluscharge_map = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_cluscharge_map->regHist(clusterExpert);
tmp = "Cluster_ToT_Map"; tmp2 = "Average cluster ToT map";
- m_clusToT_map = new PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_clusToT_map = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW(tmp.c_str(), (tmp2 + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_clusToT_map->regHist(clusterExpert);
@@ -315,16 +315,16 @@ StatusCode PixelMainMon::BookClustersMon(void)
if (m_doModules && m_doOnTrack)
{
- m_cluseff_mod = new PixelMonModulesProf("Clus_track_eff", ("Proportion of clusters on track vs t in module" + m_histTitleExt).c_str(), 2500,-0.5,2499.5);
+ m_cluseff_mod = std::make_unique<PixelMonModulesProf>(PixelMonModulesProf("Clus_track_eff", ("Proportion of clusters on track vs t in module" + m_histTitleExt).c_str(), 2500,-0.5,2499.5));
sc = m_cluseff_mod->regHist(this,(path+"/Modules_Cluseff").c_str(),run);
- m_cluster_size_mod = new PixelMonModules1D("Cluster_size", ("Cluster size in Module" + m_histTitleExt).c_str(), 20,-0.5,19.5);
+ m_cluster_size_mod = std::make_unique<PixelMonModules1D>(PixelMonModules1D("Cluster_size", ("Cluster size in Module" + m_histTitleExt).c_str(), 20,-0.5,19.5));
sc = m_cluster_size_mod->regHist(this,(path+"/Modules_ClusterSize").c_str(),run);
- m_cluster_num_mod = new PixelMonModules1D("Cluster_num", ("Number of clusters per event in module" + m_histTitleExt).c_str(), 30,-0.5,29.5);
+ m_cluster_num_mod = std::make_unique<PixelMonModules1D>(PixelMonModules1D("Cluster_num", ("Number of clusters per event in module" + m_histTitleExt).c_str(), 30,-0.5,29.5));
sc = m_cluster_num_mod->regHist(this,(path+"/Modules_NumberOfClusters").c_str(),run);
- m_cluster_ToT_mod = new PixelMonModules1D("Cluster_ToT", ("Cluster ToT in Module" + m_histTitleExt).c_str(), 200,0.,200.);
+ m_cluster_ToT_mod = std::make_unique<PixelMonModules1D>(PixelMonModules1D("Cluster_ToT", ("Cluster ToT in Module" + m_histTitleExt).c_str(), 200,0.,200.));
sc = m_cluster_ToT_mod->regHist(this,(path+"/Modules_ClusToT").c_str(),run);
}
if (m_doOnline)
@@ -407,7 +407,7 @@ StatusCode PixelMainMon::BookClustersLumiBlockMon(void)
sc = lumiBlockHist.regHist(m_cluster_ToT_LB = TH1F_LW::create("Cluster_ToT_LB", ("Cluster Time over Threshold" + m_histTitleExt + ";ToT;# clusters").c_str(), 300,-0.5,299.5));
if (m_do2DMaps) {
- m_cluster_occupancy_LB = new PixelMon2DMapsLW("Cluster_Occupancy_LB", ("Cluster Occupancy" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_cluster_occupancy_LB = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Cluster_Occupancy_LB", ("Cluster Occupancy" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_cluster_occupancy_LB->regHist(lumiBlockHist);
}
if (m_doLowOccupancy || m_doHighOccupancy) {
@@ -417,9 +417,9 @@ StatusCode PixelMainMon::BookClustersLumiBlockMon(void)
}
if (m_doModules && m_doOnTrack) { // normally not booked, as doModules is online, doLumiBlock is offline
- m_cluster_num_mod_LB = new PixelMonModules1D("Cluster_num_LB", ("Number of clusters per event in module" + m_histTitleExt).c_str(), 20,-0.5,59.5);
+ m_cluster_num_mod_LB = std::make_unique<PixelMonModules1D>(PixelMonModules1D("Cluster_num_LB", ("Number of clusters per event in module" + m_histTitleExt).c_str(), 20,-0.5,59.5));
sc = m_cluster_num_mod_LB->regHist(this,(path+"/Modules_NumberOfClusters").c_str(),lowStat);
- m_cluster_ToT_mod_LB = new PixelMonModules1D("Cluster_ToT_mod_LB", ("Cluster ToT in Module" + m_histTitleExt).c_str(), 75,0.,300.);
+ m_cluster_ToT_mod_LB = std::make_unique<PixelMonModules1D>(PixelMonModules1D("Cluster_ToT_mod_LB", ("Cluster ToT in Module" + m_histTitleExt).c_str(), 75,0.,300.));
sc = m_cluster_ToT_mod_LB->regHist(this,(path+"/Modules_ClusToT").c_str(),lowStat);
}
@@ -693,7 +693,7 @@ StatusCode PixelMainMon::FillClustersMon(void)
//////////////////////Fill after event block////////////////
if (m_doOnline)//should we fill these mid run or only at the end?
{
- FillSummaryHistos(m_cluster_occupancy,
+ FillSummaryHistos(m_cluster_occupancy.get(),
m_cluster_occupancy_summary_mod[PixLayer::kECA],
m_cluster_occupancy_summary_mod[PixLayer::kECC],
m_cluster_occupancy_summary_mod[PixLayer::kIBL],
@@ -701,7 +701,7 @@ StatusCode PixelMainMon::FillClustersMon(void)
m_cluster_occupancy_summary_mod[PixLayer::kB1],
m_cluster_occupancy_summary_mod[PixLayer::kB2]);
if (m_doRefresh) {
- if (m_clustermap_mon && m_clustermap_tmp) m_clustermap_mon->Fill2DMon(m_clustermap_tmp);
+ if (m_clustermap_mon && m_clustermap_tmp) m_clustermap_mon->Fill2DMon(m_clustermap_tmp.get());
}
}
@@ -777,7 +777,7 @@ StatusCode PixelMainMon::ProcClustersMon(void)
{
if (m_doOffline)
{
- FillSummaryHistos(m_cluster_occupancy,
+ FillSummaryHistos(m_cluster_occupancy.get(),
m_cluster_occupancy_summary_mod[PixLayer::kECA],
m_cluster_occupancy_summary_mod[PixLayer::kECC],
m_cluster_occupancy_summary_mod[PixLayer::kIBL],
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Errors.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Errors.cxx
index cf2ab68095ab8c454196c618a95e53b6392c0c3f..481a1ca0e03b1ca573336c4d9b43f2cbc4dd46f7 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Errors.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Errors.cxx
@@ -47,22 +47,22 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
MonGroup rodExpert(this, path2.c_str(), run, ATTRIB_MANAGED); //declare a group of histograms
const std::array <std::pair <std::string, std::string>, kNumErrorStates > error_state_labels = {{
- std::make_pair("Mod_Sync_BCID1_errors", "Synchronization Module BCID1 errors"),
- std::make_pair("Mod_Sync_BCID2_errors", "Synchronization Module BCID2 errors"),
- std::make_pair("Mod_Sync_LVL1ID_errors", "Synchronization Module LVL1ID errors"),
- std::make_pair("ROD_Sync_BCID_errors", "Synchronization ROD BCID errors"),
- std::make_pair("ROD_Sync_LVL1ID_errors", "Synchronization ROD LVL1ID errors"),
- std::make_pair("Mod_Trunc_EOC_errors", "Truncation Module EOC errors"),
- std::make_pair("Mod_Trunc_Hit_Overflow_errors", "Truncation Module Hit Overflow errors"),
- std::make_pair("Mod_Trunc_EoE_Overflow_errors", "Truncation Module EoE Overflow errors"),
- std::make_pair("ROD_Trunc_HT_Limit_errors", "Truncation ROD H/T Limit errors"),
- std::make_pair("ROD_Trunc_ROD_OF_errors", "Truncation ROD Overflow errors"),
- std::make_pair("Optical_Errors", "Preamble/header Errors"),
- std::make_pair("SEU_Hit_Parity", "SEU Hit Parity errors"),
- std::make_pair("SEU_Register_Parity", "SEU Register Parity errors"),
- std::make_pair("SEU_Hamming", "SEU Hamming Code errors"),
- std::make_pair("ROD_Timeout", "ROD Formatter Timeout errors"),
- std::make_pair("FE_Warning", "FE Warning errors"),
+ std::make_pair("Mod_Sync_BCID1_errors", "FE/MCC BCID1 Sync Errors"),
+ std::make_pair("Mod_Sync_BCID2_errors", "FE/MCC BCID2 Sync Errors"),
+ std::make_pair("Mod_Sync_LVL1ID_errors", "FE/MCC LVL1ID Sync Errors"),
+ std::make_pair("ROD_Sync_BCID_errors", "ROD BCID Sync Errors"),
+ std::make_pair("ROD_Sync_LVL1ID_errors", "ROD LVL1ID Sync Errors"),
+ std::make_pair("Mod_Trunc_EOC_errors", "FE/MCC EoC Trunc Errors"),
+ std::make_pair("Mod_Trunc_Hit_Overflow_errors", "FE/MCC Hit Overflow Trunc Errors"),
+ std::make_pair("Mod_Trunc_EoE_Overflow_errors", "FE/MCC EoE Overflow Trunc Errors"),
+ std::make_pair("ROD_Trunc_HT_Limit_errors", "ROD H/T Limit Trunc Errors"),
+ std::make_pair("ROD_Trunc_ROD_OF_errors", "ROD Overflow Trunc Errors"),
+ std::make_pair("Optical_Errors", "Preamble/Header Errors"),
+ std::make_pair("SEU_Hit_Parity", "SEU Hit Parity Errors"),
+ std::make_pair("SEU_Register_Parity", "SEU Register Parity Errors"),
+ std::make_pair("SEU_Hamming", "SEU Hamming Code Errors"),
+ std::make_pair("ROD_Timeout", "ROD Formatter Timeout Errors"),
+ std::make_pair("FE_Warning", "FE Warning Errors"),
}};
std::array <std::pair <std::string, std::string>, kNumErrorStatesIBL > error_state_labelsIBL = {{
@@ -96,14 +96,14 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
}};
const char * errorBitsPIX[kNumErrorBits] = {
- "ROD Trunc FIFO Overflow", "ROD Trunc H/T Limit", "2", "3",
- "Module Trunc EoC", "SEU Hit Parity", "SEU Reg Parity", "SEU Hamming Code",
- "FE Warning (Bit Flip)", "9", "10", "11",
- "Module Trunc Hit Overflow", "Module Trunc EoE Overflow", "Module Sync BCID1", "Module Sync BCID2",
- "Module Sync LVL1ID", "17", "18", "19",
- "ROD Sync BCID", "ROD Sync LVL1ID", "Timeout", "Optical",
- "24", "25", "26", "27",
- "28", "29", "30", "31"
+ "ROD Overflow Trunc", "ROD H/T Limit Trunc", "2", "3",
+ "FE/MCC EoC Trunc", "SEU Hit Parity", "SEU Register Parity", "SEU Hamming Code",
+ "FE Warning (Bit Flip)", "9", "10", "11",
+ "FE/MCC Hit Overflow Trunc", "FE/MCC EoE Overflow Trunc", "FE/MCC BCID1 Sync", "FE/MCC BCID2 Sync",
+ "FE/MCC LVL1ID Sync", "17", "18", "19",
+ "ROD BCID Sync", "ROD LVL1ID Sync", "ROD Formatter Timeout", "Preamble/Header",
+ "24", "25", "26", "27",
+ "28", "29", "30", "31"
};
const char* errorBitsIBL[kNumErrorBits] = {
@@ -118,21 +118,21 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
};
const std::array <std::pair <std::string, std::string>, ErrorCategoryMODROD::COUNT> error_type_labels = {{
- std::make_pair("SyncErrors_Mod", "SyncErrors_Mod"),
- std::make_pair("SyncErrors_ROD", "SyncErrors_ROD"),
- std::make_pair("TruncErrors_Mod", "TruncErrors_Mod"),
- std::make_pair("TruncErrors_ROD", "TruncErrors_ROD"),
- std::make_pair("OpticalErrors_RODMod", "Preamble/headerErrors"),
- std::make_pair("SEUErrors_RODMod", "SEUErrors"),
- std::make_pair("TimeoutErrors_RODMod", "TimeoutErrors"),
+ std::make_pair("SyncErrors_Mod", "FE/MCC Sync Errors"),
+ std::make_pair("SyncErrors_ROD", "ROD Sync Errors"),
+ std::make_pair("TruncErrors_Mod", "FE/MCC Trunc Errors"),
+ std::make_pair("TruncErrors_ROD", "ROD Trunc Errors"),
+ std::make_pair("OpticalErrors_RODMod", "Preamble/Header Errors"),
+ std::make_pair("SEUErrors_RODMod", "SEU Errors"),
+ std::make_pair("TimeoutErrors_RODMod", "Timeout Errors"),
}};
const std::array <std::pair <std::string, std::string>, ErrorCategory::COUNT> error_cat_labels = {{
- std::make_pair("SyncErrors", "SyncErrors"),
- std::make_pair("TruncErrors", "TruncErrors"),
- std::make_pair("OpticalErrors", "Preamble/headerErrors"),
- std::make_pair("SEUErrors", "SEUErrors"),
- std::make_pair("TimeoutErrors", "TimeoutErrors"),
+ std::make_pair("SyncErrors", "Sync Errors (FE/MCC & ROD)"),
+ std::make_pair("TruncErrors", "Trunc Errors (FE/MCC & ROD)"),
+ std::make_pair("OpticalErrors", "Preamble/Header Errors"),
+ std::make_pair("SEUErrors", "SEU Errors"),
+ std::make_pair("TimeoutErrors", "Timeout Errors"),
}};
const std::string modlabel2[PixLayerIBL2D3D::COUNT] = {"ECA", "ECC", "B0", "B1", "B2", "IBL", "IBL2D", "IBL3D"};
@@ -142,8 +142,8 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
std::string atext_LB = ";lumi block";
std::string atext_err = ";# errors/event";
std::string atext_erf = ";# errors/module/event";
- std::string atext_erb = ";Error bit";
- std::string atext_ers = ";Error state";
+ std::string atext_erb = ";error bit";
+ std::string atext_ers = ";error type";
int nbins_LB = m_lbRange; float minbin_LB = -0.5; float maxbin_LB = minbin_LB + (1.0*nbins_LB);
std::string hname;
std::string htitles;
@@ -168,16 +168,16 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
}
hname = makeHistname(("errors_per_lumi_"+modlabel2[i]), false);
- htitles = makeHisttitle(("Average number of errors per event, "+modlabel2[i]), (atext_LB+atext_err), false);
+ htitles = makeHisttitle(("Average Total Errors, "+modlabel2[i]), (atext_LB+atext_err), false);
sc = rodHistos.regHist(m_errhist_tot_LB[i] = TProfile_LW::create(hname.c_str(), htitles.c_str(), nbins_LB, minbin_LB, maxbin_LB));
hname = makeHistname(("ErrorBit_per_lumi_"+modlabel2[i]), false);
- htitles = makeHisttitle(("Average Errors per module per event, "+modlabel2[i]), (atext_LB+atext_erb+atext_err), false);
+ htitles = makeHisttitle(("Average Errors by Error Bits, "+modlabel2[i]), (atext_LB+atext_erb+atext_erf), false);
sc = rodHistos.regHist(m_errhist_per_bit_LB[i] = TProfile2D_LW::create(hname.c_str(), htitles.c_str(), nbins_LB, minbin_LB, maxbin_LB, 31, 0., 31.));
m_errhist_per_bit_LB[i]->SetOption("colz");
hname = makeHistname(("Error_per_lumi_"+modlabel2[i]), false);
- htitles = makeHisttitle(("Average Errors per module per event, "+modlabel2[i]), (atext_LB+atext_ers+atext_err), false);
+ htitles = makeHisttitle(("Average Errors by Error Types, "+modlabel2[i]), (atext_LB+atext_ers+atext_err), false);
sc = rodHistos.regHist(m_errhist_per_type_LB[i] = TProfile2D_LW::create(hname.c_str(), htitles.c_str(), nbins_LB, minbin_LB, maxbin_LB, 7, 0., 7.));
m_errhist_per_type_LB[i]->SetOption("colz");
@@ -198,7 +198,7 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
const std::string tmp[ErrorCategory::COUNT] = {"SyncErrorsFrac_per_event", "TruncationErrorsFrac_per_event", "OpticalErrorsFrac_per_event", "SEUErrorsFrac_per_event", "TimeoutErrorsFrac_per_event"};
for (int j = 0; j < ErrorCategory::COUNT; j++) {
hname = makeHistname((tmp[j]+"_"+modlabel2[i]), false);
- htitles = makeHisttitle((tmp[j]+", "+modlabel2[i]), (atext_LB+atext_erf), false);
+ htitles = makeHisttitle(("Average " + error_cat_labels[j].second + " per Module" + ", " + modlabel2[i]), (atext_LB + atext_erf), false);
sc = rodHistos.regHist(m_errhist_errcat_avg[j][i] = TProfile_LW::create(hname.c_str(), htitles.c_str(), nbins_LB, minbin_LB, maxbin_LB));
}
@@ -220,29 +220,29 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
}
if (m_doModules) {
- m_errors = new PixelMonModules1D("errors", ("Errors in module:ErrorType" + m_histTitleExt + ";Number of Errors").c_str(), 7, 0.5, 7.5);
+ m_errors = std::make_unique<PixelMonModules1D>(PixelMonModules1D("errors", ("Errors in module:ErrorType" + m_histTitleExt + ";Number of Errors").c_str(), 7, 0.5, 7.5));
sc = m_errors->regHist(this, (path+"/ModulesErrors").c_str(), run);
for (int k = 0; k < 7; k++) m_errors->SetBinLabel(error_type_labels[k].second.c_str(), k+1);
}
if (m_do2DMaps && !m_doOnline) {
for (int i = 0; i < ErrorCategoryMODROD::COUNT - 3; i++) {
- m_errhist_errtype_map[i] = new PixelMon2DMapsLW(error_type_labels[i].first, (error_type_labels[i].second + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_errhist_errtype_map[i] = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(error_type_labels[i].first, ("Total " + error_type_labels[i].second + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_errhist_errtype_map[i]->regHist(rodHistos);
}
for (int i = 0; i < ErrorCategory::COUNT; i++) {
- m_errhist_errcat_map[i] = new PixelMon2DMapsLW(error_cat_labels[i].first.c_str(), (error_cat_labels[i].second + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_errhist_errcat_map[i] = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(error_cat_labels[i].first, ("Total " + error_cat_labels[i].second + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_errhist_errcat_map[i]->regHist(rodHistos);
}
}
- if (m_do2DMaps && !m_doOnline) {
+ if (m_doOfflineAnalysis) {
for (int j = 0; j < kNumErrorStates; j++) {
- m_errhist_expert_LB_maps[j] = new PixelMon2DLumiMaps(error_state_labels[j].first + "_int_LB", error_state_labels[j].second + " per event per LB" + m_histTitleExt, "# Errors", PixMon::HistConf::kPix);
+ m_errhist_expert_LB_maps[j] = std::make_unique<PixelMon2DLumiMaps>(PixelMon2DLumiMaps(error_state_labels[j].first + "_int_LB", error_state_labels[j].second + " per event per LB" + m_histTitleExt, "# Errors", PixMon::HistConf::kPix));
sc = m_errhist_expert_LB_maps[j]->regHist(rodExpert);
}
for (int j = kNumErrorStates; j < kNumErrorStates+kNumErrorStatesIBL; j++) {
- m_errhist_expert_LB_maps[j] = new PixelMon2DLumiMaps(error_state_labelsIBL[j - kNumErrorStates].first + "_int_LB", error_state_labelsIBL[j - kNumErrorStates].second + " per event per LB" + m_histTitleExt, "# Errors", PixMon::HistConf::kIBL);
+ m_errhist_expert_LB_maps[j] = std::make_unique<PixelMon2DLumiMaps>(PixelMon2DLumiMaps(error_state_labelsIBL[j - kNumErrorStates].first + "_int_LB", error_state_labelsIBL[j - kNumErrorStates].second + " per event per LB" + m_histTitleExt, "# Errors", PixMon::HistConf::kIBL));
sc = m_errhist_expert_LB_maps[j]->regHist(rodExpert);
}
}
@@ -255,12 +255,12 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
}
hname = makeHistname((error_state_labels[j].first+"_Map"), false);
htitles = makeHisttitle((error_state_labels[j].second + " per event per LB"), "", false);
- m_errhist_expert_maps[j] = new PixelMon2DMapsLW(hname.c_str(), htitles.c_str(), PixMon::HistConf::kPix, true);
+ m_errhist_expert_maps[j] = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(hname.c_str(), htitles.c_str(), PixMon::HistConf::kPix, true));
sc = m_errhist_expert_maps[j]->regHist(rodExpert);
}
if (m_do2DMaps) {
- m_errhist_femcc_errwords_map = new PixelMon2DProfilesLW("femcc_errorwords", ("Average FE/MCC Error Words" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D);
+ m_errhist_femcc_errwords_map = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("femcc_errorwords", ("Average FE/MCC Error Words" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D));
sc = m_errhist_femcc_errwords_map->regHist(rodHistos);
}
@@ -273,20 +273,20 @@ StatusCode PixelMainMon::BookRODErrorMon(void)
for (int j = kNumErrorStates; j < kNumErrorStates+kNumErrorStatesIBL; j++) {
hname = makeHistname((error_state_labelsIBL[j - kNumErrorStates].first+"_Map"), false);
htitles = makeHisttitle((error_state_labelsIBL[j - kNumErrorStates].second + " per event per LB"), "", false);
- m_errhist_expert_maps[j] = new PixelMon2DMapsLW(hname.c_str(), htitles.c_str(), PixMon::HistConf::kIBL, m_doIBL);
+ m_errhist_expert_maps[j] = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW(hname.c_str(), htitles.c_str(), PixMon::HistConf::kIBL, m_doIBL));
sc = m_errhist_expert_maps[j]->regHist(rodExpert);
}
hname = makeHistname("ServiceRecord_Unweighted_IBL", false);
- htitles = makeHisttitle("ServiceRecord Unweighted,_IBL", ";SR;Count", false);
+ htitles = makeHisttitle("ServiceRecord Unweighted, IBL", ";SR;Count", false);
sc = rodExpert.regHist(m_errhist_expert_servrec_ibl_unweighted = TH1F_LW::create(hname.c_str(), htitles.c_str(), 32, -0.5, 31.5));
hname = makeHistname("ServiceRecord_Weighted_IBL", false);
- htitles = makeHisttitle("ServiceRecord Weighted,_IBL", ";SR;Count", false);
+ htitles = makeHisttitle("ServiceRecord Weighted, IBL", ";SR;Count", false);
sc = rodExpert.regHist(m_errhist_expert_servrec_ibl_weighted = TH1F_LW::create(hname.c_str(), htitles.c_str(), 32, -0.5, 31.5));
hname = makeHistname("ServiceRecord_Count_IBL", false);
- htitles = makeHisttitle("ServiceRecord Count,_IBL", ";SR;Count", false);
+ htitles = makeHisttitle("ServiceRecord Count, IBL", ";SR;Count", false);
sc = rodExpert.regHist(m_errhist_expert_servrec_ibl_count = TH1F_LW::create(hname.c_str(), htitles.c_str(), 100, -0.5, 99.5));
if (m_errhist_expert_servrec_ibl_unweighted) {
@@ -322,13 +322,13 @@ StatusCode PixelMainMon::BookRODErrorLumiBlockMon(void)
StatusCode sc;
if (m_do2DMaps && !m_doOnline) {
- m_errors_LB = new PixelMon2DMapsLW("Errors_LB", ("Errors" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_errors_LB = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Errors_LB", ("Errors" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_errors_LB->regHist(lumiBlockHist);
- m_errors_RODSync_mod = new PixelMon2DMapsLW("Errors_RODSync_LB", ("Errors_RODSync" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_errors_RODSync_mod = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Errors_RODSync_LB", ("Errors_RODSync" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_errors_RODSync_mod->regHist(lumiBlockHist);
- m_errors_ModSync_mod = new PixelMon2DMapsLW("Errors_ModSync_LB", ("Errors_ModSync" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_errors_ModSync_mod = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Errors_ModSync_LB", ("Errors_ModSync" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_errors_ModSync_mod->regHist(lumiBlockHist);
}
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Hits.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Hits.cxx
index 9216039a52e85ba62727a7883afbb52f3f5900f9..e064e30cc950f1b69067242d1b2cecfc5f2f162f 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Hits.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Hits.cxx
@@ -158,7 +158,7 @@ StatusCode PixelMainMon::BookHitsMon(void)
}
}
- m_hitmap_tmp = new PixelMon2DMapsLW("HitMap_tmp", ("Hit map for monitoring" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_hitmap_tmp = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("HitMap_tmp", ("Hit map for monitoring" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_hitmap_tmp->regHist(rdoShift);
for( int i=0; i<PixLayer::COUNT; i++){
@@ -173,7 +173,7 @@ StatusCode PixelMainMon::BookHitsMon(void)
sc = rdoShift.regHist(m_occupancy_time2= new TProfile("occupancy_time_1hr", ("Module hit occupancy as function of time over 1 hour. 36 sec/bin" + m_histTitleExt + ";time;module occupancy").c_str(), 99,0.,1.,"i"));
sc = rdoShift.regHist(m_occupancy_time3= new TProfile("occupancy_time_6hr", ("Module hit occupancy as function of time over 6 hours. 3.6 min/bin" + m_histTitleExt + ";time;module occupancy").c_str(), 99,0.,1.,"i"));
- m_hitmap_mon = new PixelMon2DMapsLW("HitMap_Mon", ("Hit map for monitoring" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_hitmap_mon = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("HitMap_Mon", ("Hit map for monitoring" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_hitmap_mon->regHist(rdoShift);
for (int i=0; i<PixLayer::COUNT-1+(int)(m_doIBL); i++){
@@ -233,29 +233,29 @@ StatusCode PixelMainMon::BookHitsMon(void)
if (m_do2DMaps)
{
- m_occupancy = new PixelMon2DMapsLW("Occupancy", ("hit map"+ m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_occupancy = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Occupancy", ("hit map"+ m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_occupancy->regHist(rdoShift);
- m_average_pixocc = new PixelMon2DMapsLW("Occupancy_per_pixel", ("#hits / pixel" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_average_pixocc = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Occupancy_per_pixel", ("#hits / pixel" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D, false));
sc = m_average_pixocc->regHist(rdoShift);
- m_occupancy_pix_evt = new PixelMon2DProfilesLW("Occupancy_per_pixel_event", ("#hits / pixel / event" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D);
+ m_occupancy_pix_evt = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("Occupancy_per_pixel_event", ("#hits / pixel / event" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D));
sc = m_occupancy_pix_evt->regHist(rdoShift);
- m_Lvl1ID_diff_mod_ATLAS_per_LB = new PixelMon2DLumiProfiles("Lvl1ID_diff_ATLAS_mod_per_LB", ("ATLAS_{Level 1 ID} - Module_{Level 1 ID} per LB" + m_histTitleExt).c_str(),"#Delta Level 1 ID", PixMon::HistConf::kPixIBL);
+ m_Lvl1ID_diff_mod_ATLAS_per_LB = std::make_unique<PixelMon2DLumiProfiles>(PixelMon2DLumiProfiles("Lvl1ID_diff_ATLAS_mod_per_LB", ("ATLAS_{Level 1 ID} - Module_{Level 1 ID} per LB" + m_histTitleExt).c_str(),"#Delta Level 1 ID", PixMon::HistConf::kPixIBL));
sc = m_Lvl1ID_diff_mod_ATLAS_per_LB->regHist(timeExpert);
- m_Lvl1ID_absdiff_mod_ATLAS_per_LB = new PixelMon2DLumiProfiles("Lvl1ID_absdiff_ATLAS_mod_per_LB", ("ATLAS_{Level 1 ID} - Module_{Level 1 ID} per LB" + m_histTitleExt).c_str(),"#Delta Level 1 ID", PixMon::HistConf::kPixIBL);
+ m_Lvl1ID_absdiff_mod_ATLAS_per_LB = std::make_unique<PixelMon2DLumiProfiles>(PixelMon2DLumiProfiles("Lvl1ID_absdiff_ATLAS_mod_per_LB", ("ATLAS_{Level 1 ID} - Module_{Level 1 ID} per LB" + m_histTitleExt).c_str(),"#Delta Level 1 ID", PixMon::HistConf::kPixIBL));
sc = m_Lvl1ID_absdiff_mod_ATLAS_per_LB->regHist(timeExpert);
}
if (m_doModules)
{
- m_hit_num_mod = new PixelMonModules1D("Hit_num", ("Number of hits in a module in an event" + m_histTitleExt).c_str(), 15,-0.5,149.5);
+ m_hit_num_mod = std::make_unique<PixelMonModules1D>(PixelMonModules1D("Hit_num", ("Number of hits in a module in an event" + m_histTitleExt).c_str(), 15,-0.5,149.5));
sc = m_hit_num_mod->regHist(this,(path+"/Modules_NumberOfHits").c_str(),run);
- m_hiteff_mod = new PixelMonModulesProf("Hit_track_eff", ("Proportion of hits on track" + m_histTitleExt).c_str(), 2500,-0.5,2499.5);
+ m_hiteff_mod = std::make_unique<PixelMonModulesProf>(PixelMonModulesProf("Hit_track_eff", ("Proportion of hits on track" + m_histTitleExt).c_str(), 2500,-0.5,2499.5));
sc = m_hiteff_mod->regHist(this,(path+"/Modules_HitEff").c_str(),run);
- m_FE_chip_hit_summary = new PixelMonModules1D("FE_Chip_Summary", ("FE Chip Summary" + m_histTitleExt).c_str(), 16,-0.5,15.5);
+ m_FE_chip_hit_summary = std::make_unique<PixelMonModules1D>(PixelMonModules1D("FE_Chip_Summary", ("FE Chip Summary" + m_histTitleExt).c_str(), 16,-0.5,15.5));
sc = m_FE_chip_hit_summary->regHist(this,(path+"/Modules_FEChipSummary").c_str(),run);
}
@@ -281,7 +281,7 @@ StatusCode PixelMainMon::BookHitsMon(void)
}
if (m_doPixelOccupancy)
{
- m_pixel_occupancy = new PixelMonModules2D("Pixel_Occupancy", ("Pixel Occupancy" + m_histTitleExt).c_str(), 160, -0.,160.,336,0.,336.);
+ m_pixel_occupancy = std::make_unique<PixelMonModules2D>(PixelMonModules2D("Pixel_Occupancy", ("Pixel Occupancy" + m_histTitleExt).c_str(), 160, -0.,160.,336,0.,336.));
sc = m_pixel_occupancy->regHist(this,(path+"/PixelOccupancy").c_str(),run);
}
@@ -364,7 +364,7 @@ StatusCode PixelMainMon::BookHitsLumiBlockMon(void)
if(m_doModules) {
hname = makeHistname("num_Hits_mod_LB", false);
htitles = makeHisttitle("Number of pixel hits in a module in an event", (atext_hit+atext_nevt), false);
- m_hit_num_mod_LB = new PixelMonModules1D(hname.c_str(), htitles.c_str(), 20, -0.5, 19.5);
+ m_hit_num_mod_LB = std::make_unique<PixelMonModules1D>(PixelMonModules1D(hname.c_str(), htitles.c_str(), 20, -0.5, 19.5));
sc = m_hit_num_mod_LB->regHist(this, (path+"/Modules_NumberOfHits").c_str(), lowStat);
}
for( int i=0; i<PixLayer::COUNT; i++){
@@ -381,7 +381,7 @@ StatusCode PixelMainMon::BookHitsLumiBlockMon(void)
sc = lumiBlockHist.regHist(m_Lvl1A_10min_mod[i] = TH1F_LW::create(hname.c_str(), htitles.c_str(), 14, -1.5, 12.5));
}
- m_occupancy_10min = new PixelMon2DMapsLW("Occupancy_10min", ("hit occupancy" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_occupancy_10min = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Occupancy_10min", ("hit occupancy" + m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_occupancy_10min->regHist(lumiBlockHist);
if (sc.isFailure()) ATH_MSG_WARNING("Problems with booking Hit histograms per LB (low stat)");
@@ -540,7 +540,7 @@ StatusCode PixelMainMon::FillHitsMon(void) //Called once per event
pixlayeribl2d3d < PixLayerIBL2D3D::COUNT &&
nChannels_mod[pixlayeribl2d3d] > 0 )
{
- m_average_pixocc->WeightingFill(rdoID, m_pixelid, 1.0/( 1.0*nChannels_mod[pixlayeribl2d3d]) );
+ m_average_pixocc->Fill(rdoID, m_pixelid, 1.0/( 1.0*nChannels_mod[pixlayeribl2d3d]) );
}
@@ -668,7 +668,7 @@ StatusCode PixelMainMon::FillHitsMon(void) //Called once per event
////////////////////Fill after event block////////////////
if (m_doOnline)//should we fill these mid run or only at the end?
{
- FillSummaryHistos(m_occupancy, m_occupancy_summary_mod[PixLayer::kECA], m_occupancy_summary_mod[PixLayer::kECC],
+ FillSummaryHistos(m_occupancy.get(), m_occupancy_summary_mod[PixLayer::kECA], m_occupancy_summary_mod[PixLayer::kECC],
m_occupancy_summary_mod[PixLayer::kIBL], m_occupancy_summary_mod[PixLayer::kB0],
m_occupancy_summary_mod[PixLayer::kB1], m_occupancy_summary_mod[PixLayer::kB2]);
if(m_occupancy_time1&&m_occupancy_time2&&m_occupancy_time3) FillTimeHisto(double(nhits/(1744.0+280*m_doIBL)),m_occupancy_time1, m_occupancy_time2, m_occupancy_time3,10.,60.,360. );
@@ -676,8 +676,8 @@ StatusCode PixelMainMon::FillHitsMon(void) //Called once per event
for(int i=0; i<PixLayer::COUNT; i++)
if( m_hit_ToT_Mon_mod[i] && m_hit_ToT_tmp_mod[i]) TH1FFillMonitoring(m_hit_ToT_Mon_mod[i], m_hit_ToT_tmp_mod[i]);
if ( m_hitmap_tmp && m_hitmap_mon) {
- if ( m_occupancy_pix_evt ) m_occupancy_pix_evt->FillFromMap(m_hitmap_tmp, false);
- m_hitmap_mon->Fill2DMon(m_hitmap_tmp);
+ if ( m_occupancy_pix_evt ) m_occupancy_pix_evt->FillFromMap(m_hitmap_tmp.get(), false);
+ m_hitmap_mon->Fill2DMon(m_hitmap_tmp.get());
}
}
} //end of doOnline loop processing
@@ -688,7 +688,7 @@ StatusCode PixelMainMon::FillHitsMon(void) //Called once per event
if (m_hits_per_lumi_mod[i]) m_hits_per_lumi_mod[i]->Fill(m_manager->lumiBlockNumber(), nhits_mod[i]);
/// Fill average occupancy
- if ( !m_doOnline && m_occupancy_pix_evt && m_hitmap_tmp) m_occupancy_pix_evt->FillFromMap(m_hitmap_tmp, true);
+ if ( !m_doOnline && m_occupancy_pix_evt && m_hitmap_tmp) m_occupancy_pix_evt->FillFromMap(m_hitmap_tmp.get(), true);
double avgocc = 0;
double avgocc_mod[PixLayerIBL2D3D::COUNT] = {0};
@@ -853,7 +853,7 @@ StatusCode PixelMainMon::ProcHitsMon(void)
if (m_doOffline)
{
- FillSummaryHistos(m_occupancy, m_occupancy_summary_mod[PixLayer::kECA], m_occupancy_summary_mod[PixLayer::kECC],
+ FillSummaryHistos(m_occupancy.get(), m_occupancy_summary_mod[PixLayer::kECA], m_occupancy_summary_mod[PixLayer::kECC],
m_occupancy_summary_mod[PixLayer::kIBL], m_occupancy_summary_mod[PixLayer::kB0],
m_occupancy_summary_mod[PixLayer::kB1], m_occupancy_summary_mod[PixLayer::kB2]);
}
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMainMon.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMainMon.cxx
index 7980fa5dccbad738a29323da454c5ed7cbd7f81c..a6d4be445898da16a9c4e2e2ba63e52f295e01c4 100755
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMainMon.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMainMon.cxx
@@ -53,6 +53,11 @@
#include "EventInfo/EventID.h"
#include "TrkToolInterfaces/ITrackHoleSearchTool.h"
#include "PathResolver/PathResolver.h"
+#include "PixelMonitoring/PixelMon2DMapsLW.h"
+#include "PixelMonitoring/PixelMon2DProfilesLW.h"
+#include "PixelMonitoring/PixelMon2DLumiMaps.h"
+#include "PixelMonitoring/PixelMon2DLumiProfiles.h"
+#include "PixelMonitoring/PixelMonModules.h"
//////////////////////////////////////////////////////////////////////////////
@@ -168,8 +173,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
/// number of hits
m_hits_per_lumi = 0;
m_num_hits = 0;
- m_hitmap_tmp = 0;
- m_hitmap_mon = 0;
memset(m_nhits_mod, 0, sizeof(m_nhits_mod));
memset(m_hits_per_lumi_mod, 0, sizeof(m_hits_per_lumi_mod));
memset(m_nlargeevt_per_lumi_mod, 0, sizeof(m_nlargeevt_per_lumi_mod));
@@ -183,10 +186,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
memset(m_avgocc_active_per_lumi_mod, 0, sizeof(m_avgocc_active_per_lumi_mod));
memset(m_maxocc_per_lumi_mod, 0, sizeof(m_maxocc_per_lumi_mod));
memset(m_maxocc_per_bcid_mod, 0, sizeof(m_maxocc_per_bcid_mod));
- m_occupancy = 0;
- m_average_pixocc = 0;
- m_occupancy_pix_evt = 0;
- m_occupancy_10min = 0;
m_occupancy_time1 = 0;
m_occupancy_time2 = 0;
m_occupancy_time3 = 0;
@@ -211,16 +210,9 @@ PixelMainMon::PixelMainMon(const std::string & type,
memset(m_Lvl1A_10min_mod, 0, sizeof(m_Lvl1A_10min_mod));
memset(m_Lvl1ID_diff_mod_ATLAS_mod, 0, sizeof(m_Lvl1ID_diff_mod_ATLAS_mod));
memset(m_diff_ROD_vs_Module_BCID_mod, 0, sizeof(m_diff_ROD_vs_Module_BCID_mod));
- m_Lvl1ID_diff_mod_ATLAS_per_LB = 0;
- m_Lvl1ID_absdiff_mod_ATLAS_per_LB = 0;
/// Quick status
m_nhits_L0_B11_S2_C6 = 0;
m_occupancy_L0_B11_S2_C6 = 0;
- /// module histo
- m_hit_num_mod = 0;
- m_hiteff_mod = 0;
- m_FE_chip_hit_summary = 0;
- m_pixel_occupancy = 0;
/// details
m_Details_mod1_num_hits = 0;
m_Details_mod2_num_hits = 0;
@@ -247,16 +239,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
m_tracksPerEvt_per_lumi = 0;
m_tracksPerEvtPerMu_per_lumi = 0;
/// track state on surface
- m_tsos_hitmap = 0;
- m_tsos_holemap = 0;
- m_tsos_outliermap = 0;
- //m_tsos_measratio = 0;
- //m_tsos_holeratio = 0;
- m_misshits_ratio = 0;
- m_tsos_holeratio_tmp = 0;
- m_tsos_holeratio_mon = 0;
- m_misshits_ratio_tmp = 0;
- m_misshits_ratio_mon = 0;
/// hit efficiency
memset(m_hiteff_incl_mod, 0, sizeof(m_hiteff_incl_mod));
/// Lorentz Angle
@@ -283,7 +265,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
m_clustot_highpt = 0;
m_1hitclustot_highpt = 0;
m_2hitclustot_highpt = 0;
- m_tsos_hiteff_vs_lumi = 0;
///
/// Cluster histograms
///
@@ -309,39 +290,26 @@ PixelMainMon::PixelMainMon(const std::string & type,
memset(m_2cluster_Q_mod, 0, sizeof(m_2cluster_Q_mod));
memset(m_3cluster_Q_mod, 0, sizeof(m_3cluster_Q_mod));
memset(m_bigcluster_Q_mod, 0, sizeof(m_bigcluster_Q_mod));
- m_clussize_map = 0;
- m_cluscharge_map = 0;
- m_clusToT_map = 0;
m_cluster_groupsize = 0;
m_cluster_col_width = 0;
m_cluster_row_width = 0;
memset(m_cluster_col_width_mod, 0, sizeof(m_cluster_col_width_mod));
memset(m_cluster_row_width_mod, 0, sizeof(m_cluster_row_width_mod));
memset(m_cluster_groupsize_mod, 0, sizeof(m_cluster_groupsize_mod));
- m_cluster_LVL1A = 0;
memset(m_cluster_LVL1A1d_mod, 0, sizeof(m_cluster_LVL1A1d_mod));
m_clusterSize_eta = 0;
memset(m_clusToT_vs_eta_mod, 0, sizeof(m_clusToT_vs_eta_mod));
memset(m_ToT_vs_clussize_mod, 0, sizeof(m_ToT_vs_clussize_mod));
memset(m_clussize_vs_eta_mod, 0, sizeof(m_clussize_vs_eta_mod));
- m_clustermap_mon = 0;
- m_clustermap_tmp = 0;
- m_cluster_occupancy = 0;
m_cluster_occupancy_FE_B0_mon = 0;
m_cluster_occupancy_time1 = 0;
m_cluster_occupancy_time2 = 0;
m_cluster_occupancy_time3 = 0;
- m_clusocc_sizenot1 = 0;
- m_cluseff_mod = 0;
- m_cluster_ToT_mod = 0;
- m_cluster_size_mod = 0;
- m_cluster_num_mod = 0;
m_num_clusters = 0;
memset(m_clusters_per_track_per_lumi_mod, 0, sizeof(m_clusters_per_track_per_lumi_mod));
memset(m_num_clusters_mod, 0, sizeof(m_num_clusters_mod));
memset(m_cluster_occupancy_summary_mod, 0, sizeof(m_cluster_occupancy_summary_mod));
m_cluster_LVL1A_mod = 0;
- m_clus_LVL1A_sizenot1 = 0;
m_clustersOnOffTrack_per_lumi = 0;
/// Quick status
m_clusters_onTrack_L0_B11_S2_C6 = 0;
@@ -349,11 +317,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
///
/// Status
///
- m_Status_modules = 0;
- m_status = 0;
- m_status_mon = 0;
- m_status_LB = 0;
- m_dqStatus = 0;
m_disabledModules_per_lumi_PIX = 0;
memset(m_badModules_per_lumi_mod, 0, sizeof(m_badModules_per_lumi_mod));
memset(m_disabledModules_per_lumi_mod, 0, sizeof(m_disabledModules_per_lumi_mod));
@@ -369,10 +332,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
m_error_time1 = 0;
m_error_time2 = 0;
m_error_time3 = 0;
- m_errors = 0;
- memset(m_errhist_errtype_map, 0, sizeof(m_errhist_errtype_map));
- memset(m_errhist_errcat_map, 0, sizeof(m_errhist_errcat_map));
- memset(m_errhist_expert_maps, 0, sizeof(m_errhist_expert_maps));
memset(m_errhist_expert_LB, 0, sizeof(m_errhist_expert_LB));
memset(m_errhist_per_bit_LB, 0, sizeof(m_errhist_per_bit_LB));
memset(m_errhist_per_type_LB, 0, sizeof(m_errhist_per_type_LB));
@@ -380,10 +339,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
m_errhist_expert_servrec_ibl_unweighted = 0;
m_errhist_expert_servrec_ibl_weighted = 0;
m_errhist_expert_servrec_ibl_count = 0;
- memset(m_errhist_expert_LB_maps, 0, sizeof(m_errhist_expert_LB_maps));
- m_errors_LB = 0;
- m_errors_RODSync_mod = 0;
- m_errors_ModSync_mod = 0;
///
/// Space Point
///
@@ -399,10 +354,6 @@ PixelMainMon::PixelMainMon(const std::string & type,
///
/// Per 20 LB
///
- m_cluster_occupancy_LB = 0;
- m_cluster_ToT_mod_LB = 0;
- m_cluster_num_mod_LB = 0;
- m_hit_num_mod_LB = 0;
m_num_hits_LB = 0;
memset(m_hit_ToT_LB_mod, 0, sizeof(m_hit_ToT_LB_mod));
m_cluster_ToT_LB = 0;
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiMaps.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiMaps.cxx
index ae9aabbc4c111e1ae2aad7e4d297df325b42c854..d6532d8390d8e9b943e0d491aac5fac89cd45d77 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiMaps.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiMaps.cxx
@@ -8,113 +8,94 @@
#include "PixelMonitoring/PixelMon2DLumiMaps.h"
#include "PixelMonitoring/Components.h"
+#include "PixelMonitoring/HolderTemplate.h"
#include "InDetIdentifier/PixelID.h"
#include "LWHists/TH2F_LW.h"
#include "GaudiKernel/StatusCode.h"
#include <string.h>
PixelMon2DLumiMaps::PixelMon2DLumiMaps(std::string name, std::string title, std::string zlabel, const PixMon::HistConf& config)
- : IBLlbm(nullptr),
- B0lbm(nullptr),
- B1lbm(nullptr),
- B2lbm(nullptr),
- Albm(nullptr),
- Clbm(nullptr),
- DBMAlbm(nullptr),
- DBMClbm(nullptr),
- m_config(config)
-{
+ : HolderTemplate<TH2F_LW>(config) {
const int lbRange = 3000;
int num_modules;
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL)) {
num_modules = PixMon::kNumStavesIBL * (PixMon::kNumModulesIBL2D + PixMon::kNumModulesIBL3D);
- IBLlbm = TH2F_LW::create((name+"_2D_Map_IBL").c_str(),(title + ", IBL " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(0).reset(TH2F_LW::create((name+"_2D_Map_IBL").c_str(),(title + ", IBL " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB0)) {
num_modules = PixMon::kNumStavesL0 * PixMon::kNumModulesBarrel;
- B0lbm = TH2F_LW::create((name+"_2D_Map_B0").c_str(), (title + ", B0 " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(3).reset(TH2F_LW::create((name+"_2D_Map_B0").c_str(), (title + ", B0 " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB1)) {
num_modules = PixMon::kNumStavesL1 * PixMon::kNumModulesBarrel;
- B1lbm = TH2F_LW::create((name+"_2D_Map_B1").c_str(), (title + ", B1 " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(4).reset(TH2F_LW::create((name+"_2D_Map_B1").c_str(), (title + ", B1 " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB2)) {
num_modules = PixMon::kNumStavesL2 * PixMon::kNumModulesBarrel;
- B2lbm = TH2F_LW::create((name+"_2D_Map_B2").c_str(), (title + ", B2 " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(5).reset(TH2F_LW::create((name+"_2D_Map_B2").c_str(), (title + ", B2 " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECA)) {
num_modules = PixMon::kNumLayersDisk * PixMon::kNumModulesDisk;
- Albm = TH2F_LW::create((name+"_2D_Map_ECA" ).c_str(),(title + ", ECA " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(6).reset(TH2F_LW::create((name+"_2D_Map_ECA" ).c_str(),(title + ", ECA " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECC)) {
num_modules = PixMon::kNumLayersDisk * PixMon::kNumModulesDisk;
- Clbm = TH2F_LW::create((name+"_2D_Map_ECC" ).c_str(),(title + ", ECC " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(7).reset(TH2F_LW::create((name+"_2D_Map_ECC" ).c_str(),(title + ", ECC " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMA)) {
num_modules = PixMon::kNumLayersDBM * PixMon::kNumModulesDBM;
- DBMAlbm = TH2F_LW::create((name+"_2D_Map_DBMA").c_str(),(title + ", DBMA " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(8).reset(TH2F_LW::create((name+"_2D_Map_DBMA").c_str(),(title + ", DBMA " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMC)) {
num_modules = PixMon::kNumLayersDBM * PixMon::kNumModulesDBM;
- DBMClbm = TH2F_LW::create((name+"_2D_Map_DBMC").c_str(),(title + ", DBMC " + " (Map);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(9).reset(TH2F_LW::create((name+"_2D_Map_DBMC").c_str(),(title + ", DBMC " + " (Map);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
- // We do not have support for IBL2D/3D in this class, but the histogram
- // array should look the same for all classes. Therefore, we fill the
- // blanks for IBL2D/3d with null pointers.
- m_histograms = {IBLlbm, nullptr, nullptr, B0lbm, B1lbm, B2lbm, Albm, Clbm, DBMAlbm, DBMClbm};
-
+ setHistogramPointers();
formatHist();
}
-PixelMon2DLumiMaps::~PixelMon2DLumiMaps()
-{
- for (auto& hist : m_histograms) {
- if (hist) LWHist::safeDelete(hist);
- }
-}
-
-void PixelMon2DLumiMaps::Fill(double LB,Identifier &id, const PixelID* pixID,double weight)
+void PixelMon2DLumiMaps::Fill(double LB,Identifier &id, const PixelID* pixID, float weight)
{
const int bec = pixID->barrel_ec(id);
const int pm = pixID->phi_module(id);
int ld = pixID->layer_disk(id);
- if (bec == 2 && Albm) {
- Albm->Fill(LB, ld * 48 + pm, weight);
- } else if (bec == -2 && Clbm) {
- Clbm->Fill(LB, ld * 48 + pm, weight);
- } else if (bec == 4 && DBMAlbm) {
- DBMAlbm->Fill(LB, ld * 4 + pm, weight);
- } else if (bec == -4 && DBMClbm) {
- DBMClbm->Fill(LB, ld * 4 + pm, weight);
+ if (bec == 2 && A) {
+ A->Fill(LB, ld * 48 + pm, weight);
+ } else if (bec == -2 && C) {
+ C->Fill(LB, ld * 48 + pm, weight);
+ } else if (bec == 4 && DBMA) {
+ DBMA->Fill(LB, ld * 4 + pm, weight);
+ } else if (bec == -4 && DBMC) {
+ DBMC->Fill(LB, ld * 4 + pm, weight);
} else if (bec == 0) {
if (m_doIBL) ld--;
const int em = pixID->eta_module(id) + 6;
- if (ld == 0 && B0lbm) {
- B0lbm->Fill(LB, em + 13 * pm, weight);
- }else if (ld == 1 && B1lbm) {
- B1lbm->Fill(LB, em + 13 * pm, weight);
- } else if (ld == 2 && B2lbm) {
- B2lbm->Fill(LB, em + 13 * pm, weight);
- } else if (ld == -1 && IBLlbm) {
- IBLlbm->Fill(LB, em + 4 + 20 * pm, weight);
+ if (ld == 0 && B0) {
+ B0->Fill(LB, em + 13 * pm, weight);
+ }else if (ld == 1 && B1) {
+ B1->Fill(LB, em + 13 * pm, weight);
+ } else if (ld == 2 && B2) {
+ B2->Fill(LB, em + 13 * pm, weight);
+ } else if (ld == -1 && IBL) {
+ IBL->Fill(LB, em + 4 + 20 * pm, weight);
}
}
}
@@ -123,35 +104,35 @@ void PixelMon2DLumiMaps::formatHist()
{
std::string label;
unsigned int count = 1;
- if (Albm && Clbm) {
+ if (A && C) {
for (unsigned int j = 0; j < PixMon::kNumLayersDisk; ++j) {
for (unsigned int i = 0; i < PixMon::kNumModulesDisk; ++i) {
label = PixMon::LayersDisk.at(j) + "A_" + PixMon::ModulesECA.at(i);
- Albm->GetYaxis()->SetBinLabel(count, label.c_str());
+ A->GetYaxis()->SetBinLabel(count, label.c_str());
label = PixMon::LayersDisk.at(j) + "C_" + PixMon::ModulesECC.at(i);
- Clbm->GetYaxis()->SetBinLabel(count, label.c_str());
+ C->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
count = 1;
}
- if (DBMAlbm && DBMClbm) {
+ if (DBMA && DBMC) {
for (unsigned int j = 0; j < PixMon::kNumLayersDBM; ++j) {
for (unsigned int i = 0; i < PixMon::kNumModulesDBM; ++i) {
label = PixMon::LayersDBM.at(j) + "A_" + PixMon::ModulesDBM.at(i);
- DBMAlbm->GetYaxis()->SetBinLabel(count, label.c_str());
+ DBMA->GetYaxis()->SetBinLabel(count, label.c_str());
label = PixMon::LayersDBM.at(j) + "C_" + PixMon::ModulesDBM.at(i);
- DBMClbm->GetYaxis()->SetBinLabel(count, label.c_str());
+ DBMC->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
count = 1;
}
- if (B0lbm && B1lbm && B2lbm) {
+ if (B0 && B1 && B2) {
for (unsigned int i = 0; i < PixMon::kNumStavesL0; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesBarrel; ++j) {
label = "L0_" + PixMon::StavesL0.at(i) + "_" + PixMon::ModulesBarrel.at(j);
- B0lbm->GetYaxis()->SetBinLabel(count, label.c_str());
+ B0->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
@@ -159,7 +140,7 @@ void PixelMon2DLumiMaps::formatHist()
for (unsigned int i = 0; i < PixMon::kNumStavesL1; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesBarrel; ++j) {
label = "L1_" + PixMon::StavesL1.at(i) + "_" + PixMon::ModulesBarrel.at(j);
- B1lbm->GetYaxis()->SetBinLabel(count, label.c_str());
+ B1->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
@@ -167,18 +148,18 @@ void PixelMon2DLumiMaps::formatHist()
for (unsigned int i = 0; i < PixMon::kNumStavesL2; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesBarrel; ++j) {
label = "L2_" + PixMon::StavesL2.at(i) + "_" + PixMon::ModulesBarrel.at(j);
- B2lbm->GetYaxis()->SetBinLabel(count, label.c_str());
+ B2->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
count = 1;
}
- if (IBLlbm) {
+ if (IBL) {
for (unsigned int i = 0; i < PixMon::kNumStavesIBL; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesIBL; ++j) {
label = "IBL_" + PixMon::StavesIBL.at(i) + "_" + PixMon::ModulesIBL.at(j);
- IBLlbm->GetYaxis()->SetBinLabel(count, label.c_str());
+ IBL->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
@@ -191,19 +172,3 @@ void PixelMon2DLumiMaps::formatHist()
hist->SetMinimum(0.);
}
}
-
-StatusCode PixelMon2DLumiMaps::regHist(ManagedMonitorToolBase::MonGroup &group)
-{
- StatusCode sc = StatusCode::SUCCESS;
-
- for (auto& hist : m_histograms) {
- if (!hist) continue;
- if (group.regHist(hist).isFailure()) {
- sc = StatusCode::FAILURE;
- }
- }
-
- return sc;
-}
-
-const bool PixelMon2DLumiMaps::m_doIBL{true};
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiProfiles.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiProfiles.cxx
index 3e64dcf54f05117be6a32519c024ef4f0c3d7a30..dd36db2dedd001e72794495052dd9101629507d8 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiProfiles.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DLumiProfiles.cxx
@@ -13,108 +13,87 @@
#include "GaudiKernel/StatusCode.h"
#include <string.h>
-PixelMon2DLumiProfiles::PixelMon2DLumiProfiles(std::string name, std::string title, std::string zlabel, const PixMon::HistConf& config)
- : IBLlbp(nullptr),
- B0lbp(nullptr),
- B1lbp(nullptr),
- B2lbp(nullptr),
- Albp(nullptr),
- Clbp(nullptr),
- DBMAlbp(nullptr),
- DBMClbp(nullptr),
- m_config(config)
-{
+PixelMon2DLumiProfiles::PixelMon2DLumiProfiles(std::string name, std::string title, std::string zlabel, const PixMon::HistConf& config) : HolderTemplate<TProfile2D_LW>(config) {
const int lbRange = 3000;
int num_modules;
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL)) {
num_modules = PixMon::kNumStavesIBL * (PixMon::kNumModulesIBL2D + PixMon::kNumModulesIBL3D);
- IBLlbp= TProfile2D_LW::create((name+"_2D_Profile_IBL").c_str(), (title + ", IBL " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(0).reset(TProfile2D_LW::create((name+"_2D_Profile_IBL").c_str(), (title + ", IBL " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB0)) {
num_modules = PixMon::kNumStavesL0 * PixMon::kNumModulesBarrel;
- B0lbp = TProfile2D_LW::create((name+"_2D_Profile_B0").c_str(), (title + ", B0 " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(3).reset(TProfile2D_LW::create((name+"_2D_Profile_B0").c_str(), (title + ", B0 " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB1)) {
num_modules = PixMon::kNumStavesL1 * PixMon::kNumModulesBarrel;
- B1lbp = TProfile2D_LW::create((name+"_2D_Profile_B1").c_str(), (title + ", B1 " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(4).reset(TProfile2D_LW::create((name+"_2D_Profile_B1").c_str(), (title + ", B1 " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB2)) {
num_modules = PixMon::kNumStavesL2 * PixMon::kNumModulesBarrel;;
- B2lbp = TProfile2D_LW::create((name+"_2D_Profile_B2").c_str(), (title + ", B2 " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(5).reset(TProfile2D_LW::create((name+"_2D_Profile_B2").c_str(), (title + ", B2 " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECA)) {
num_modules = PixMon::kNumLayersDisk * PixMon::kNumModulesDisk;
- Albp = TProfile2D_LW::create((name+"_2D_Profile_ECA" ).c_str(),(title + ", ECA " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(6).reset(TProfile2D_LW::create((name+"_2D_Profile_ECA" ).c_str(),(title + ", ECA " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECC)) {
num_modules = PixMon::kNumLayersDisk * PixMon::kNumModulesDisk;
- Clbp = TProfile2D_LW::create((name+"_2D_Profile_ECC" ).c_str(),(title + ", ECC " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(7).reset(TProfile2D_LW::create((name+"_2D_Profile_ECC" ).c_str(),(title + ", ECC " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMA)) {
num_modules = PixMon::kNumLayersDBM * PixMon::kNumModulesDBM;
- DBMAlbp = TProfile2D_LW::create((name+"_2D_Profile_DBMA" ).c_str(),(title + ", DBMA " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(8).reset(TProfile2D_LW::create((name+"_2D_Profile_DBMA" ).c_str(),(title + ", DBMA " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMC)) {
num_modules = PixMon::kNumLayersDBM * PixMon::kNumModulesDBM;
- DBMClbp = TProfile2D_LW::create((name+"_2D_Profile_DBMC" ).c_str(),(title + ", DBMC " + title + " (Profile);LB;Module;" + zlabel).c_str(),
- lbRange, -0.5, -0.5 + lbRange,
- num_modules, -0.5, -0.5 + num_modules);
+ m_histograms.at(9).reset(TProfile2D_LW::create((name+"_2D_Profile_DBMC" ).c_str(),(title + ", DBMC " + title + " (Profile);LB;Module;" + zlabel).c_str(),
+ lbRange, -0.5, -0.5 + lbRange,
+ num_modules, -0.5, -0.5 + num_modules));
}
- // We do not have support for IBL2D/3D in this class, but the histogram
- // array should look the same for all classes. Therefore, we fill the
- // blanks for IBL2D/3d with null pointers.
- m_histograms = {IBLlbp, nullptr, nullptr, B0lbp, B1lbp, B2lbp, Albp, Clbp, DBMAlbp, DBMClbp};
-
+ setHistogramPointers();
formatHist();
}
-PixelMon2DLumiProfiles::~PixelMon2DLumiProfiles()
-{
- for (auto& hist : m_histograms) {
- if (hist) LWHist::safeDelete(hist);
- }
-}
-
void PixelMon2DLumiProfiles::Fill(double LB,Identifier &id, const PixelID* pixID, double weight)
{
const int bec = pixID->barrel_ec(id);
const int pm = pixID->phi_module(id);
int ld = pixID->layer_disk(id);
- if (bec == 2 && Albp) {
- Albp->Fill(LB, ld * 48 + pm, weight);
- } else if (bec == -2 && Clbp) {
- Clbp->Fill(LB, ld * 48 + pm, weight);
- } else if (bec == 4 && DBMAlbp) {
- DBMAlbp->Fill(LB, ld * 4 + pm, weight);
- } else if (bec == -4 && DBMClbp) {
- DBMClbp->Fill(LB, ld * 4 + pm, weight);
+ if (bec == 2 && A) {
+ A->Fill(LB, ld * 48 + pm, weight);
+ } else if (bec == -2 && C) {
+ C->Fill(LB, ld * 48 + pm, weight);
+ } else if (bec == 4 && DBMA) {
+ DBMA->Fill(LB, ld * 4 + pm, weight);
+ } else if (bec == -4 && DBMC) {
+ DBMC->Fill(LB, ld * 4 + pm, weight);
} else if (bec == 0) {
if (m_doIBL) ld--;
const int em = pixID->eta_module(id) + 6;
- if (ld == 0 && B0lbp) {
- B0lbp->Fill(LB, em + 13 * pm, weight);
- } else if (ld == 1 && B1lbp) {
- B1lbp->Fill(LB, em + 13 * pm, weight);
- } else if (ld == 2 && B2lbp) {
- B2lbp->Fill(LB, em + 13 * pm, weight);
- } else if (ld == -1 && IBLlbp) {
- IBLlbp->Fill(LB, em + 4 + 20 * pm, weight);
+ if (ld == 0 && B0) {
+ B0->Fill(LB, em + 13 * pm, weight);
+ } else if (ld == 1 && B1) {
+ B1->Fill(LB, em + 13 * pm, weight);
+ } else if (ld == 2 && B2) {
+ B2->Fill(LB, em + 13 * pm, weight);
+ } else if (ld == -1 && IBL) {
+ IBL->Fill(LB, em + 4 + 20 * pm, weight);
}
}
}
@@ -124,35 +103,35 @@ void PixelMon2DLumiProfiles::formatHist()
{
std::string label;
unsigned int count = 1;
- if (Albp && Clbp) {
+ if (A && C) {
for (unsigned int j = 0; j < PixMon::kNumLayersDisk; ++j) {
for (unsigned int i = 0; i < PixMon::kNumModulesDisk; ++i) {
label = PixMon::LayersDisk.at(j) + "A_" + PixMon::ModulesECA.at(i);
- Albp->GetYaxis()->SetBinLabel(count, label.c_str());
+ A->GetYaxis()->SetBinLabel(count, label.c_str());
label = PixMon::LayersDisk.at(j) + "C_" + PixMon::ModulesECC.at(i);
- Clbp->GetYaxis()->SetBinLabel(count, label.c_str());
+ C->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
count = 1;
}
- if (DBMAlbp && DBMClbp) {
+ if (DBMA && DBMC) {
for (unsigned int j = 0; j < PixMon::kNumLayersDBM; ++j) {
for (unsigned int i = 0; i < PixMon::kNumModulesDBM; ++i) {
label = PixMon::LayersDBM.at(j) + "A_" + PixMon::ModulesDBM.at(i);
- DBMAlbp->GetYaxis()->SetBinLabel(count, label.c_str());
+ DBMA->GetYaxis()->SetBinLabel(count, label.c_str());
label = PixMon::LayersDBM.at(j) + "C_" + PixMon::ModulesDBM.at(i);
- DBMClbp->GetYaxis()->SetBinLabel(count, label.c_str());
+ DBMC->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
count = 1;
}
- if (B0lbp && B1lbp && B2lbp) {
+ if (B0 && B1 && B2) {
for (unsigned int i = 0; i < PixMon::kNumStavesL0; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesBarrel; ++j) {
label = "L0_" + PixMon::StavesL0.at(i) + "_" + PixMon::ModulesBarrel.at(j);
- B0lbp->GetYaxis()->SetBinLabel(count, label.c_str());
+ B0->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
@@ -160,7 +139,7 @@ void PixelMon2DLumiProfiles::formatHist()
for (unsigned int i = 0; i < PixMon::kNumStavesL1; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesBarrel; ++j) {
label = "L1_" + PixMon::StavesL1.at(i) + "_" + PixMon::ModulesBarrel.at(j);
- B1lbp->GetYaxis()->SetBinLabel(count, label.c_str());
+ B1->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
@@ -168,17 +147,17 @@ void PixelMon2DLumiProfiles::formatHist()
for (unsigned int i = 0; i < PixMon::kNumStavesL2; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesBarrel; ++j) {
label = "L2_" + PixMon::StavesL2.at(i) + "_" + PixMon::ModulesBarrel.at(j);
- B2lbp->GetYaxis()->SetBinLabel(count, label.c_str());
+ B2->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
count = 1;
}
- if (IBLlbp) {
+ if (IBL) {
for (unsigned int i = 0; i < PixMon::kNumStavesIBL; ++i) {
for (unsigned int j = 0; j < PixMon::kNumModulesIBL; ++j) {
label = "IBL_" + PixMon::StavesIBL.at(i) + "_" + PixMon::ModulesIBL.at(j);
- IBLlbp->GetYaxis()->SetBinLabel(count, label.c_str());
+ IBL->GetYaxis()->SetBinLabel(count, label.c_str());
count++;
}
}
@@ -186,7 +165,7 @@ void PixelMon2DLumiProfiles::formatHist()
for (auto& hist : m_histograms) {
if (!hist) continue;
- if (hist == Albp || hist == Clbp) {
+ if (hist.get() == A || hist.get() == C) {
hist->GetYaxis()->SetLabelSize(0.02);
} else {
hist->GetYaxis()->SetLabelSize(0.03);
@@ -194,19 +173,3 @@ void PixelMon2DLumiProfiles::formatHist()
hist->SetOption("colz");
}
}
-
-StatusCode PixelMon2DLumiProfiles::regHist(ManagedMonitorToolBase::MonGroup &group)
-{
- StatusCode sc = StatusCode::SUCCESS;
-
- for (auto& hist : m_histograms) {
- if (!hist) continue;
- if (group.regHist(hist).isFailure()) {
- sc = StatusCode::FAILURE;
- }
- }
-
- return sc;
-}
-
-const bool PixelMon2DLumiProfiles::m_doIBL{true};
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DMapsLW.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DMapsLW.cxx
index 4ddabf175e1cbb804c8eb75a7d7eda4e5a6d4b65..2d1894fa963f762ed8d0ce2c18574828a4b9fdf9 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DMapsLW.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DMapsLW.cxx
@@ -13,20 +13,7 @@
#include "GaudiKernel/StatusCode.h"
#include <string.h>
-PixelMon2DMapsLW::PixelMon2DMapsLW(std::string name, std::string title, const PixMon::HistConf& config, bool copy2DFEval)
- : IBL(nullptr),
- IBL2D(nullptr),
- IBL3D(nullptr),
- B0(nullptr),
- B1(nullptr),
- B2(nullptr),
- A(nullptr),
- C(nullptr),
- DBMA(nullptr),
- DBMC(nullptr),
- m_config(config),
- m_copy2DFEval(copy2DFEval)
-{
+PixelMon2DMapsLW::PixelMon2DMapsLW(std::string name, std::string title, const PixMon::HistConf& config, bool copy2DFEval) : HolderTemplate<TH2F_LW>(config, copy2DFEval) {
std::string setatext = ";shifted eta index of module";
std::string etatext = ";eta index of module";
std::string phitext = ";phi index of module";
@@ -34,110 +21,61 @@ PixelMon2DMapsLW::PixelMon2DMapsLW(std::string name, std::string title, const Pi
std::string layertext = ";layer number";
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL)) {
- IBL = TH2F_LW::create((name+"_IBL").c_str(), (title + ", IBL " + setatext + phitext).c_str(),
- PixMon::kNumModulesIBL, -16.5, -16.5 + PixMon::kNumModulesIBL,
- PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL);
+ m_histograms.at(0).reset(TH2F_LW::create((name+"_IBL").c_str(), (title + ", IBL " + setatext + phitext).c_str(),
+ PixMon::kNumModulesIBL, -16.5, -16.5 + PixMon::kNumModulesIBL,
+ PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL2D)) {
- IBL2D = TH2F_LW::create((name+"_IBL2D").c_str(), (title + ", IBL planar modules " + setatext + phitext).c_str(),
- PixMon::kNumModulesIBL2D, -6.5, -6.5 + PixMon::kNumModulesIBL2D,
- PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL);
+ m_histograms.at(1).reset(TH2F_LW::create((name+"_IBL2D").c_str(), (title + ", IBL planar modules " + setatext + phitext).c_str(),
+ PixMon::kNumModulesIBL2D, -6.5, -6.5 + PixMon::kNumModulesIBL2D,
+ PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL3D)) {
- IBL3D = TH2F_LW::create((name+"_IBL3D").c_str(), (title + ", IBL 3D modules " + etatext + phitext).c_str(),
- PixMon::kNumModulesIBL3D, -0.5, -0.5 + PixMon::kNumModulesIBL3D,
- PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL);
+ m_histograms.at(2).reset(TH2F_LW::create((name+"_IBL3D").c_str(), (title + ", IBL 3D modules " + etatext + phitext).c_str(),
+ PixMon::kNumModulesIBL3D, -0.5, -0.5 + PixMon::kNumModulesIBL3D,
+ PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB0)) {
- B0 = TH2F_LW::create((name+"_B0").c_str(), (title + ", B0 " + etatext + phitext).c_str(),
- PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
- PixMon::kNumStavesL0, -0.5, -0.5 + PixMon::kNumStavesL0);
+ m_histograms.at(3).reset(TH2F_LW::create((name+"_B0").c_str(), (title + ", B0 " + etatext + phitext).c_str(),
+ PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
+ PixMon::kNumStavesL0, -0.5, -0.5 + PixMon::kNumStavesL0));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB1)) {
- B1 = TH2F_LW::create((name+"_B1").c_str(), (title + ", B1 " + etatext + phitext).c_str(),
- PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
- PixMon::kNumStavesL1, -0.5, -0.5 + PixMon::kNumStavesL1);
+ m_histograms.at(4).reset(TH2F_LW::create((name+"_B1").c_str(), (title + ", B1 " + etatext + phitext).c_str(),
+ PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
+ PixMon::kNumStavesL1, -0.5, -0.5 + PixMon::kNumStavesL1));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB2)) {
- B2 = TH2F_LW::create((name+"_B2").c_str(), (title + ", B2 " + etatext + phitext).c_str(),
- PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
- PixMon::kNumStavesL2, -0.5, -0.5 + PixMon::kNumStavesL2);
+ m_histograms.at(5).reset(TH2F_LW::create((name+"_B2").c_str(), (title + ", B2 " + etatext + phitext).c_str(),
+ PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
+ PixMon::kNumStavesL2, -0.5, -0.5 + PixMon::kNumStavesL2));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECA)) {
- A = TH2F_LW::create((name+"_ECA" ).c_str(), (title + ", ECA " + disktext + phitext).c_str(),
- PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
- PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk);
+ m_histograms.at(6).reset(TH2F_LW::create((name+"_ECA" ).c_str(), (title + ", ECA " + disktext + phitext).c_str(),
+ PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
+ PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECC)) {
- C = TH2F_LW::create((name+"_ECC" ).c_str(), (title + ", ECC " + disktext + phitext).c_str(),
- PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
- PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk);
+ m_histograms.at(7).reset(TH2F_LW::create((name+"_ECC" ).c_str(), (title + ", ECC " + disktext + phitext).c_str(),
+ PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
+ PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMA)) {
- DBMA = TH2F_LW::create((name+"_DBMA" ).c_str(), (title + ", DBMA " + layertext + phitext).c_str(),
- PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
- PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM);
+ m_histograms.at(8).reset(TH2F_LW::create((name+"_DBMA" ).c_str(), (title + ", DBMA " + layertext + phitext).c_str(),
+ PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
+ PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMC)) {
- DBMC = TH2F_LW::create((name+"_DBMC" ).c_str(), (title + ", DBMC " + layertext + phitext).c_str(),
- PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
- PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM);
+ m_histograms.at(9).reset(TH2F_LW::create((name+"_DBMC" ).c_str(), (title + ", DBMC " + layertext + phitext).c_str(),
+ PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
+ PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM));
}
- m_histograms = {IBL, IBL2D, IBL3D, B0, B1, B2, A, C, DBMA, DBMC};
-
+ setHistogramPointers();
formatHist();
}
-PixelMon2DMapsLW::~PixelMon2DMapsLW()
-{
- for (auto& hist : m_histograms) {
- if (hist) LWHist::safeDelete(hist);
- }
-}
-
-void PixelMon2DMapsLW::Fill(Identifier &id, const PixelID* pixID)
-{
- const int bec = pixID->barrel_ec(id);
- const int pm = pixID->phi_module(id);
- int ld = pixID->layer_disk(id);
-
- if (bec == 2 && A) A->Fill(ld, pm);
- else if (bec == -2 && C) C->Fill(ld, pm);
- else if (bec == 4 && DBMA) DBMA->Fill(ld, pm);
- else if (bec == -4 && DBMC) DBMC->Fill(ld, pm);
- else if (bec == 0) {
- if (m_doIBL) ld--;
- const int em = pixID->eta_module(id);
- if (ld == 0 && B0) {
- B0->Fill(em, pm);
- } else if (ld == 1 && B1) {
- B1->Fill(em,pm);
- } else if (ld == 2 && B2) {
- B2->Fill(em,pm);
- } else if (ld == -1 && IBL) {
- int feid = 0;
- int emf = 0;
- bool copy = false;
- if (em < 6 && em > -7) {
- if (pixID->eta_index(id) >= 80) feid = 1;
- emf = 2 * em + feid;
- if (IBL2D) IBL2D->Fill(em, pm);
- copy = true;
- } else if (em < -6) {
- emf = em - 6;
- if (IBL3D) IBL3D->Fill(em + 10, pm);
- } else {
- emf = em + 6;
- if (IBL3D) IBL3D->Fill(em - 2, pm);
- }
- IBL->Fill(emf, pm);
- if (m_copy2DFEval && copy) IBL->Fill(emf + 1, pm);
- }
- }
-}
-
-void PixelMon2DMapsLW::WeightingFill(Identifier &id, const PixelID* pixID, float weight)
+void PixelMon2DMapsLW::Fill(Identifier &id, const PixelID* pixID, float weight)
{
const int bec = pixID->barrel_ec(id);
const int pm = pixID->phi_module(id);
@@ -149,7 +87,7 @@ void PixelMon2DMapsLW::WeightingFill(Identifier &id, const PixelID* pixID, float
else if (bec == -4 && DBMC) DBMC->Fill(ld, pm, weight);
else if (bec == 0) {
if (m_doIBL) ld--;
- const int em = pixID->eta_module(id);
+ const int em = pixID->eta_module(id);
if (ld == 0 && B0) {
B0->Fill(em, pm, weight);
} else if (ld == 1 && B1) {
@@ -159,10 +97,12 @@ void PixelMon2DMapsLW::WeightingFill(Identifier &id, const PixelID* pixID, float
} else if (ld == -1 && IBL) {
int feid = 0;
int emf = 0;
+ bool copy = false;
if (em < 6 && em > -7) {
if (pixID->eta_index(id) >= 80) feid = 1;
emf = 2 * em + feid;
if (IBL2D) IBL2D->Fill(em, pm, weight);
+ copy = true;
} else if (em < -6) {
emf = em - 6;
if (IBL3D) IBL3D->Fill(em + 10, pm, weight);
@@ -171,9 +111,10 @@ void PixelMon2DMapsLW::WeightingFill(Identifier &id, const PixelID* pixID, float
if (IBL3D) IBL3D->Fill(em - 2, pm, weight);
}
IBL->Fill(emf, pm, weight);
+ if (m_copy2DFEval && copy) IBL->Fill(emf + 1, pm, weight);
}
}
-}
+}
void PixelMon2DMapsLW::Fill2DMon(PixelMon2DMapsLW* oldmap)
{
@@ -253,7 +194,7 @@ void PixelMon2DMapsLW::formatHist()
for (auto& hist : m_histograms) {
if (!hist) continue;
- if (hist == A || hist == C) {
+ if (hist.get() == A || hist.get() == C) {
hist->GetYaxis()->SetLabelSize(0.02);
} else {
hist->GetYaxis()->SetLabelSize(0.03);
@@ -262,19 +203,3 @@ void PixelMon2DMapsLW::formatHist()
hist->SetMinimum(0.);
}
}
-
-StatusCode PixelMon2DMapsLW::regHist(ManagedMonitorToolBase::MonGroup &group)
-{
- StatusCode sc = StatusCode::SUCCESS;
-
- for (auto& hist : m_histograms) {
- if (!hist) continue;
- if (group.regHist(hist).isFailure()) {
- sc = StatusCode::FAILURE;
- }
- }
-
- return sc;
-}
-
-const bool PixelMon2DMapsLW::m_doIBL{true};
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DProfilesLW.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DProfilesLW.cxx
index d7b9628d5468aea6237b4eb312448cc55382bf01..f69f52ce03b92ee80c8d07326b332b0252d87f22 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DProfilesLW.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMon2DProfilesLW.cxx
@@ -6,98 +6,77 @@
// Function to handle 2D profile histograms of modules, one for each region
///////////////////////////////////////////////////////////////////////////////
-#include "PixelMonitoring/Components.h"
-#include "PixelMonitoring/PixelMon2DProfilesLW.h"
#include "PixelMonitoring/PixelMon2DMapsLW.h"
+#include "PixelMonitoring/PixelMon2DProfilesLW.h"
+#include "PixelMonitoring/Components.h"
#include "InDetIdentifier/PixelID.h"
#include "LWHists/TH2F_LW.h"
#include "LWHists/TProfile2D_LW.h"
#include "GaudiKernel/StatusCode.h"
#include <string.h>
-PixelMon2DProfilesLW::PixelMon2DProfilesLW(std::string name, std::string title, const PixMon::HistConf& config, bool copy2DFEval)
- : IBL3D(nullptr),
- IBL2D(nullptr),
- IBL(nullptr),
- B0(nullptr),
- B1(nullptr),
- B2(nullptr),
- A(nullptr),
- C(nullptr),
- DBMA(nullptr),
- DBMC(nullptr),
- m_config(config),
- m_copy2DFEval(copy2DFEval)
-{
+PixelMon2DProfilesLW::PixelMon2DProfilesLW(std::string name, std::string title, const PixMon::HistConf& config, bool copy2DFEval) : HolderTemplate<TProfile2D_LW>(config, copy2DFEval) {
std::string setatext = ";shifted eta index of module";
std::string etatext = ";eta index of module";
std::string phitext = ";phi index of module";
std::string disktext = ";disk number";
std::string layertext = ";layer number";
- if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL3D)) {
- IBL3D = TProfile2D_LW::create((name+"_IBL3D").c_str(), (title + ", IBL 3D modules " + etatext + phitext).c_str(),
- PixMon::kNumModulesIBL3D, -.5, -.5 + PixMon::kNumModulesIBL3D,
- PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL);
+ if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL)) {
+ m_histograms.at(0).reset(TProfile2D_LW::create((name+"_IBL").c_str(), (title + ", IBL " + setatext + phitext).c_str(),
+ PixMon::kNumModulesIBL, -16.5, -16.5 + PixMon::kNumModulesIBL,
+ PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL));
}
if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL2D) ){
- IBL2D = TProfile2D_LW::create((name+"_IBL2D").c_str(), (title + ", IBL planar modules " + setatext + phitext).c_str(),
- PixMon::kNumModulesIBL2D, -6.5, -6.5 + PixMon::kNumModulesIBL2D,
- PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL);
+ m_histograms.at(1).reset(TProfile2D_LW::create((name+"_IBL2D").c_str(), (title + ", IBL planar modules " + setatext + phitext).c_str(),
+ PixMon::kNumModulesIBL2D, -6.5, -6.5 + PixMon::kNumModulesIBL2D,
+ PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL));
}
- if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL)) {
- IBL = TProfile2D_LW::create((name+"_IBL").c_str(), (title + ", IBL " + setatext + phitext).c_str(),
- PixMon::kNumModulesIBL, -16.5, -16.5 + PixMon::kNumModulesIBL,
- PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL);
+ if (m_doIBL && PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kIBL3D)) {
+ m_histograms.at(2).reset(TProfile2D_LW::create((name+"_IBL3D").c_str(), (title + ", IBL 3D modules " + etatext + phitext).c_str(),
+ PixMon::kNumModulesIBL3D, -.5, -.5 + PixMon::kNumModulesIBL3D,
+ PixMon::kNumStavesIBL, -0.5, -0.5 + PixMon::kNumStavesIBL));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB0)) {
- B0 = TProfile2D_LW::create((name+"_B0").c_str(), (title + ", B0 " + etatext + phitext).c_str(),
- PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
- PixMon::kNumStavesL0, -0.5, -0.5 + PixMon::kNumStavesL0);
+ m_histograms.at(3).reset(TProfile2D_LW::create((name+"_B0").c_str(), (title + ", B0 " + etatext + phitext).c_str(),
+ PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
+ PixMon::kNumStavesL0, -0.5, -0.5 + PixMon::kNumStavesL0));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB1)) {
- B1 = TProfile2D_LW::create((name+"_B1").c_str(), (title + ", B1 " + etatext + phitext).c_str(),
- PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
- PixMon::kNumStavesL1, -0.5, -0.5 + PixMon::kNumStavesL1);
+ m_histograms.at(4).reset(TProfile2D_LW::create((name+"_B1").c_str(), (title + ", B1 " + etatext + phitext).c_str(),
+ PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
+ PixMon::kNumStavesL1, -0.5, -0.5 + PixMon::kNumStavesL1));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kB2)) {
- B2 = TProfile2D_LW::create((name+"_B2").c_str(), (title + ", B2 " + etatext + phitext).c_str(),
- PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
- PixMon::kNumStavesL2, -0.5, -0.5 + PixMon::kNumStavesL2);
+ m_histograms.at(5).reset(TProfile2D_LW::create((name+"_B2").c_str(), (title + ", B2 " + etatext + phitext).c_str(),
+ PixMon::kNumModulesBarrel, -6.5, -6.5 + PixMon::kNumModulesBarrel,
+ PixMon::kNumStavesL2, -0.5, -0.5 + PixMon::kNumStavesL2));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECA)) {
- A = TProfile2D_LW::create((name+"_ECA" ).c_str(), (title + ", ECA " + disktext + phitext).c_str(),
- PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
- PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk);
+ m_histograms.at(6).reset(TProfile2D_LW::create((name+"_ECA" ).c_str(), (title + ", ECA " + disktext + phitext).c_str(),
+ PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
+ PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kECC)) {
- C = TProfile2D_LW::create((name+"_ECC" ).c_str(), (title + ", ECC " + disktext + phitext).c_str(),
- PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
- PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk);
+ m_histograms.at(7).reset(TProfile2D_LW::create((name+"_ECC" ).c_str(), (title + ", ECC " + disktext + phitext).c_str(),
+ PixMon::kNumLayersDisk, -0.5, -0.5 + PixMon::kNumLayersDisk,
+ PixMon::kNumModulesDisk, -0.5, -0.5 + PixMon::kNumModulesDisk));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMA)) {
- DBMA = TProfile2D_LW::create((name+"_DBMA").c_str(), (title + ", DBMA " + layertext + phitext).c_str(),
- PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
- PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM);
+ m_histograms.at(8).reset(TProfile2D_LW::create((name+"_DBMA").c_str(), (title + ", DBMA " + layertext + phitext).c_str(),
+ PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
+ PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM));
}
if (PixMon::HasComponent(m_config, PixMon::LayerIBL2D3DDBM::kDBMC)) {
- DBMC = TProfile2D_LW::create((name+"_DBMC").c_str(), (title + ", DBMC " + layertext + phitext).c_str(),
- PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
- PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM);
+ m_histograms.at(9).reset(TProfile2D_LW::create((name+"_DBMC").c_str(), (title + ", DBMC " + layertext + phitext).c_str(),
+ PixMon::kNumLayersDBM, -0.5, -0.5 + PixMon::kNumLayersDBM,
+ PixMon::kNumModulesDBM, -0.5, -0.5 + PixMon::kNumModulesDBM));
}
- m_histograms = {IBL, IBL2D, IBL3D, B0, B1, B2, A, C, DBMA, DBMC};
-
+ setHistogramPointers();
formatHist();
}
-PixelMon2DProfilesLW::~PixelMon2DProfilesLW()
-{
- for (auto& hist : m_histograms) {
- if (hist) LWHist::safeDelete(hist);
- }
-}
-
void PixelMon2DProfilesLW::SetMaxValue(float max)
{
for (auto& hist : m_histograms) {
@@ -214,7 +193,7 @@ void PixelMon2DProfilesLW::formatHist()
for (auto& hist : m_histograms) {
if (!hist) continue;
- if (hist == A || hist == C) {
+ if (hist.get() == A || hist.get() == C) {
hist->GetYaxis()->SetLabelSize(0.02);
} else {
hist->GetYaxis()->SetLabelSize(0.03);
@@ -254,9 +233,9 @@ void PixelMon2DProfilesLW::FillFromMap(PixelMon2DMapsLW* inputmap, bool clear_in
for (unsigned int x = 1; x <= hist->GetNbinsX(); x++) {
for (unsigned int y = 1; y <= hist->GetNbinsY(); y++) {
auto content = map->GetBinContent(x, y);
- if (hist == IBL || hist == IBL3D || hist == DBMA || hist == DBMC) {
+ if (hist.get() == IBL || hist.get() == IBL3D || hist.get() == DBMA || hist.get() == DBMC) {
content *= weightIBL;
- } else if (hist == IBL2D) {
+ } else if (hist.get() == IBL2D) {
content *= weightIBL * 0.5;
} else {
content *= weightPixel;
@@ -267,19 +246,3 @@ void PixelMon2DProfilesLW::FillFromMap(PixelMon2DMapsLW* inputmap, bool clear_in
if (clear_inputmap) map->Reset();
}
}
-
-StatusCode PixelMon2DProfilesLW::regHist(ManagedMonitorToolBase::MonGroup &group)
-{
- StatusCode sc = StatusCode::SUCCESS;
-
- for (auto& hist : m_histograms) {
- if (!hist) continue;
- if (group.regHist(hist).isFailure()) {
- sc = StatusCode::FAILURE;
- }
- }
-
- return sc;
-}
-
-const bool PixelMon2DProfilesLW::m_doIBL{true};
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMonModules.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMonModules.cxx
index 606ee96b65fb722d7364201c04ba7b4e9c36344d..50db27390ba7138a04f389f51b9f7408a122bbe4 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMonModules.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/PixelMonModules.cxx
@@ -14,10 +14,6 @@
#include "GaudiKernel/StatusCode.h"
#include <string.h>
-PixelMonModules::~PixelMonModules()
-{
-}
-
PixelMonModulesProf::PixelMonModulesProf(std::string name, std::string title, int nbins, double* arr)
{
m_nBins=nbins;
@@ -48,13 +44,6 @@ PixelMonModulesProf::PixelMonModulesProf(std::string name, std::string title, in
m_Dummy = 0;
}
-PixelMonModulesProf::~PixelMonModulesProf()
-{
- for (int i = 0; i < 2024; i++) {
- if (getHist(i)) LWHist::safeDelete(getHist(i));
- }
-}
-
PixelMonModules1D::PixelMonModules1D(std::string name, std::string title, int nbins, double* arr)
{
m_nBins = nbins;
@@ -85,13 +74,6 @@ PixelMonModules1D::PixelMonModules1D(std::string name, std::string title, int nb
m_Dummy = 0;
}
-PixelMonModules1D::~PixelMonModules1D()
-{
- for (int i=0; i < 2024; i++) {
- if (getHist(i)) delete getHist(i);
- }
-}
-
PixelMonModules2D::PixelMonModules2D(std::string name, std::string title, int nbins0, double low0, double high0, int nbins1, double low1, double high1)
{
m_nBins = nbins0 * nbins1;
@@ -107,13 +89,6 @@ PixelMonModules2D::PixelMonModules2D(std::string name, std::string title, int nb
m_Dummy = 0;
}
-PixelMonModules2D::~PixelMonModules2D()
-{
- for (int i = 0; i < 2024; i++) {
- if (getHist(i)) delete getHist(i);
- }
-}
-
void PixelMonModulesProf::Reset()
{
for (int i = 0; i < 2024; i++) {
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Status.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Status.cxx
index 4d64a8ffad036a28246de36a5c19698185558617..21002552b7786d29c5be282c02fbd553d61d79b3 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Status.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Status.cxx
@@ -46,24 +46,24 @@ StatusCode PixelMainMon::BookStatusMon(void)
StatusCode sc;
- m_status = new PixelMon2DProfilesLW("Map_Of_Modules_Status", ("Modules Status (0=Active+Good, 1=Active+Bad, 2=Inactive)" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_status = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("Map_Of_Modules_Status", ("Modules Status (0=Active+Good, 1=Active+Bad, 2=Inactive)" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_status->regHist(statusHistos);
m_status->SetMaxValue( 2.0 );
- m_status_mon = new PixelMon2DProfilesLW("Map_Of_Modules_Status_Mon", ("Modules Status (0=Active+Good, 1=Active+Bad, 2=Inactive) for monitoring" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_status_mon = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("Map_Of_Modules_Status_Mon", ("Modules Status (0=Active+Good, 1=Active+Bad, 2=Inactive) for monitoring" + m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_status_mon->regHist(statusHistos);
m_status_mon->SetMaxValue( 2.0 );
if (m_doModules)
{
- m_Status_modules = new PixelMonModules1D("Status_of_Module", ("Module Status (0=Active+Good, 1=Active+Bad, 2=Inactive)" + m_histTitleExt + ";Status").c_str(),2,0,2);
+ m_Status_modules = std::make_unique<PixelMonModules1D>(PixelMonModules1D("Status_of_Module", ("Module Status (0=Active+Good, 1=Active+Bad, 2=Inactive)" + m_histTitleExt + ";Status").c_str(),2,0,2));
sc = m_Status_modules->regHist(this, (path+"/Modules_Status").c_str(),run);
m_Status_modules->SetBinLabel( "Status",2 );
m_Status_modules->formatHist("status");
}
if (m_doOffline)
{
- m_dqStatus = new PixelMon2DMapsLW("Ok_modules", ("module problems, empty bin means dead module not listed in status database"+ m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D);
+ m_dqStatus = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("Ok_modules", ("module problems, empty bin means dead module not listed in status database"+ m_histTitleExt).c_str(), PixMon::HistConf::kPixDBMIBL2D3D));
sc = m_dqStatus->regHist(statusHistos);
}
@@ -106,7 +106,7 @@ StatusCode PixelMainMon::BookStatusLumiBlockMon(void)
if (m_doOnTrack) path.replace(path.begin(), path.end(), "Pixel/LumiBlockOnTrack");
MonGroup lumiBlockHist(this, path.c_str(), lowStat, ATTRIB_MANAGED);
- m_status_LB = new PixelMon2DProfilesLW("Map_Of_Modules_Status_LB", ("Module Status (0=Active+Good, 1=Active+Bad, 2=Inactive)"+ m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true);
+ m_status_LB = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("Map_Of_Modules_Status_LB", ("Module Status (0=Active+Good, 1=Active+Bad, 2=Inactive)"+ m_histTitleExt).c_str(), PixMon::HistConf::kPixIBL2D3D, true));
StatusCode sc = m_status_LB->regHist(lumiBlockHist);
m_status_LB->SetMaxValue( 2.0 );
diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Track.cxx b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Track.cxx
index b16e89dd2ba423774a65670272d5f3c125c354bb..e9e8c60ebef58b9dcf22a7b73a52abab9fa67140 100644
--- a/InnerDetector/InDetMonitoring/PixelMonitoring/src/Track.cxx
+++ b/InnerDetector/InDetMonitoring/PixelMonitoring/src/Track.cxx
@@ -105,33 +105,33 @@ StatusCode PixelMainMon::BookTrackMon(void)
if (m_LorentzAngle_B2) m_LorentzAngle_B2->SetOption("colz");
if (m_do2DMaps && !m_doOnline) {
- m_tsos_hitmap = new PixelMon2DMapsLW("TSOS_Measurement", ("TSOS of type Measurement" + m_histTitleExt), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_tsos_hitmap = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("TSOS_Measurement", ("TSOS of type Measurement" + m_histTitleExt), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_tsos_hitmap->regHist(trackHistos);
- m_tsos_holemap = new PixelMon2DMapsLW("TSOS_Hole", ("TSOS of type Hole" + m_histTitleExt), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_tsos_holemap = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("TSOS_Hole", ("TSOS of type Hole" + m_histTitleExt), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_tsos_holemap->regHist(trackHistos);
- m_tsos_outliermap = new PixelMon2DMapsLW("TSOS_Outlier", ("TSOS of type Outlier" + m_histTitleExt), PixMon::HistConf::kPixDBMIBL2D3D, true);
+ m_tsos_outliermap = std::make_unique<PixelMon2DMapsLW>(PixelMon2DMapsLW("TSOS_Outlier", ("TSOS of type Outlier" + m_histTitleExt), PixMon::HistConf::kPixDBMIBL2D3D, true));
sc = m_tsos_outliermap->regHist(trackHistos);
- //m_tsos_measratio = new PixelMon2DProfilesLW("TSOS_MeasRatio", ("TSOS of type Meas per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true);
+ //m_tsos_measratio = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("TSOS_MeasRatio", ("TSOS of type Meas per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true));
//sc = m_tsos_measratio->regHist(trackHistos);
- //m_tsos_holeratio = new PixelMon2DProfilesLW("TSOS_HoleRatio", ("TSOS of type Hole per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true);
+ //m_tsos_holeratio = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("TSOS_HoleRatio", ("TSOS of type Hole per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true));
//sc = m_tsos_holeratio->regHist(trackHistos);
- //m_misshits_ratio = new PixelMon2DProfilesLW("MissHitsRatioOnTrack", ("Hole+Outlier per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true);
+ //m_misshits_ratio = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("MissHitsRatioOnTrack", ("Hole+Outlier per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true));
//sc = m_misshits_ratio->regHist(trackHistos);
}
if (m_doOnline) {
- m_tsos_holeratio_tmp = new PixelMon2DProfilesLW("HoleRatio_tmp", ("TSOS of type Hole per track tmp" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true);
+ m_tsos_holeratio_tmp = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("HoleRatio_tmp", ("TSOS of type Hole per track tmp" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_tsos_holeratio_tmp->regHist(trackHistos);
- m_tsos_holeratio_mon = new PixelMon2DProfilesLW("HoleRatio_mon", ("TSOS of type Hole per track for monitoring" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true);
+ m_tsos_holeratio_mon = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("HoleRatio_mon", ("TSOS of type Hole per track for monitoring" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_tsos_holeratio_mon->regHist(trackHistos);
- m_misshits_ratio_tmp = new PixelMon2DProfilesLW("MissHitsRatioOnTrack_tmp", ("Hole+Outlier per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true);
+ m_misshits_ratio_tmp = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("MissHitsRatioOnTrack_tmp", ("Hole+Outlier per track" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_misshits_ratio_tmp->regHist(trackHistos);
- m_misshits_ratio_mon = new PixelMon2DProfilesLW("MissHitsRatioOnTrack_mon", ("Hole+Outlier per track for monitoring" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true);
+ m_misshits_ratio_mon = std::make_unique<PixelMon2DProfilesLW>(PixelMon2DProfilesLW("MissHitsRatioOnTrack_mon", ("Hole+Outlier per track for monitoring" + m_histTitleExt), PixMon::HistConf::kPixIBL2D3D, true));
sc = m_misshits_ratio_mon->regHist(trackHistos);
}
if (m_doModules && !m_doOnTrack) { // tbc essentially code weren't used since doModules was enabled only for AllHits; to keep it disabled also now !m_doOnTrack switch was added
- m_tsos_hiteff_vs_lumi = new PixelMonModulesProf("TSOS_HitEfficiency",("TSOS-based hit efficiency in module" + m_histTitleExt).c_str(),2500,-0.5,2499.5);
+ m_tsos_hiteff_vs_lumi = std::make_unique<PixelMonModulesProf>(PixelMonModulesProf("TSOS_HitEfficiency",("TSOS-based hit efficiency in module" + m_histTitleExt).c_str(),2500,-0.5,2499.5));
sc = m_tsos_hiteff_vs_lumi->regHist(this,(path+"/Modules_TSOSHitEff").c_str(),run);
if (!m_doOnline) {
sc=trackHistos.regHist(m_clustot_lowpt = TH1F_LW::create("m_clustot_lowpt",("Cluster ToT vs Track pT (pT<10GeV)" + m_histTitleExt + "; Track pT; Cluster ToT (on track)").c_str(),250,0,250));
@@ -511,8 +511,8 @@ StatusCode PixelMainMon::FillTrackMon(void)
if (m_doOnline) {
if (m_doRefresh5min) {
- if (m_tsos_holeratio_mon && m_tsos_holeratio_tmp) m_tsos_holeratio_mon->Fill2DMon(m_tsos_holeratio_tmp);
- if (m_misshits_ratio_mon && m_misshits_ratio_tmp) m_misshits_ratio_mon->Fill2DMon(m_misshits_ratio_tmp);
+ if (m_tsos_holeratio_mon && m_tsos_holeratio_tmp) m_tsos_holeratio_mon->Fill2DMon(m_tsos_holeratio_tmp.get());
+ if (m_misshits_ratio_mon && m_misshits_ratio_tmp) m_misshits_ratio_mon->Fill2DMon(m_misshits_ratio_tmp.get());
}
}