diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTErrMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTErrMonTool.h
index 6066a5abbe26b88d1a82ae5b11dcc3592520d1e9..5a4a65a4c6c8df9a353957ee490d66c907166126 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTErrMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTErrMonTool.h
@@ -13,22 +13,22 @@
#ifndef SCTERRMONTOOL_H
#define SCTERRMONTOOL_H
#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include <string>
-#include <vector>
-#include <map>
-#include <utility>
-//for CondDB
#include "InDetConditionsSummaryService/IInDetConditionsTool.h"
+#include "InDetRawData/SCT_RDO_Container.h"
#include "SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h"
#include "SCT_ConditionsTools/ISCT_ByteStreamErrorsTool.h"
#include "SCT_ConditionsTools/ISCT_DCSConditionsTool.h"
#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
-
#include "StoreGate/ReadHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
-#include "InDetRawData/SCT_RDO_Container.h"
+
+#include "GaudiKernel/ServiceHandle.h"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <utility>
/** Forward declarations*/
class IInterface;
@@ -58,12 +58,12 @@ class SCTErrMonTool : public ManagedMonitorToolBase
typedef std::map< IdentifierHash, moduleGeo_t > geoContainer_t;
public:
- SCTErrMonTool(const std::string & type,const std::string & name,const IInterface* parent);
+ SCTErrMonTool(const std::string& type,const std::string& name,const IInterface* parent);
virtual ~SCTErrMonTool();
//
/** @name Methods reimplemented from baseclass */
//@{
- //initialize 11.09.2016
+ //initialize
virtual StatusCode initialize() final;
//book
virtual StatusCode bookHistograms() final;
@@ -71,7 +71,7 @@ class SCTErrMonTool : public ManagedMonitorToolBase
virtual StatusCode fillHistograms() final;
//post processing
virtual StatusCode procHistograms() final;
- //Recurrent 11.09.2016
+ //Recurrent
virtual StatusCode bookHistogramsRecurrent() final;
//book
virtual StatusCode copyHistograms() final;
@@ -80,7 +80,7 @@ class SCTErrMonTool : public ManagedMonitorToolBase
private:
static const int NREGIONS_INC_GENERAL=SCT_Monitoring::N_REGIONS+1;
- typedef TProfile2D_LW * Prof2_t;
+ typedef TProfile2D_LW* Prof2_t;
typedef std::vector<Prof2_t> VecProf2_t;
StatusCode checkRateHists();
StatusCode fillByteStreamErrors();
@@ -92,8 +92,8 @@ class SCTErrMonTool : public ManagedMonitorToolBase
//@name Histograms related members
//@{
// Pointers to hit error histograms
- TH1F_LW * m_firstHit[NREGIONS_INC_GENERAL];
- TH1F_LW * m_secondHit[NREGIONS_INC_GENERAL];
+ TH1F_LW* m_firstHit[NREGIONS_INC_GENERAL];
+ TH1F_LW* m_secondHit[NREGIONS_INC_GENERAL];
//@}
enum CategoryErrors { MASKEDLINKALL=0, SUMMARY, BADERR, LINKLEVEL, RODLEVEL, MASKEDCHIP, N_ERRCATEGORY};
@@ -125,13 +125,13 @@ class SCTErrMonTool : public ManagedMonitorToolBase
TH2F_LW* m_numErrorsPerLumi[NREGIONS_INC_GENERAL];
TProfile2D_LW* m_rateErrorsPerLumi[NREGIONS_INC_GENERAL];
- TH1I *m_nErrors;
- TH1I *m_nLinksWithErrors;
- int *m_nErrors_buf;
- int *m_nLinksWithErrors_buf;
+ TH1I* m_nErrors;
+ TH1I* m_nLinksWithErrors;
+ int* m_nErrors_buf;
+ int* m_nLinksWithErrors_buf;
int m_nErrors_pos;
- TH1I *m_MaskedAllLinks; // maskedLinks||maskedRODs
+ TH1I* m_MaskedAllLinks; // maskedLinks||maskedRODs
//Count number of events
int m_numberOfEventsLumi;
@@ -147,14 +147,13 @@ class SCTErrMonTool : public ManagedMonitorToolBase
int fillByteStreamErrorsHelper(const std::set<IdentifierHash>* errors, TH2F_LW* histo[SCT_ByteStreamErrors::NUM_ERROR_TYPES][NREGIONS_INC_GENERAL][SCT_Monitoring::N_ENDCAPSx2], bool lumi2DHist, int err_type);
void numByteStreamErrors(const std::set<IdentifierHash>* errors, int& ntot, int& nbar, int& neca, int& necc);
- StatusCode bookErrHistosHelper(MonGroup & mg, TString name, TString title, TString titlehitmap, TProfile2D_LW* &tprof, TH2F_LW* &th, const int layer, const bool barrel=true);
+ StatusCode bookErrHistosHelper(MonGroup& mg, TString name, TString title, TString titlehitmap, TProfile2D_LW*& tprof, TH2F_LW*& th, const int layer, const bool barrel=true);
- StatusCode bookErrHistosHelper(MonGroup & mg, TString name, TString title, TProfile2D_LW* &tprof, const int layer, const bool barrel=true);
+ StatusCode bookErrHistosHelper(MonGroup& mg, TString name, TString title, TProfile2D_LW*& tprof, const int layer, const bool barrel=true);
- std::vector<TH2F_LW *> m_p2DmapHistoVectorAll[NREGIONS_INC_GENERAL];
+ std::vector<TH2F_LW*> m_p2DmapHistoVectorAll[NREGIONS_INC_GENERAL];
/// "Magic numbers" for an SCT module
- //unsigned int m_nplanes; //to be determined from SCT Helper
enum { Confbins = 6, ConfbinsDetailed = 5 };
// NOTE: The following is not the usual index order, which goes C, Barrel, A
enum {iECm=0, iBARREL=1, iECp=2, iGEN=3 }; //iECp==EA, iECm==EC
@@ -207,28 +206,28 @@ class SCTErrMonTool : public ManagedMonitorToolBase
StatusCode resetConfigurationDetails();
/// Pointer to 1D histogram of Number of SCT Clusters per LBs
- TProfile_LW * m_Conf[NREGIONS_INC_GENERAL];
- TProfile_LW * m_ConfRN[NREGIONS_INC_GENERAL];
- TProfile_LW * m_ConfNew[NREGIONS_INC_GENERAL];
- TProfile_LW * m_ConfOutModules[NREGIONS_INC_GENERAL];
- TProfile_LW * m_ConfOnline[NREGIONS_INC_GENERAL];
+ TProfile_LW* m_Conf[NREGIONS_INC_GENERAL];
+ TProfile_LW* m_ConfRN[NREGIONS_INC_GENERAL];
+ TProfile_LW* m_ConfNew[NREGIONS_INC_GENERAL];
+ TProfile_LW* m_ConfOutModules[NREGIONS_INC_GENERAL];
+ TProfile_LW* m_ConfOnline[NREGIONS_INC_GENERAL];
- TProfile_LW * m_ByteStreamVsLB[SCT_ByteStreamErrors::NUM_ERROR_TYPES][NREGIONS_INC_GENERAL];
- TProfile_LW * m_ByteStreamWithSctFlagVsLB[SCT_ByteStreamErrors::NUM_ERROR_TYPES][NREGIONS_INC_GENERAL];
- TProfile_LW * m_ByteStreamCategorisedVsLB[CategoryErrors::N_ERRCATEGORY][NREGIONS_INC_GENERAL];
- TProfile_LW * m_LinksWithCategorisedErrorsVsLB[CategoryErrors::N_ERRCATEGORY][NREGIONS_INC_GENERAL];
- TProfile_LW * m_LinksWithCategorisedErrorsVsLBLayer[CategoryErrors::N_ERRCATEGORY][NREGIONS_INC_GENERAL][SCT_Monitoring::N_DISKSx2];
+ TProfile_LW* m_ByteStreamVsLB[SCT_ByteStreamErrors::NUM_ERROR_TYPES][NREGIONS_INC_GENERAL];
+ TProfile_LW* m_ByteStreamWithSctFlagVsLB[SCT_ByteStreamErrors::NUM_ERROR_TYPES][NREGIONS_INC_GENERAL];
+ TProfile_LW* m_ByteStreamCategorisedVsLB[CategoryErrors::N_ERRCATEGORY][NREGIONS_INC_GENERAL];
+ TProfile_LW* m_LinksWithCategorisedErrorsVsLB[CategoryErrors::N_ERRCATEGORY][NREGIONS_INC_GENERAL];
+ TProfile_LW* m_LinksWithCategorisedErrorsVsLBLayer[CategoryErrors::N_ERRCATEGORY][NREGIONS_INC_GENERAL][SCT_Monitoring::N_DISKSx2];
- TProfile_LW * m_LinksWithRODErrorsVsLB_check[NREGIONS_INC_GENERAL];
+ TProfile_LW* m_LinksWithRODErrorsVsLB_check[NREGIONS_INC_GENERAL];
- TH1F_LW * m_NumberOfSCTFlagErrorsVsLB;
- TH1F_LW * m_NumberOfEventsVsLB;
- TProfile_LW * m_FractionOfSCTFlagErrorsPerLB;
+ TH1F_LW* m_NumberOfSCTFlagErrorsVsLB;
+ TH1F_LW* m_NumberOfEventsVsLB;
+ TProfile_LW* m_FractionOfSCTFlagErrorsPerLB;
- TProfile * m_ConfEffOnline;
- TProfile_LW * m_ConfNoiseOnline;
- TProfile_LW * m_ConfNoiseOnlineRecent;
- TProfile_LW * m_DetailedConfiguration;
+ TProfile* m_ConfEffOnline;
+ TProfile_LW* m_ConfNoiseOnline;
+ TProfile_LW* m_ConfNoiseOnlineRecent;
+ TProfile_LW* m_DetailedConfiguration;
/** a handle on the Hist/TTree registration service */
ServiceHandle<ITHistSvc> m_thistSvc;
@@ -254,7 +253,7 @@ class SCTErrMonTool : public ManagedMonitorToolBase
//@}
Prof2_t
- prof2Factory(const std::string & name, const std::string & title, const unsigned int&, VecProf2_t & storageVector);
+ prof2Factory(const std::string& name, const std::string& title, const unsigned int&, VecProf2_t& storageVector);
bool syncDisabledSCT();
bool syncErrorSCT();
@@ -263,7 +262,7 @@ class SCTErrMonTool : public ManagedMonitorToolBase
bool eventVsWafer();
void fillWafer( moduleGeo_t module, TH2F* histo );
- double calculateDetectorCoverage(const TH2F * histo );
+ double calculateDetectorCoverage(const TH2F* histo );
enum ProblemForCoverage {
all, //All SCT module for counting good module
@@ -278,15 +277,15 @@ class SCTErrMonTool : public ManagedMonitorToolBase
std::vector<moduleGeo_t> m_geo;
std::set<IdentifierHash> m_SCTHash[numberOfProblemForCoverage];
- TH2F * m_mapSCT[numberOfProblemForCoverage];
+ TH2F* m_mapSCT[numberOfProblemForCoverage];
const unsigned int m_nBinsEta;
const double m_rangeEta;
const unsigned int m_nBinsPhi;
const double m_WafersThreshold;
- TProfile * m_detectorCoverageVsLbs[numberOfProblemForCoverage];
- TProfile * m_PSTripModulesVsLbs;
+ TProfile* m_detectorCoverageVsLbs[numberOfProblemForCoverage];
+ TProfile* m_PSTripModulesVsLbs;
float m_PSTripModules;
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitEffMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitEffMonTool.h
index 6fc600cf11aa8884599965c419888e694ef6da0b..13a9801d673a422772ca9faf223fa8fe90f87060 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitEffMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitEffMonTool.h
@@ -11,42 +11,35 @@
#ifndef SCTEFFICIENCYTOOL_H
#define SCTEFFICIENCYTOOL_H
-//STL
-#include <string>
-#include <array>
-
-//Gaudi
-#include "GaudiKernel/ToolHandle.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "MagFieldInterfaces/IMagFieldSvc.h"
-//Athena
#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-//cannot fwd declare due to typedefs
-#include "TrkTrack/Track.h"
-#include "TrkTrack/TrackCollection.h"
-#include "TrkToolInterfaces/ITrackHoleSearchTool.h"
-#include "TrkToolInterfaces/IResidualPullCalculator.h"
-#include "TrkToolInterfaces/IRIO_OnTrackCreator.h"
-
-#include "TrigAnalysisInterfaces/IBunchCrossingTool.h"
-
-//SCT
-#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
-
-//
+#include "CommissionEvent/ComTime.h"
#include "InDetPrepRawData/SCT_ClusterContainer.h"
-
+#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
+#include "MagFieldInterfaces/IMagFieldSvc.h"
+#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
-#include "CommissionEvent/ComTime.h"
-#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
+#include "TrigAnalysisInterfaces/IBunchCrossingTool.h"
+#include "TrkToolInterfaces/ITrackHoleSearchTool.h"
+#include "TrkToolInterfaces/IResidualPullCalculator.h"
+#include "TrkToolInterfaces/IRIO_OnTrackCreator.h"
+#include "TrkTrack/Track.h"
+#include "TrkTrack/TrackCollection.h"
#include "xAODEventInfo/EventInfo.h"
+//Gaudi
+#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/ServiceHandle.h"
+
//ROOT
#include "TString.h"
+//STL
+#include <string>
+#include <array>
+
class Identifier;
class PixelID;
class SCT_ID;
@@ -77,7 +70,7 @@ class SCTHitEffMonTool : public ManagedMonitorToolBase {
public:
typedef Trk::Track Track;
/** Constructor */
- SCTHitEffMonTool (const std::string &type, const std::string &name, const IInterface* parent);
+ SCTHitEffMonTool (const std::string& type, const std::string& name, const IInterface* parent);
/** Destructor */
virtual ~SCTHitEffMonTool () = default;
@@ -97,37 +90,37 @@ private:
StatusCode failCut (Bool_t value, std::string name);
/** Method to compute incident angle of track to wafer */
- StatusCode findAnglesToWaferSurface (const Amg::Vector3D &mom, const Identifier id,
+ StatusCode findAnglesToWaferSurface (const Amg::Vector3D& mom, const Identifier id,
const InDetDD::SiDetectorElementCollection* elements,
- Double_t &theta, Double_t &phi);
+ Double_t& theta, Double_t& phi);
/** Method to find the chip just before a given hit */
Int_t previousChip (Double_t xl, Int_t side, bool swap);
/** Computes residual of a hit to a track */
Double_t getResidual (const Identifier& surfaceID,
- const Trk::TrackParameters * trkParam,
+ const Trk::TrackParameters* trkParam,
const InDet::SCT_ClusterContainer* p_sctclcontainer);
/** Single histogram booking method */
- template < class T > StatusCode bookEffHisto (T*& histo, MonGroup & MG,
+ template < class T > StatusCode bookEffHisto (T*& histo, MonGroup& MG,
TString name, TString title,
Int_t nbin, Double_t x1, Double_t x2);
- template < class T > StatusCode bookEffHisto (T*& histo, MonGroup & MG,
+ template < class T > StatusCode bookEffHisto (T*& histo, MonGroup& MG,
TString name, TString title,
Int_t nbinx, Double_t x1, Double_t x2,
Int_t nbiny, Double_t y1, Double_t y2);
- template < class T > StatusCode bookEffHisto (T*& histo, MonGroup & MG,
+ template < class T > StatusCode bookEffHisto (T*& histo, MonGroup& MG,
TString name, TString title,
- Int_t nbinx, Double_t * xbins,
- Int_t nbiny, Double_t * ybins);
+ Int_t nbinx, Double_t* xbins,
+ Int_t nbiny, Double_t* ybins);
SG::ReadHandle<TrackCollection> m_TrackName;
- IChronoStatSvc * m_chrono;
+ IChronoStatSvc* m_chrono;
- const std::map < Identifier, unsigned int > * m_badChips;
+ const std::map < Identifier, unsigned int >* m_badChips;
ServiceHandle<MagField::IMagFieldSvc> m_fieldServiceHandle;
ToolHandle<Trig::IBunchCrossingTool> m_bunchCrossingTool;
@@ -178,21 +171,21 @@ private:
typedef std::array < TH2F*, SCT_Monitoring::N_REGIONS > TH2FArray;
typedef std::array < std::array < TH2F*, SCT_Monitoring::N_ENDCAPS >, SCT_Monitoring::N_REGIONS > TH2FArrayLayer;
- std::array < std::array < TProfile2D *, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_effMap;
- std::array < std::array < TProfile2D *, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_effMapFirstBCID;
- std::array < std::array < TProfile2D *, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_ineffMap;
- std::array < std::array < TProfile *, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_effLumiBlock;
- std::array < TProfile2D *, SCT_Monitoring::N_LAYERS_TOTAL > m_accMap;
- std::array < TProfile2D *, SCT_Monitoring::N_LAYERS_TOTAL > m_accPhysMap;
- std::array < std::array < TProfile2D *, SCT_Monitoring::N_ENDCAPSx2 >, SCT_Monitoring::N_REGIONS > m_layerResidualHistos;
-
- TProfile * m_Eff_Total;
- TProfile * m_Eff_TotalBCID;
- TProfile * m_Eff_hashCodeHisto;
- TProfile * m_Eff_LumiBlockHisto_Total;
+ std::array < std::array < TProfile2D*, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_effMap;
+ std::array < std::array < TProfile2D*, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_effMapFirstBCID;
+ std::array < std::array < TProfile2D*, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_ineffMap;
+ std::array < std::array < TProfile*, 2 >, SCT_Monitoring::N_LAYERS_TOTAL > m_effLumiBlock;
+ std::array < TProfile2D*, SCT_Monitoring::N_LAYERS_TOTAL > m_accMap;
+ std::array < TProfile2D*, SCT_Monitoring::N_LAYERS_TOTAL > m_accPhysMap;
+ std::array < std::array < TProfile2D*, SCT_Monitoring::N_ENDCAPSx2 >, SCT_Monitoring::N_REGIONS > m_layerResidualHistos;
+
+ TProfile* m_Eff_Total;
+ TProfile* m_Eff_TotalBCID;
+ TProfile* m_Eff_hashCodeHisto;
+ TProfile* m_Eff_LumiBlockHisto_Total;
TH1F* m_effdistribution;
- TProfile2D * m_effHashLumiB;
+ TProfile2D* m_effHashLumiB;
TProfArray m_Eff_summaryHisto;
TProfArray m_Eff_summaryHistoFirstBCID;
@@ -232,8 +225,8 @@ private:
TProfArray m_Eff_nTrk;
TProfArray m_Eff_nGoodTrk;
- std::array < TProfile2D *, SCT_Monitoring::N_REGIONS > m_inEffStrip;
- std::array < TProfile2D *, SCT_Monitoring::N_REGIONS > m_inEffChip;
+ std::array < TProfile2D*, SCT_Monitoring::N_REGIONS > m_inEffStrip;
+ std::array < TProfile2D*, SCT_Monitoring::N_REGIONS > m_inEffChip;
TH1FArray m_EventHisto;
TH1FArray m_SelectionHisto;
@@ -254,18 +247,24 @@ private:
TH1FArray m_chi2Histo;
TH1FArray m_localHitXHisto, m_localHitYHistos;
- TH1F * m_mNHitHisto, *m_barrelNHitHisto, *m_pNHitHisto;
- TH1F * m_SCTNHitHisto, *m_trtNHitHisto, *m_pixelNHitHisto;
- TH1F * m_PtTkHisto;
- TH1F * m_etaTkHisto;
- TH1F * m_d0TkHisto;
- TH1F * m_d0PrecTkHisto;
- TH1F * m_nTrkHisto, * m_nTrkParsHisto, * m_nTrkGoodHisto;
- TH1F * m_LumiBlock;
- TH1F * m_z0TkHisto;
- TH1F * m_hashCodeHisto;
-
- TH2I * m_badModFineMap;
+ TH1F* m_mNHitHisto;
+ TH1F* m_barrelNHitHisto;
+ TH1F* m_pNHitHisto;
+ TH1F* m_SCTNHitHisto;
+ TH1F* m_trtNHitHisto;
+ TH1F* m_pixelNHitHisto;
+ TH1F* m_PtTkHisto;
+ TH1F* m_etaTkHisto;
+ TH1F* m_d0TkHisto;
+ TH1F* m_d0PrecTkHisto;
+ TH1F* m_nTrkHisto;
+ TH1F* m_nTrkParsHisto;
+ TH1F* m_nTrkGoodHisto;
+ TH1F* m_LumiBlock;
+ TH1F* m_z0TkHisto;
+ TH1F* m_hashCodeHisto;
+
+ TH2I* m_badModFineMap;
TH2FArray m_localHitHisto, m_localMissHisto, m_localUnasHisto;
TH2FArray m_localHitGHisto;
@@ -278,13 +277,13 @@ private:
TH2FArrayLayer m_xlResidualE1Histo;
TH2FArrayLayer m_xlResidualUnasHisto;
- TGraphErrors * m_badModMap;
- TGraphErrors * m_badChipMap;
+ TGraphErrors* m_badModMap;
+ TGraphErrors* m_badChipMap;
Int_t m_countEvent;
- const PixelID * m_pixelId;
- const SCT_ID * m_sctId;
- const TRT_ID * m_trtId;
+ const PixelID* m_pixelId;
+ const SCT_ID* m_sctId;
+ const TRT_ID* m_trtId;
SG::ReadHandleKey<ComTime> m_comTimeName;
SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoKey;
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitsNoiseMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitsNoiseMonTool.h
index 4a6d91a97b7a87178a426a70f453a4ad6892f082..722645b925c4dc0a0beeb310132753df80bf9476 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitsNoiseMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTHitsNoiseMonTool.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
/** @file SCTHitsNoiseMonTool.h
@@ -18,24 +18,22 @@
#ifndef SCTHITSNOISEMONTOOL_H
#define SCTHITSNOISEMONTOOL_H
-#include <string>
-#include <vector>
-#include <map>
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
#include "SCT_Monitoring/SCTMotherTrigMonTool.h"
-#include "TrkTrack/Track.h"
-#include "TrkTrack/TrackCollection.h"
-
+#include "InDetRawData/SCT_RDO_Container.h"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
+#include "InDetPrepRawData/SCT_ClusterContainer.h"
+#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
#include "StoreGate/ReadCondHandleKey.h"
-
#include "StoreGate/ReadHandleKey.h"
#include "TrkSpacePoint/SpacePointContainer.h"
-#include "InDetRawData/SCT_RDO_Container.h"
+#include "TrkTrack/Track.h"
+#include "TrkTrack/TrackCollection.h"
#include "xAODEventInfo/EventInfo.h"
-#include "InDetPrepRawData/SCT_ClusterContainer.h"
+
+#include <string>
+#include <vector>
+#include <map>
// Forward declarations
class IInterface;
@@ -61,7 +59,7 @@ class PairBuilder;
class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
public:
typedef unsigned int ChipNumberType;
- SCTHitsNoiseMonTool(const std::string & type, const std::string & name,const IInterface* parent);
+ SCTHitsNoiseMonTool(const std::string& type, const std::string& name,const IInterface* parent);
~SCTHitsNoiseMonTool();
virtual StatusCode initialize() final;
/** @name Book, fill & check (reimplemented from baseclass) */
@@ -80,12 +78,12 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
//@}
private:
- typedef TProfile2D * Prof2_t;
- typedef TProfile_LW * Prof_t;
- typedef TH1I * H1I_t;
- typedef TH2I_LW * H2I_t;
- typedef TH1F_LW * H1_t;
- typedef TH2F_LW * H2_t;
+ typedef TProfile2D* Prof2_t;
+ typedef TProfile_LW* Prof_t;
+ typedef TH1I* H1I_t;
+ typedef TH2I_LW* H2I_t;
+ typedef TH1F_LW* H1_t;
+ typedef TH2F_LW* H2_t;
typedef std::vector<Prof2_t> VecProf2_t;
typedef std::vector<H1I_t> VecH1I_t;
typedef std::vector<H2I_t> VecH2I_t;
@@ -116,17 +114,17 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
VecProf2_t m_pnoiseoccupancymapHistoVectorECmTrigger;
TH1F* m_nSP;
- int *m_nSP_buf;
+ int* m_nSP_buf;
int m_nSP_pos;
TH1F* m_nHits;
- int *m_nHits_buf;
+ int* m_nHits_buf;
int m_nHits_pos;
TH1F* m_nmaxHits;
- int *m_nmaxHits_buf;
- Identifier *m_nmaxModule_buf;
+ int* m_nmaxHits_buf;
+ Identifier* m_nmaxModule_buf;
TH1F* m_nminHits;
- int *m_nminHits_buf;
- Identifier *m_nminModule_buf;
+ int* m_nminHits_buf;
+ Identifier* m_nminModule_buf;
//Histograms with hits per luminosity block
H1_t m_numBarrelHitsPerLumiBlock;
@@ -322,7 +320,7 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
StatusCode bookGeneralNoiseOccupancyMaps( const unsigned int systemIndex);
//Book hit occupancy map histograms
StatusCode bookGeneralHitOccupancyMaps( const unsigned int systemIndex);
-
+
// Book Hits Histograms
StatusCode
bookGeneralHits( const unsigned int systemIndex);
@@ -372,7 +370,6 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
int m_occTriggerECm_lb[SCT_Monitoring::NBINS_LBs+1];
int m_eventsTrigger_lb;
- //Added 09.09.2016
VecProf2_t m_phitoccupancymapHistoVector;
VecProf2_t m_phitoccupancymapHistoVectorRecent;
VecProf2_t m_phitoccupancymapHistoVectorTrigger;
@@ -382,7 +379,7 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
VecProf2_t m_phitoccupancymapHistoVectorECm;
VecProf2_t m_phitoccupancymapHistoVectorECmRecent;
VecProf2_t m_phitoccupancymapHistoVectorECmTrigger;
-
+
//Histograms with HO distribution
TH1F* m_BARHO;
TH1F* m_BARHOTrigger;
@@ -392,7 +389,7 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
TH1F* m_ECpHOTrigger;
TH1F* m_SCTHO;
TH1F* m_SCTHOTrigger;
-
+
//---- results required no triggers
// # of hits vs LBs
Prof_t m_HallHitsBAR_vsLB;
@@ -430,7 +427,7 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
std::map<Identifier, float> m_hitoccSumUnbiased;
std::map<Identifier, float> m_hitoccSumUnbiasedTrigger;
std::map<Identifier, float> m_hitoccSumUnbiasedRecent;
-
+
std::map<Identifier, float> m_hitoccSumUnbiased_lb;
std::map<Identifier, float> m_hitoccSumUnbiasedBAR_lb;
std::map<Identifier, float> m_hitoccSumUnbiasedECp_lb;
@@ -483,27 +480,27 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
///Determines whether a local summary is written
int m_localSummary;
H1_t
- h1Factory(const std::string & name, const std::string & title, MonGroup & registry, VecH1_t & storageVector, const float lo, const float hi, const unsigned int nbins);
+ h1Factory(const std::string& name, const std::string& title, MonGroup& registry, VecH1_t& storageVector, const float lo, const float hi, const unsigned int nbins);
H1_t
- h1Factory(const std::string & name, const std::string & title, MonGroup & registry, const float lo, const float hi, const unsigned int nbins);
+ h1Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo, const float hi, const unsigned int nbins);
TH1F*
- th1Factory(const std::string & name, const std::string & title, MonGroup & registry, std::vector<TH1F*> & storageVector, const float lo, const float hi, const unsigned int nbins);
+ th1Factory(const std::string& name, const std::string& title, MonGroup& registry, std::vector<TH1F*>& storageVector, const float lo, const float hi, const unsigned int nbins);
TH1F*
- th1Factory(const std::string & name, const std::string & title, MonGroup & registry, const float lo, const float hi, const unsigned int nbins);
+ th1Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo, const float hi, const unsigned int nbins);
H2_t
- h2Factory(const std::string & name, const std::string & title, const SCT_Monitoring::Bec bec, MonGroup & registry, VecH2_t & storageVector);
+ h2Factory(const std::string& name, const std::string& title, const SCT_Monitoring::Bec bec, MonGroup& registry, VecH2_t& storageVector);
H2I_t
- h2IFactory(const std::string & name, const std::string & title, MonGroup & registry, int nbinx, float xlo, float xhi, int nbiny, float ylo, float yhi);
+ h2IFactory(const std::string& name, const std::string& title, MonGroup& registry, int nbinx, float xlo, float xhi, int nbiny, float ylo, float yhi);
Prof2_t
- prof2Factory(const std::string & name, const std::string & title, const SCT_Monitoring::Bec bec, MonGroup & registry, VecProf2_t & storageVector);
+ prof2Factory(const std::string& name, const std::string& title, const SCT_Monitoring::Bec bec, MonGroup& registry, VecProf2_t& storageVector);
Prof2_t
- prof2DFactory(const std::string & name, const std::string & title, MonGroup & registry, int nbinx, float xlo, float xhi, int nbiny, float ylo, float yhi);
+ prof2DFactory(const std::string& name, const std::string& title, MonGroup& registry, int nbinx, float xlo, float xhi, int nbiny, float ylo, float yhi);
Prof_t
- profFactory(const std::string & name, const std::string & title, MonGroup & registry, int nbin, float lo, float hi);
+ profFactory(const std::string& name, const std::string& title, MonGroup& registry, int nbin, float lo, float hi);
Prof_t
- profFactory(const std::string & name, const std::string & title, MonGroup & registry);
+ profFactory(const std::string& name, const std::string& title, MonGroup& registry);
//@}
//@name Tool methods
@@ -513,7 +510,7 @@ class SCTHitsNoiseMonTool : public SCTMotherTrigMonTool{
///Format the position as a string
std::string
- positionString(const Identifier & plane) const;
+ positionString(const Identifier& plane) const;
//@}
SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoKey;
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTLorentzMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTLorentzMonTool.h
index 8754d1efb3947905ce4ce135bc56139a4cbe4de9..2397e9675cf557e9efb68ab6d6bc09b1178ca111 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTLorentzMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTLorentzMonTool.h
@@ -18,27 +18,23 @@
#ifndef SCTLORENTZMONTOOL_H
#define SCTLORENTZMONTOOL_H
-#include <string>
-#include <vector>
-
-// for Updator
-#include "TrkToolInterfaces/IUpdator.h"
-
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include "TrkToolInterfaces/IResidualPullCalculator.h"
#include "SCT_Monitoring/SCTMotherTrigMonTool.h"
-#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/ToolHandle.h"
-
-//for vertexTool
-#include "ITrackToVertex/ITrackToVertex.h" //for m_trackToVertexTool
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
+#include "ITrackToVertex/ITrackToVertex.h" //for m_trackToVertexTool
+#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
+#include "TrkToolInterfaces/IResidualPullCalculator.h"
+#include "TrkToolInterfaces/IUpdator.h"
#include "TrkTrack/TrackCollection.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ToolHandle.h"
+
+#include <string>
+#include <vector>
+
// Forward declarations
class IInterface;
class TH1I;
@@ -52,21 +48,19 @@ class SCT_ID;
///Concrete monitoring tool derived from SCTMotherTrigMonTool
class SCTLorentzMonTool : public SCTMotherTrigMonTool{
public:
- SCTLorentzMonTool(const std::string & type, const std::string & name, const IInterface* parent);
+ SCTLorentzMonTool(const std::string& type, const std::string& name, const IInterface* parent);
virtual ~SCTLorentzMonTool() = default;
//initialize
virtual StatusCode initialize() final;
/** @name Book, fill & check (reimplemented from baseclass) */
//@{
///Book histograms in initialization
- // virtual StatusCode bookHistograms(bool isNewEventsBlock, bool isNewLumiBlock, bool isNewRun);
- virtual StatusCode bookHistograms(); // hidetoshi 14.01.21
- virtual StatusCode bookHistogramsRecurrent(); // hidetoshi 14.01.21
+ virtual StatusCode bookHistograms();
+ virtual StatusCode bookHistogramsRecurrent();
///Fill histograms in each loop
virtual StatusCode fillHistograms() ;
///process histograms at the end (we only use 'isEndOfRun')
- // virtual StatusCode procHistograms( bool isEndOfEventsBlock, bool isEndOfLumiBlock, bool isEndOfRun );
- virtual StatusCode procHistograms(); // hidetoshi 14.01.21
+ virtual StatusCode procHistograms();
///helper function used in procHistograms
StatusCode checkHists(bool fromFinalize);
//@}
@@ -74,9 +68,9 @@ class SCTLorentzMonTool : public SCTMotherTrigMonTool{
private:
//@name typedefs centralised to enable easy changing of types
//@{
- typedef TProfile * Prof_t;
- typedef TH1F * H1_t;
- typedef TH2F * H2_t;
+ typedef TProfile* Prof_t;
+ typedef TH1F* H1_t;
+ typedef TH2F* H2_t;
typedef std::vector<Prof_t> VecProf_t;
typedef std::vector<H1_t> VecH1_t;
typedef std::vector<H2_t> VecH2_t;
@@ -106,28 +100,24 @@ private:
//@name Service members
//@{
- /// Kalman Updator for SCT Unbiased states in Residual calculation
- // ToolHandle<Trk::IUpdator> m_updator;
-
///SCT Helper class
const SCT_ID* m_pSCTHelper;
//@}
//@name Histograms related methods
//@{
// Book Histograms
- // StatusCode bookLorentzHistos(bool isNewRun,bool isNewLumiBlock);
- StatusCode bookLorentzHistos(); // hidetoshi 14.01.22
+ StatusCode bookLorentzHistos();
//@}
//@name Service methods
//@{
// Calculate the local angle of incidence
- int findAnglesToWaferSurface ( const float (&vec)[3], const float &sinAlpha, const Identifier &id, const InDetDD::SiDetectorElementCollection* elements, float &theta, float &phi );
+ int findAnglesToWaferSurface ( const float (&vec)[3], const float& sinAlpha, const Identifier& id, const InDetDD::SiDetectorElementCollection* elements, float& theta, float& phi );
///Factory + register for the 2D profiles, returns whether successfully registered
- Prof_t pFactory(const std::string & name, const std::string & title, int nbinsx, float xlow, float xhigh, MonGroup & registry, int& iflag);
+ Prof_t pFactory(const std::string& name, const std::string& title, int nbinsx, float xlow, float xhigh, MonGroup& registry, int& iflag);
///Factory + register for the 1D histograms, returns whether successfully registered
- bool h1Factory(const std::string & name, const std::string & title, const float extent, MonGroup & registry, VecH1_t & storageVector);
+ bool h1Factory(const std::string& name, const std::string& title, const float extent, MonGroup& registry, VecH1_t& storageVector);
//@}
};
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTMotherTrigMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTMotherTrigMonTool.h
index 527ad41df5aa8010acd20317dca3320f16de2a77..d889f703a425f818001d898f90c85b27ffdcf172 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTMotherTrigMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTMotherTrigMonTool.h
@@ -11,16 +11,15 @@
#ifndef SCTMotherTrigMonTool_H
#define SCTMotherTrigMonTool_H
-//Local includes
#include "AthenaMonitoring/ManagedMonitorToolBase.h"
+#include "StoreGate/ReadHandleKey.h"
+#include "xAODEventInfo/EventInfo.h"
+
//Standard C++
#include <string>
#include <bitset>
-#include "StoreGate/ReadHandleKey.h"
-#include "xAODEventInfo/EventInfo.h"
-
//Fwd declarations
class IInterface;
class StatusCode;
@@ -29,7 +28,7 @@ class StatusCode;
class SCTMotherTrigMonTool : public ManagedMonitorToolBase {
public:
///Constructor
- SCTMotherTrigMonTool( const std::string & type, const std::string & name,const IInterface* parent);
+ SCTMotherTrigMonTool( const std::string& type, const std::string& name,const IInterface* parent);
///Destructor
virtual ~SCTMotherTrigMonTool() = default;
@@ -47,9 +46,9 @@ protected:
///Get the status of a particular trigger bit (trigger bit 0-7)
bool hasTriggerFired(const unsigned int trigger) const;
///Check if the event belongs to Stream = StreamName
- bool isStream(const std::string & StreamName);
+ bool isStream(const std::string& StreamName);
///Check if the event passes L1 item
- bool isCalibrationNoise(const std::string & L1_Item);
+ bool isCalibrationNoise(const std::string& L1_Item);
///Abbreviations for level 1 trigger types
const static std::string m_triggerNames[8];
///Format and output (INFO msg level) the fired triggers
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTRatioNoiseMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTRatioNoiseMonTool.h
index 34e1f79c8f5f0cb26c96f6aa790c4730475c9410..f1232c2811b1d3ddfa69376e8044a08562d3922b 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTRatioNoiseMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTRatioNoiseMonTool.h
@@ -18,22 +18,20 @@
#ifndef SCTRATIONOISEMONTOOL_H
#define SCTRATIONOISEMONTOOL_H
-#include <string>
-#include <vector>
+#include "SCT_Monitoring/SCTMotherTrigMonTool.h"
-// for Updator
+#include "InDetRawData/SCT_RDO_Container.h"
+#include "InDetConditionsSummaryService/IInDetConditionsTool.h"
+#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
+#include "StoreGate/ReadHandleKey.h"
#include "TrkToolInterfaces/IUpdator.h"
+#include "xAODEventInfo/EventInfo.h"
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-
-#include "SCT_Monitoring/SCTMotherTrigMonTool.h"
-#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
#include "GaudiKernel/ToolHandle.h"
-#include "InDetConditionsSummaryService/IInDetConditionsTool.h"
-#include "StoreGate/ReadHandleKey.h"
-#include "InDetRawData/SCT_RDO_Container.h"
-#include "xAODEventInfo/EventInfo.h"
+#include <string>
+#include <vector>
+
// Forward declarations
class IInterface;
@@ -57,19 +55,19 @@ class SCT_ID;
///Concrete monitoring tool derived from SCTMotherTrigMonTool
class SCTRatioNoiseMonTool : public SCTMotherTrigMonTool{
public:
- SCTRatioNoiseMonTool(const std::string & type, const std::string & name, const IInterface* parent);
+ SCTRatioNoiseMonTool(const std::string& type, const std::string& name, const IInterface* parent);
virtual ~SCTRatioNoiseMonTool() = default;
// initialize
virtual StatusCode initialize() final;
/** @name Book, fill & check (reimplemented from baseclass) */
//@{
///Book histograms in initialization
- virtual StatusCode bookHistogramsRecurrent(); // hidetoshi 14.01.21
- virtual StatusCode bookHistograms(); // hidetoshi 14.01.21
+ virtual StatusCode bookHistogramsRecurrent();
+ virtual StatusCode bookHistograms();
///Fill histograms in each loop
virtual StatusCode fillHistograms() ;
///process histograms at the end (we only use 'isEndOfRun')
- virtual StatusCode procHistograms(); // hidetoshi 14.01.21
+ virtual StatusCode procHistograms();
///helper function used in procHistograms
StatusCode checkHists(bool fromFinalize);
//@}
@@ -78,12 +76,12 @@ class SCTRatioNoiseMonTool : public SCTMotherTrigMonTool{
private:
//@name typedefs centralised to enable easy changing of types
//@{
- typedef TProfile * Prof_t;
- typedef TProfile2D * Prof2_t;
- typedef TH1F_LW * H1_t;
- typedef TH2F_LW * H2_t;
- typedef TH1I * H1I_t;
- typedef TH2I * H2I_t;
+ typedef TProfile* Prof_t;
+ typedef TProfile2D* Prof2_t;
+ typedef TH1F_LW* H1_t;
+ typedef TH2F_LW* H2_t;
+ typedef TH1I* H1I_t;
+ typedef TH2I* H2I_t;
typedef std::vector<Prof2_t> VecProf2_t;
typedef std::vector<Prof_t> VecProf_t;
typedef std::vector<H1_t> VecH1_t;
@@ -249,14 +247,13 @@ private:
//@name Histograms related methods
//@{
// Book Histograms
- // StatusCode bookRatioNoiseHistos(bool isNewRun,bool isNewLumiBlock); // hidetoshi 14.01.22
- StatusCode bookRatioNoiseHistos(); // hidetoshi 14.01.22
+ StatusCode bookRatioNoiseHistos();
//@}
//@name Service methods
//@{
// Calculate the local angle of incidence
- int findAnglesToWaferSurface ( const float (&vec)[3], const float &sinAlpha, const Identifier &id, float &theta, float &phi );
+ int findAnglesToWaferSurface ( const float (&vec)[3], const float& sinAlpha, const Identifier& id, float& theta, float& phi );
float calculateNoiseOccupancyUsingRatioMethod(const float numberOneSide, const float numberZeroSide);
float calculateOneSideNoiseOccupancyUsingRatioMethod(const float numberOneSide, const float numberZeroSide);
bool isBarrel(const int moduleNumber);
@@ -266,19 +263,19 @@ private:
///Factory + register for the 2D profiles, returns whether successfully registered
Prof_t
- pFactory(const std::string & name, const std::string & title, MonGroup & registry, const float lo, const float hi, const unsigned int nbins);
+ pFactory(const std::string& name, const std::string& title, MonGroup& registry, const float lo, const float hi, const unsigned int nbins);
H1_t
- h1Factory(const std::string & name, const std::string & title, MonGroup & registry, VecH1_t & storageVector, const float lo, const float hi, const unsigned int nbins);
+ h1Factory(const std::string& name, const std::string& title, MonGroup& registry, VecH1_t& storageVector, const float lo, const float hi, const unsigned int nbins);
H1_t
- h1Factory(const std::string & name, const std::string & title, MonGroup & registry, const float lo, const float hi, const unsigned int nbins);
+ h1Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo, const float hi, const unsigned int nbins);
H2_t
- h2Factory(const std::string & name, const std::string & title, MonGroup & registry, const float lo_x, const float hi_x, const unsigned int nbins_x, const float lo_y, const float hi_y, const unsigned int nbins_y);
+ h2Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo_x, const float hi_x, const unsigned int nbins_x, const float lo_y, const float hi_y, const unsigned int nbins_y);
H1I_t
- h1IFactory(const std::string & name, const std::string & title, MonGroup & registry, VecH1I_t & storageVector, const float lo, const float hi, const unsigned int nbins);
+ h1IFactory(const std::string& name, const std::string& title, MonGroup& registry, VecH1I_t& storageVector, const float lo, const float hi, const unsigned int nbins);
H1I_t
- h1IFactory(const std::string & name, const std::string & title, MonGroup & registry, const float lo, const float hi, const unsigned int nbins);
+ h1IFactory(const std::string& name, const std::string& title, MonGroup& registry, const float lo, const float hi, const unsigned int nbins);
Prof2_t
- prof2Factory(const std::string & name, const std::string & title, const unsigned int&, MonGroup & registry, VecProf2_t & storageVector);
+ prof2Factory(const std::string& name, const std::string& title, const unsigned int&, MonGroup& registry, VecProf2_t& storageVector);
//@}
};
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTSummaryMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTSummaryMonTool.h
index e5af5176a4e8c2f330b45a1e2a567cdd95ee18f9..b428f38dca0cd2f64a098072d52c564d3ba0373b 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTSummaryMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTSummaryMonTool.h
@@ -17,11 +17,10 @@
#ifndef SCTSummaryMonTool_H
#define SCTSummaryMonTool_H
-#include <string>
-
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
#include "SCT_Monitoring/SCTMotherTrigMonTool.h"
+#include <string>
+
// Forward declarations
class IInterface;
class StatusCode;
@@ -30,7 +29,7 @@ class StatusCode;
///Concrete monitoring tool derived from SCTMotherTrigMonTool
class SCTSummaryMonTool : public SCTMotherTrigMonTool{
public:
- SCTSummaryMonTool(const std::string & type, const std::string & name, const IInterface* parent);
+ SCTSummaryMonTool(const std::string& type, const std::string& name, const IInterface* parent);
virtual ~SCTSummaryMonTool() = default;
/** @name Book, fill & check (reimplemented from baseclass) */
//@{
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTTracksMonTool.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTTracksMonTool.h
index d713accbb928e992744ead0abce7eaf48e6f21d8..1fb76d94a26e473551344a4c7e7ffc5917d2a6d6 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTTracksMonTool.h
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCTTracksMonTool.h
@@ -13,22 +13,19 @@
#ifndef SCTTRACKSMONTOOL_H
#define SCTTRACKSMONTOOL_H
-#include <string>
-#include <vector>
-
-// for Updator
-#include "TrkToolInterfaces/IUpdator.h"
-
-#include "AthenaMonitoring/ManagedMonitorToolBase.h"
-#include "TrkToolInterfaces/IResidualPullCalculator.h"
#include "SCT_Monitoring/SCTMotherTrigMonTool.h"
+
#include "SCT_Monitoring/SCT_MonitoringNumbers.h"
+#include "StoreGate/ReadHandleKey.h"
+#include "TrkToolInterfaces/IResidualPullCalculator.h"
+#include "TrkToolInterfaces/IUpdator.h"
+#include "TrkTrack/TrackCollection.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
-#include "StoreGate/ReadHandleKey.h"
-#include "TrkTrack/TrackCollection.h"
+#include <string>
+#include <vector>
// Forward declarations
class IInterface;
@@ -43,19 +40,19 @@ class SCT_ID;
///Concrete monitoring tool derived from SCTMotherTrigMonTool
class SCTTracksMonTool : public SCTMotherTrigMonTool{
public:
- SCTTracksMonTool(const std::string & type, const std::string & name, const IInterface* parent);
+ SCTTracksMonTool(const std::string& type, const std::string& name, const IInterface* parent);
virtual ~SCTTracksMonTool() = default;
//initialize
virtual StatusCode initialize() final;
/** @name Book, fill & check (reimplemented from baseclass) */
//@{
///Book histograms in initialization
- virtual StatusCode bookHistogramsRecurrent(); // hidetoshi 12.01.21
- virtual StatusCode bookHistograms(); // hidetoshi 12.01.21
+ virtual StatusCode bookHistogramsRecurrent();
+ virtual StatusCode bookHistograms();
///Fill histograms in each loop
virtual StatusCode fillHistograms() ;
///process histograms at the end (we only use 'isEndOfRun')
- virtual StatusCode procHistograms(); // hidetoshi 12.01.21
+ virtual StatusCode procHistograms();
///helper function used in procHistograms
StatusCode checkHists(bool fromFinalize);
//@}
@@ -63,25 +60,25 @@ class SCTTracksMonTool : public SCTMotherTrigMonTool{
private:
//@name typedefs centralised to enable easy changing of types
//@{
- typedef TProfile2D * Prof2_t;
- typedef TProfile * Prof_t;
- typedef TH1F * H1_t;
- typedef TH2F * H2_t;
+ typedef TProfile2D* Prof2_t;
+ typedef TProfile* Prof_t;
+ typedef TH1F* H1_t;
+ typedef TH2F* H2_t;
typedef std::vector<Prof2_t> VecProf2_t;
typedef std::vector<H1_t> VecH1_t;
typedef std::vector<H2_t> VecH2_t;
//@}
- TH1I *m_nTracks;
- int *m_nTracks_buf;
+ TH1I* m_nTracks;
+ int* m_nTracks_buf;
int m_nTracks_pos;
- TH1I *m_trackTrigger;
- TProfile *m_trackTriggerRate;
- TH1F *m_totalBarrelResidual;
- TH1F *m_totalEndCapAResidual;
- TH1F *m_totalEndCapCResidual;
- TH1F *m_totalBarrelPull;
- TH1F *m_totalEndCapAPull;
- TH1F *m_totalEndCapCPull;
+ TH1I* m_trackTrigger;
+ TProfile* m_trackTriggerRate;
+ TH1F* m_totalBarrelResidual;
+ TH1F* m_totalEndCapAResidual;
+ TH1F* m_totalEndCapCResidual;
+ TH1F* m_totalBarrelPull;
+ TH1F* m_totalEndCapAPull;
+ TH1F* m_totalEndCapCPull;
int m_numberOfEvents;
//@name Histograms related members
@@ -174,7 +171,6 @@ private:
//@name Histograms related methods
//@{
// Book Track related Histograms
- // hidetoshi 14.01.22
StatusCode bookTrackHistos(const SCT_Monitoring::Bec becVal);
StatusCode bookGeneralHistos();
StatusCode bookPositiveEndCapTrackHistos(){ return bookTrackHistos(SCT_Monitoring::ENDCAP_A);}
@@ -187,13 +183,13 @@ private:
float calculatePull(const float, const float, const float);
///Factory + register for the 2D histos, returns whether successfully registered
- StatusCode h2Factory(const std::string & name, const std::string & title, const SCT_Monitoring::Bec bec, MonGroup & registry, VecH2_t & storageVector);
+ StatusCode h2Factory(const std::string& name, const std::string& title, const SCT_Monitoring::Bec bec, MonGroup& registry, VecH2_t& storageVector);
///Factory + register for the 2D profiles, returns whether successfully registered
- StatusCode p2Factory(const std::string & name, const std::string & title, const SCT_Monitoring::Bec bec, MonGroup & registry, VecProf2_t & storageVector);
+ StatusCode p2Factory(const std::string& name, const std::string& title, const SCT_Monitoring::Bec bec, MonGroup& registry, VecProf2_t& storageVector);
///Factory + register for the 1D histograms, returns whether successfully registered
- StatusCode h1Factory(const std::string & name, const std::string & title, const float extent, MonGroup & registry, VecH1_t & storageVector);
+ StatusCode h1Factory(const std::string& name, const std::string& title, const float extent, MonGroup& registry, VecH1_t& storageVector);
//@}
};
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCT_ClusterStruct.h b/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCT_ClusterStruct.h
deleted file mode 100644
index 317cc07664f4de6fd13e6f2fa258792225be9e0a..0000000000000000000000000000000000000000
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/SCT_Monitoring/SCT_ClusterStruct.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-*/
-/*
- * SCT_ClusterStruct.h
- *
- *
- * Created by Shaun Roe on 24/05/2005.
- *
- */
-
-#ifndef SCT_ClusterStruct_H
-#define SCT_ClusterStruct_H
-///Simple struct to hold the first strip and number of strips in a cluster
-struct SCT_ClusterStruct{
- unsigned int firstStrip;
- unsigned int numberOfStrips;
-};
-
-#endif
-
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx
index b21cf22ad9b0ad56e15155d115581940ccfe442f..7be62108fb70fabab50acf904a65c3f9ada175bd 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx
@@ -9,31 +9,32 @@
*/
#include "SCT_Monitoring/SCTErrMonTool.h"
-#include "SCT_Monitoring/SCT_ClusterStruct.h"
#include "GaudiKernel/ITHistSvc.h"
// conditions stuff
#include "InDetConditionsSummaryService/InDetHierarchy.h"
-#include "TH1F.h"
-#include "TH2F.h"
-#include "TH2I.h"
-#include "TProfile.h"
-#include "TProfile2D.h"
-#include "LWHists/TH1F_LW.h"
-#include "LWHists/TH2F_LW.h"
-#include "LWHists/TH2I_LW.h"
-#include "LWHists/TProfile_LW.h"
-#include "LWHists/TProfile2D_LW.h"
-#include "InDetRawData/SCT3_RawData.h"
-#include "InDetRawData/InDetRawDataContainer.h"
-#include "InDetRawData/InDetRawDataCLASS_DEF.h"
+
#include "AthContainers/DataVector.h"
#include "Identifier/Identifier.h"
#include "InDetIdentifier/SCT_ID.h"
+#include "InDetRawData/SCT3_RawData.h"
+#include "InDetRawData/InDetRawDataContainer.h"
+#include "InDetRawData/InDetRawDataCLASS_DEF.h"
#include "InDetReadoutGeometry/SCT_DetectorManager.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
-#include "cArrayUtilities.h"
+#include "LWHists/TH1F_LW.h"
+#include "LWHists/TH2F_LW.h"
+#include "LWHists/TH2I_LW.h"
+#include "LWHists/TProfile_LW.h"
+#include "LWHists/TProfile2D_LW.h"
#include "StoreGate/ReadHandle.h"
+
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TH2I.h"
+#include "TProfile.h"
+#include "TProfile2D.h"
+
#include <vector>
#include <set>
#include <iostream>
@@ -48,7 +49,7 @@ namespace {
const bool testOffline(false);
int
- numberOfInefficientSides(TH2 *pHistogramArray[], const int xbin, const int ybin, const float threshold) {
+ numberOfInefficientSides(TH2* pHistogramArray[], const int xbin, const int ybin, const float threshold) {
float histogramBinContent0 = pHistogramArray[0]->GetBinContent(xbin, ybin);
float histogramBinContent1 = pHistogramArray[1]->GetBinContent(xbin, ybin);
int side0Inefficient = (histogramBinContent0 > threshold);
@@ -58,7 +59,7 @@ namespace {
}
bool
- eitherSideIsOverThreshold(TH2 *pHistogramArray[], const int xbin, const int ybin, const float threshold) {
+ eitherSideIsOverThreshold(TH2* pHistogramArray[], const int xbin, const int ybin, const float threshold) {
float histogramBinContent0 = pHistogramArray[0]->GetBinContent(xbin, ybin);
float histogramBinContent1 = pHistogramArray[1]->GetBinContent(xbin, ybin);
@@ -66,14 +67,14 @@ namespace {
}
bool
- checkOverThreshold(TH2 *pHistogram, const int xbin, const int ybin, const float threshold) {
+ checkOverThreshold(TH2* pHistogram, const int xbin, const int ybin, const float threshold) {
float histogramBinContent = pHistogram->GetBinContent(xbin, ybin);
return(histogramBinContent > threshold);
}
bool
- thereAreEnoughEntries(TH2 *pHistogramArray[], const float threshold) {
+ thereAreEnoughEntries(TH2* pHistogramArray[], const float threshold) {
float histogramEntries0 = pHistogramArray[0]->GetEntries();
float histogramEntries1 = pHistogramArray[1]->GetEntries();
@@ -81,7 +82,7 @@ namespace {
}
void
- fillRateHistogram(const TH2F_LW *sourceHisto, TProfile2D_LW *targetHisto, const int xbin, const int ybin,
+ fillRateHistogram(const TH2F_LW* sourceHisto, TProfile2D_LW* targetHisto, const int xbin, const int ybin,
const float centreX, const float centreY, const int nEvent) {
const float content = sourceHisto->GetBinContent(xbin, ybin);
@@ -90,7 +91,7 @@ namespace {
}
void
- countNoisyModules(const int regionIndex, const int generalIndex, TH2 *pHistogram[],
+ countNoisyModules(const int regionIndex, const int generalIndex, TH2* pHistogram[],
const float threshold, int countArray[]) {
const int xbins(pHistogram[0]->GetNbinsX() + 1);
const int ybins(pHistogram[0]->GetNbinsY() + 1);
@@ -106,7 +107,7 @@ namespace {
}
void
- countNoisyModulesRN(const int regionIndex, const int generalIndex, TH2 *pHistogram[],
+ countNoisyModulesRN(const int regionIndex, const int generalIndex, TH2* pHistogram[],
const float threshold, int countArray[]) {
const int xbins(pHistogram[0]->GetNbinsX() + 1);
const int ybins(pHistogram[0]->GetNbinsY() + 1);
@@ -130,7 +131,7 @@ namespace {
* the first and second plane numbers to be used, and the timebin.
*/
// ====================================================================================================
-SCTErrMonTool::SCTErrMonTool(const std::string &type, const std::string &name, const IInterface *parent)
+SCTErrMonTool::SCTErrMonTool(const std::string& type, const std::string& name, const IInterface* parent)
: ManagedMonitorToolBase(type, name, parent),
m_firstHit{},
m_secondHit{},
@@ -323,7 +324,7 @@ SCTErrMonTool::copyHistograms() {
const int xbins(m_LinksWithCategorisedErrorsVsLB[CategoryErrors::RODLEVEL][reg]->GetNbinsX() + 1);
for (int xb(1); xb != xbins; ++xb) {
double nentry=m_LinksWithCategorisedErrorsVsLB[CategoryErrors::RODLEVEL][reg]->GetBinContent(xb);
- for(int ientry=0; ientry<nentry; ientry++){
+ for (int ientry=0; ientry<nentry; ientry++){
m_LinksWithRODErrorsVsLB_check[reg]->Fill(m_LinksWithCategorisedErrorsVsLB[CategoryErrors::RODLEVEL][reg]->GetXaxis()->GetBinCenter(xb),
m_LinksWithCategorisedErrorsVsLB[CategoryErrors::RODLEVEL][reg]->GetBinContent(xb));
}
@@ -411,7 +412,7 @@ SCTErrMonTool::bookHistograms() {
ATH_MSG_WARNING("Error in bookErrHistosGen()");
}
- for(int reg=0; reg<N_REGIONS; reg++){
+ for (int reg=0; reg<N_REGIONS; reg++){
if (bookConfMaps(reg).isFailure()) {
ATH_MSG_WARNING("Error in bookConfMaps(): " << "SCT" + subDetNameShort[reg]);
}
@@ -564,16 +565,15 @@ SCTErrMonTool::fillHistograms() {
// Use new IDC
SCT_RDO_Container::const_iterator lastCol = p_rdocontainer->end();
for (SCT_RDO_Container::const_iterator col_it = p_rdocontainer->begin(); col_it != lastCol; ++col_it) {
- const InDetRawDataCollection<SCT_RDORawData> *SCT_Collection(*col_it);
+ const InDetRawDataCollection<SCT_RDORawData>* SCT_Collection(*col_it);
if (!SCT_Collection) continue; // select only SCT RDOs
DataVector<SCTRawDataType>::const_iterator p_rdo_end = SCT_Collection->end();
- //const InDetRawDataCollection<SCT_RDORawData> *rd(*col_it);
Identifier SCT_Identifier = SCT_Collection->identify();
for (DataVector<SCTRawDataType>::const_iterator p_rdo = SCT_Collection->begin(); p_rdo != p_rdo_end; ++p_rdo) {
count_SCT_RDO++;
- const SCT3_RawData *rdo3 = dynamic_cast<const SCT3_RawData *>(*p_rdo);
+ const SCT3_RawData* rdo3 = dynamic_cast<const SCT3_RawData*>(*p_rdo);
SCT_Identifier = (*p_rdo)->identify();
int barrel_ec = m_pSCTHelper->barrel_ec(SCT_Identifier);
if (barrel_ec == BARREL) ++numSCTRDOs;
@@ -600,7 +600,7 @@ SCTErrMonTool::fillHistograms() {
}
}
}
- }// end for(SCT_RDO_Container...
+ }// end for (SCT_RDO_Container...
if (numSCTRDOs != 0) {
double scale = 100. / double(numSCTRDOs);
@@ -661,7 +661,7 @@ SCTErrMonTool::checkRateHists() {
float cyb = 0;
int evt = m_numberOfEvents;
int evt_lumi = m_numberOfEventsLumi;
- for(int reg=0; reg<N_REGIONS; reg++){
+ for (int reg=0; reg<N_REGIONS; reg++){
if (m_doPerLumiErrors && endOfLumiBlockFlag()) {
const int xbins = m_numErrorsPerLumi[reg]->GetNbinsX() + 1;
const int ybins = m_numErrorsPerLumi[reg]->GetNbinsY() + 1;
@@ -751,8 +751,8 @@ SCTErrMonTool::procHistograms() {
// SCTErrMonTool :: fillByteStreamErrorsHelper, Martin Flechl 10/09/2009
// ====================================================================================================
int
-SCTErrMonTool::fillByteStreamErrorsHelper(const std::set<IdentifierHash> *errors,
- TH2F_LW *histo[SCT_ByteStreamErrors::NUM_ERROR_TYPES][NREGIONS_INC_GENERAL][SCT_Monitoring::N_ENDCAPSx2],
+SCTErrMonTool::fillByteStreamErrorsHelper(const std::set<IdentifierHash>* errors,
+ TH2F_LW* histo[SCT_ByteStreamErrors::NUM_ERROR_TYPES][NREGIONS_INC_GENERAL][SCT_Monitoring::N_ENDCAPSx2],
bool lumi2DHist, int err_type) {
//--- Check categories of the BS error
@@ -855,7 +855,7 @@ SCTErrMonTool::fillByteStreamErrorsHelper(const std::set<IdentifierHash> *errors
// SCTErrMonTool :: numByteStreamErrors, Daniel Damiani 04/07/2011
// ====================================================================================================
void
-SCTErrMonTool::numByteStreamErrors(const std::set<IdentifierHash> *errors, int &ntot, int &nbar, int &neca, int &necc) {
+SCTErrMonTool::numByteStreamErrors(const std::set<IdentifierHash>* errors, int& ntot, int& nbar, int& neca, int& necc) {
for (auto fit: *errors) {
if (fit.is_valid()) {
@@ -905,7 +905,7 @@ SCTErrMonTool::fillByteStreamErrors() {
}
}
- if(m_sctflag) {
+ if (m_sctflag) {
return StatusCode::SUCCESS;
}
@@ -1109,8 +1109,8 @@ SCTErrMonTool::fillByteStreamErrors() {
// Avoids duplicate code in the bookErrHistosXXXX functions; added 8/9/09, Martin Flechl
// ====================================================================================================
StatusCode
-SCTErrMonTool::bookErrHistosHelper(MonGroup &mg, TString name, TString title, TString titlehitmap,
- TProfile2D_LW * &tprof, TH2F_LW * &th, const int layer, const bool barrel) {
+SCTErrMonTool::bookErrHistosHelper(MonGroup& mg, TString name, TString title, TString titlehitmap,
+ TProfile2D_LW*& tprof, TH2F_LW*& th, const int layer, const bool barrel) {
ostringstream streamhitmap;
streamhitmap << layer / 2 << "_" << layer % 2;
@@ -1147,7 +1147,7 @@ SCTErrMonTool::bookErrHistosHelper(MonGroup &mg, TString name, TString title, TS
// Avoids duplicate code in the bookErrHistosXXXX functions; added 08/08/11, Daniel Damiani
// ====================================================================================================
StatusCode
-SCTErrMonTool::bookErrHistosHelper(MonGroup &mg, TString name, TString title, TProfile2D_LW * &tprof, const int layer,
+SCTErrMonTool::bookErrHistosHelper(MonGroup& mg, TString name, TString title, TProfile2D_LW*& tprof, const int layer,
const bool barrel) {
ostringstream streamhitmap;
@@ -1313,8 +1313,8 @@ SCTErrMonTool::bookErrHistosGen() {
m_nLinksWithErrors->GetYaxis()->SetTitle("Num of Links with Errors");
size_t nErrors_buf_size;
nErrors_buf_size = m_evtsbins * sizeof(int);
- m_nErrors_buf = (int *) malloc(nErrors_buf_size);
- m_nLinksWithErrors_buf = (int *) malloc(nErrors_buf_size);
+ m_nErrors_buf = (int*) malloc(nErrors_buf_size);
+ m_nLinksWithErrors_buf = (int*) malloc(nErrors_buf_size);
m_nErrors_pos = 0;
if (Errors.regHist(m_nErrors).isFailure()) {
ATH_MSG_WARNING("Couldn't book nErrors vs event number hist");
@@ -1554,7 +1554,7 @@ SCTErrMonTool::bookConfMaps(int reg=-1) { // reg = 0:EC, 1:B, 2:EA
m_p2DmapHistoVectorAll[reg].clear();
for (int layer(0); layer != nLayers; ++layer) {
std::string mapName = "modulemap" + std::string(subDetNameShort[reg].Data()) + std::to_string(int(layer/2)) + "_" + std::to_string(int(layer%2));
- TH2F_LW *hitsHisto_tmp = TH2F_LW::create(TString(mapName.c_str()),
+ TH2F_LW* hitsHisto_tmp = TH2F_LW::create(TString(mapName.c_str()),
TString(("Module Out of Configuration : "+std::string(subDetName[reg].Data())+", "+
std::string(layerName[reg].Data())+" "+std::to_string(int(layer/2))+
" side "+std::to_string(int(layer%2))).c_str()),
@@ -1603,7 +1603,7 @@ SCTErrMonTool::fillCondDBMaps() {
};
bool failedbooking = false;
- TH2 *hitsHisto_tmp[2];
+ TH2* hitsHisto_tmp[2];
// Pointers are deleted by regHist() method
std::string stem;
@@ -1633,7 +1633,7 @@ SCTErrMonTool::fillCondDBMaps() {
}
// region
- for(int reg=0; reg<N_REGIONS; reg++){
+ for (int reg=0; reg<N_REGIONS; reg++){
int nLayers = n_layers[reg];
for (int lyr = 0; lyr < nLayers; ++lyr) {
@@ -1754,7 +1754,7 @@ SCTErrMonTool::fillConfigurationDetails() {
}
}
- const std::map<Identifier, unsigned int> *badChips = m_ConfigurationTool->badChips(); // bad chips
+ const std::map<Identifier, unsigned int>* badChips = m_ConfigurationTool->badChips(); // bad chips
unsigned int nBadChips(0);
for (auto chip : *badChips) {
unsigned int status = chip.second;
@@ -1840,7 +1840,7 @@ SCTErrMonTool::resetConfigurationDetails() {
// SCTErrMonTool :: getHisto, Martin Flechl 14/9/2009
// ====================================================================================================
bool
-SCTErrMonTool::getHisto(const int layer, const int reg, const int type, TH2 *histo[2]) {
+SCTErrMonTool::getHisto(const int layer, const int reg, const int type, TH2* histo[2]) {
const string trm[3][N_REGIONS] = {
{"SCT/SCTEC/Noise/noiseoccupancymapECm_","SCT/SCTB/Noise/noiseoccupancymap_", "SCT/SCTEA/Noise/noiseoccupancymapECp_"},
{"SCT/SCTEC/eff/ineffm_", "SCT/SCTB/eff/ineff_", "SCT/SCTEA/eff/ineffp_"},
@@ -1882,7 +1882,7 @@ SCTErrMonTool::getHisto(const int layer, const int reg, const int type, TH2 *his
// SCTErrMonTool :: getHistoRecent, Dan Damiani 21/7/2011
// ====================================================================================================
bool
-SCTErrMonTool::getHistoRecent(const int layer, const int reg, const int type, TH2 *histo[2]) {
+SCTErrMonTool::getHistoRecent(const int layer, const int reg, const int type, TH2* histo[2]) {
const string trm[1][N_REGIONS] = {
{"SCT/SCTEC/Noise/noiseoccupancymaprecentECm_", "SCT/SCTB/Noise/noiseoccupancymaprecent_", "SCT/SCTEA/Noise/noiseoccupancymaprecentECp_"}
};
@@ -1900,8 +1900,8 @@ SCTErrMonTool::getHistoRecent(const int layer, const int reg, const int type, TH
}
SCTErrMonTool::Prof2_t
-SCTErrMonTool::prof2Factory(const std::string &name, const std::string &title, const unsigned int &bec,
- VecProf2_t &storageVector) {
+SCTErrMonTool::prof2Factory(const std::string& name, const std::string& title, const unsigned int& bec,
+ VecProf2_t& storageVector) {
int firstEta(FIRST_ETA_BIN), lastEta(LAST_ETA_BIN), firstPhi(FIRST_PHI_BIN), lastPhi(LAST_PHI_BIN), nEta(N_ETA_BINS),
nPhi(N_PHI_BINS);
@@ -1954,8 +1954,7 @@ SCTErrMonTool::isEndcapA(const int moduleNumber) {
//====================================================================================================
// SCTErrMonTool :: fillWafer, Keisuke Kouda 12.09.2016
//====================================================================================================
-void SCTErrMonTool::fillWafer( moduleGeo_t module, TH2F * histo )
-//void SCTErrMonTool::fillWafer( moduleGeo_t module, TProfile2D * profile )
+void SCTErrMonTool::fillWafer( moduleGeo_t module, TH2F* histo )
{
double etaMin(module.first.first), etaMax(module.first.second);
double phiMin(module.second.first), phiMax(module.second.second);
@@ -2014,7 +2013,7 @@ bool SCTErrMonTool::syncErrorSCT()
//BadLinkLevelError
for (SCT_ByteStreamErrors::errorTypes linkLevelBadErrors: SCT_ByteStreamErrors::LinkLevelBadErrors)
{
- const std::set<IdentifierHash> * sctErrors = m_byteStreamErrTool->getErrorSet( linkLevelBadErrors );
+ const std::set<IdentifierHash>* sctErrors = m_byteStreamErrTool->getErrorSet( linkLevelBadErrors );
for (const IdentifierHash& waferHash: *sctErrors)
{
m_SCTHash[badLinkError].insert(waferHash);
@@ -2024,7 +2023,7 @@ bool SCTErrMonTool::syncErrorSCT()
//BadRODLevelError
for (SCT_ByteStreamErrors::errorTypes RodLevelBadErrors: SCT_ByteStreamErrors::RodLevelBadErrors)
{
- const std::set<IdentifierHash> * sctErrors = m_byteStreamErrTool->getErrorSet( RodLevelBadErrors );
+ const std::set<IdentifierHash>* sctErrors = m_byteStreamErrTool->getErrorSet( RodLevelBadErrors );
for (const IdentifierHash& waferHash: *sctErrors)
{
@@ -2035,7 +2034,7 @@ bool SCTErrMonTool::syncErrorSCT()
//BadError = BadLinkLevelError + BadRODLevelError
for (SCT_ByteStreamErrors::errorTypes tmpBadError: SCT_ByteStreamErrors::BadErrors)
{
- const std::set<IdentifierHash> * sctErrors = m_byteStreamErrTool->getErrorSet( tmpBadError );
+ const std::set<IdentifierHash>* sctErrors = m_byteStreamErrTool->getErrorSet( tmpBadError );
for (const IdentifierHash& waferHash: *sctErrors)
{
m_SCTHash[badError].insert(waferHash);
@@ -2107,7 +2106,7 @@ bool SCTErrMonTool::psTripDCSSCT()
//====================================================================================================
// SCTErrMonTool :: calculateDetectorCoverage, Keisuke Kouda 12.09.2016
//====================================================================================================
-double SCTErrMonTool::calculateDetectorCoverage( const TH2F * histo )
+double SCTErrMonTool::calculateDetectorCoverage( const TH2F* histo )
{
double detector_coverage = 0.;
double occupancy = 0;
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitEffMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitEffMonTool.cxx
index c509749d608a808272203552ba655ca35b9654ea..088d69aa7a9fcb5fd884a778343b5d36bd6e6bdf 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitEffMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitEffMonTool.cxx
@@ -5,26 +5,6 @@
/** Tool to measure the intrinsic single hit efficiency in the SCT
*/
-// std and STL includes
-#include <cmath>
-// #include <ostream>
-#include <sstream>
-#include <limits>
-#include <algorithm>
-#include <limits> // std::numeric_limits
-#include <array>
-
-
-
-// Gaudi
-#include "GaudiKernel/IChronoStatSvc.h"
-
-// ROOT
-#include "TH2I.h"
-#include "TProfile2D.h"
-#include "TProfile.h"
-#include "TGraphErrors.h"
-
// Athena
#include "AthenaKernel/errorcheck.h"
#include "Identifier/IdentifierHash.h"
@@ -52,16 +32,25 @@
#include "SCT_Monitoring/SCTHitEffMonTool.h"
#include "SCT_NameFormatter.h"
#include "SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h"
-// macros (ugh)
-#define DEBUG(x) ATH_MSG_DEBUG(x)
-#define INFO(x) ATH_MSG_INFO(x)
-#define WARNING(x) ATH_MSG_WARNING(x)
-#define ERROR(x) ATH_MSG_ERROR(x)
-#define VERBOSE(x) ATH_MSG_VERBOSE(x)
-using namespace SCT_Monitoring;
+// Gaudi
+#include "GaudiKernel/IChronoStatSvc.h"
+// ROOT
+#include "TH2I.h"
+#include "TProfile2D.h"
+#include "TProfile.h"
+#include "TGraphErrors.h"
+// std and STL includes
+#include <cmath>
+#include <sstream>
+#include <limits>
+#include <algorithm>
+#include <limits> // std::numeric_limits
+#include <array>
+
+using namespace SCT_Monitoring;
namespace {// anonymous namespace for functions at file scope
const bool testOffline(false);
@@ -74,9 +63,9 @@ namespace {// anonymous namespace for functions at file scope
};
template< typename T > Identifier
- surfaceOnTrackIdentifier(const T &tsos, const bool useTrackParameters = true) {
+ surfaceOnTrackIdentifier(const T& tsos, const bool useTrackParameters = true) {
Identifier result(0); // default constructor produces invalid value
- const Trk::MeasurementBase *mesb = tsos->measurementOnTrack();
+ const Trk::MeasurementBase* mesb = tsos->measurementOnTrack();
if (mesb and mesb->associatedSurface().associatedDetectorElement()) {
result = mesb->associatedSurface().associatedDetectorElement()->identify();
@@ -90,7 +79,7 @@ namespace {// anonymous namespace for functions at file scope
constexpr Double_t radianDegrees(180. / M_PI);
float
- amgPseudoRapidity(const Amg::Vector3D &position) {
+ amgPseudoRapidity(const Amg::Vector3D& position) {
float pseudo(0.);
float ma = position.mag(), dz = position.z();
@@ -113,7 +102,7 @@ using std::ostringstream;
using std::string;
// Constructor with parameters:
-SCTHitEffMonTool::SCTHitEffMonTool(const string &type, const string &name, const IInterface *parent) :
+SCTHitEffMonTool::SCTHitEffMonTool(const string& type, const string& name, const IInterface* parent) :
ManagedMonitorToolBase(type, name, parent),
m_TrackName(std::string("ResolvedSCTTracks")),// original track collection
m_chrono(nullptr),
@@ -321,7 +310,7 @@ SCTHitEffMonTool::SCTHitEffMonTool(const string &type, const string &name, const
/*---------------------------------------------------------*/
StatusCode
SCTHitEffMonTool::initialize() {
- INFO("Initializing SCTHitEffMonTool");
+ ATH_MSG_INFO("Initializing SCTHitEffMonTool");
CHECK(detStore()->retrieve(m_sctId, "SCT_ID"));
CHECK(detStore()->retrieve(m_pixelId, "PixelID"));
@@ -332,14 +321,14 @@ SCTHitEffMonTool::initialize() {
}
CHECK(ManagedMonitorToolBase::initialize());
CHECK(m_holeSearchTool.retrieve());
- INFO("Retrieved hole search tool " << m_holeSearchTool);
+ ATH_MSG_INFO("Retrieved hole search tool " << m_holeSearchTool);
CHECK(m_residualPullCalculator.retrieve());
- INFO("Retrieved pull calculator tool " << m_residualPullCalculator);
+ ATH_MSG_INFO("Retrieved pull calculator tool " << m_residualPullCalculator);
CHECK(m_rotcreator.retrieve());
- INFO("Retrieved tool " << m_rotcreator);
+ ATH_MSG_INFO("Retrieved tool " << m_rotcreator);
CHECK(m_fieldServiceHandle.retrieve());
CHECK(m_bunchCrossingTool.retrieve());
- INFO("Retrieved BunchCrossing tool " << m_bunchCrossingTool);
+ ATH_MSG_INFO("Retrieved BunchCrossing tool " << m_bunchCrossingTool);
m_path = (m_useIDGlobal) ? ("/InDetGlobal/") : ("");
@@ -375,18 +364,18 @@ SCTHitEffMonTool::bookHistograms() {
return StatusCode::SUCCESS;
}
if (m_isCosmic) {
- WARNING("Running on cosmics: releasing d0 cut and forcing use of TRT timing");
+ ATH_MSG_WARNING("Running on cosmics: releasing d0 cut and forcing use of TRT timing");
}
if (not m_fieldServiceHandle->solenoidOn()) {
- WARNING("Running with solenoid off: releasing pT cut");
+ ATH_MSG_WARNING("Running with solenoid off: releasing pT cut");
m_minPt = -1.;
}
if (newRunFlag()) {
m_badChips = m_configConditions->badChips();
- INFO("Found " << m_badChips->size() << " bad chips");
+ ATH_MSG_INFO("Found " << m_badChips->size() << " bad chips");
for (std::map<Identifier, unsigned int>::const_iterator chip(m_badChips->begin()); chip != m_badChips->end();
++chip) {
- VERBOSE("Module " << m_sctId->wafer_hash(chip->first) << ", chip " << chip->second);
+ ATH_MSG_VERBOSE("Module " << m_sctId->wafer_hash(chip->first) << ", chip " << chip->second);
}
std::array < MonGroup, N_REGIONS + 1 > histGroupE = {{
@@ -503,7 +492,7 @@ SCTHitEffMonTool::bookHistograms() {
for (Long_t i(0); i != n_layers[isub]; ++i) {
const int detIndex = becIdxLayer2Index(isub, i);
if (detIndex == -1) {
- WARNING("Subdetector region (barrel, endcap A, endcap C) could not be determined");
+ ATH_MSG_WARNING("Subdetector region (barrel, endcap A, endcap C) could not be determined");
continue;
}
for (Long_t j(0); j != 2; ++j) {
@@ -732,18 +721,18 @@ SCTHitEffMonTool::bookHistograms() {
StatusCode
SCTHitEffMonTool::bookHistogramsRecurrent() {
if (m_isCosmic) {
- WARNING("Running on cosmics: releasing d0 cut and forcing use of TRT timing");
+ ATH_MSG_WARNING("Running on cosmics: releasing d0 cut and forcing use of TRT timing");
}
if (not m_fieldServiceHandle->solenoidOn()) {
- WARNING("Running with solenoid off: releasing pT cut");
+ ATH_MSG_WARNING("Running with solenoid off: releasing pT cut");
m_minPt = -1.;
}
if (newRunFlag()) {
m_badChips = m_configConditions->badChips();
- INFO("Found " << m_badChips->size() << " bad chips");
+ ATH_MSG_INFO("Found " << m_badChips->size() << " bad chips");
for (std::map<Identifier, unsigned int>::const_iterator chip(m_badChips->begin()); chip != m_badChips->end();
++chip) {
- VERBOSE("Module " << m_sctId->wafer_hash(chip->first) << ", chip " << chip->second);
+ ATH_MSG_VERBOSE("Module " << m_sctId->wafer_hash(chip->first) << ", chip " << chip->second);
}
std::array < MonGroup, N_REGIONS + 1 > histGroupE = {{
@@ -855,7 +844,7 @@ SCTHitEffMonTool::bookHistogramsRecurrent() {
for (Long_t i(0); i != n_layers[isub]; ++i) {
const int detIndex(becIdxLayer2Index(isub, i));
if (detIndex == -1) {
- WARNING("Detector region (barrel, endcap A, endcap C) could not be determined");
+ ATH_MSG_WARNING("Detector region (barrel, endcap A, endcap C) could not be determined");
continue;
}
for (Long_t j(0); j != 2; ++j) {
@@ -1082,22 +1071,23 @@ StatusCode
SCTHitEffMonTool::fillHistograms() {
errorcheck::ReportMessage::hideErrorLocus(true);
- VERBOSE("SCTHitEffMonTool::fillHistograms()");
+ ATH_MSG_VERBOSE("SCTHitEffMonTool::fillHistograms()");
Double_t timecor(-20.);
if (m_useTRTPhase or m_isCosmic) {
SG::ReadHandle<ComTime> theComTime(m_comTimeName);
if (theComTime.isValid()) {
timecor = theComTime->getTime();
- VERBOSE("Retrieved ComTime object with name " << m_comTimeName.key() << " found: Time = " << timecor);
+ ATH_MSG_VERBOSE("Retrieved ComTime object with name " << m_comTimeName.key() << " found: Time = " << timecor);
} else {
timecor = -18.;
- WARNING("ComTime object not found with name " << m_comTimeName.key());
+ ATH_MSG_WARNING("ComTime object not found with name " << m_comTimeName.key());
}
}
// If we are going to use TRT phase in anger, need run-dependent corrections.
SG::ReadHandle<xAOD::EventInfo> pEvent(m_eventInfoKey);
if (not pEvent.isValid()) {
- return ERROR("Could not find EventInfo"), StatusCode::FAILURE;
+ ATH_MSG_ERROR("Could not find EventInfo");
+ return StatusCode::FAILURE;
}
unsigned BCID = pEvent->bcid();
int BCIDpos = m_bunchCrossingTool->distanceFromFront(BCID);
@@ -1110,18 +1100,18 @@ SCTHitEffMonTool::fillHistograms() {
// ---- First try if m_tracksName is a TrackCollection
SG::ReadHandle<TrackCollection>tracks(m_TrackName);
if (not tracks.isValid()) {
- WARNING("Tracks not found: " << tracks << " / " << m_TrackName.key());
+ ATH_MSG_WARNING("Tracks not found: " << tracks << " / " << m_TrackName.key());
if (m_chronotime) {
m_chrono->chronoStop("SCTHitEff");
}
return StatusCode::SUCCESS;
} else {
- VERBOSE("Successfully retrieved " << m_TrackName.key() << " : " << tracks->size() << " items");
+ ATH_MSG_VERBOSE("Successfully retrieved " << m_TrackName.key() << " : " << tracks->size() << " items");
}
SG::ReadHandle<InDet::SCT_ClusterContainer> p_sctclcontainer(m_sctContainerName);
if (not p_sctclcontainer.isValid()) {
- WARNING("SCT clusters container not found: " << m_sctContainerName.key());
+ ATH_MSG_WARNING("SCT clusters container not found: " << m_sctContainerName.key());
if (m_chronotime) {
m_chrono->chronoStop("SCTHitEff");
}
@@ -1151,7 +1141,7 @@ SCTHitEffMonTool::fillHistograms() {
const TrackCollection::const_iterator endOfTracks(tracks->end());
for (TrackCollection::const_iterator itr(tracks->begin()); itr != endOfTracks; ++itr) {
nTrk++;
- const Trk::Track *pthisTrack(*itr);
+ const Trk::Track* pthisTrack(*itr);
if (not pthisTrack) {
continue;
}
@@ -1168,8 +1158,8 @@ SCTHitEffMonTool::fillHistograms() {
if (pthisTrack->perigeeParameters() == 0) {
continue;
}
- const Trk::Perigee *perigee = pthisTrack->perigeeParameters();
- const AmgVector(5) & perigeeParameters(perigee->parameters());
+ const Trk::Perigee* perigee = pthisTrack->perigeeParameters();
+ const AmgVector(5)& perigeeParameters(perigee->parameters());
const float d0(perigeeParameters[Trk::d0]);
const float z0(perigeeParameters[Trk::z0]);
const float perigeeTheta(perigeeParameters[Trk::theta]);
@@ -1189,8 +1179,8 @@ SCTHitEffMonTool::fillHistograms() {
// Loop over original track collection
// const TrackCollection::const_iterator endOfTracks(tracks->end());
for (TrackCollection::const_iterator itr(tracks->begin()); itr != endOfTracks; ++itr) {
- VERBOSE("Starting new track");
- const Trk::Track *pthisTrack(*itr);
+ ATH_MSG_VERBOSE("Starting new track");
+ const Trk::Track* pthisTrack(*itr);
if (not pthisTrack) {
continue;
}
@@ -1206,8 +1196,8 @@ SCTHitEffMonTool::fillHistograms() {
if (pthisTrack->perigeeParameters() == 0) {
continue;
}
- const Trk::Perigee *perigee = pthisTrack->perigeeParameters();
- const AmgVector(5) & perigeeParameters(perigee->parameters());
+ const Trk::Perigee* perigee = pthisTrack->perigeeParameters();
+ const AmgVector(5)& perigeeParameters(perigee->parameters());
const float d0(perigeeParameters[Trk::d0]);
const float z0(perigeeParameters[Trk::z0]);
const float perigeeTheta(perigeeParameters[Trk::theta]);
@@ -1229,18 +1219,18 @@ SCTHitEffMonTool::fillHistograms() {
bool useDetector[N_REGIONS] = {
false, false, false
};
- const Trk::TrackSummary *summary = pthisTrack->trackSummary();
+ const Trk::TrackSummary* summary = pthisTrack->trackSummary();
if (summary and summary->get(Trk::numberOfSCTHits) < 1) {
continue;
}
- const Trk::Track *trackWithHoles = m_holeSearchTool->getTrackWithHoles(*pthisTrack);
+ const Trk::Track* trackWithHoles = m_holeSearchTool->getTrackWithHoles(*pthisTrack);
if (not trackWithHoles) {
- WARNING("trackWithHoles pointer is invalid");
+ ATH_MSG_WARNING("trackWithHoles pointer is invalid");
continue;
}
- VERBOSE("Found " << trackWithHoles->trackStateOnSurfaces()->size() << " states on track");
+ ATH_MSG_VERBOSE("Found " << trackWithHoles->trackStateOnSurfaces()->size() << " states on track");
// loop over all hits on track
DataVector<const Trk::TrackStateOnSurface>::const_iterator TSOSItr =
trackWithHoles->trackStateOnSurfaces()->begin();
@@ -1288,7 +1278,7 @@ SCTHitEffMonTool::fillHistograms() {
zmax = std::max(zpos, zmax);
zmin = std::min(zpos, zmin);
}else {
- WARNING("No track parameter found. Zmin and Zmax not recalculated.");
+ ATH_MSG_WARNING("No track parameter found. Zmin and Zmax not recalculated.");
}
}else { // else use layer/side number : better but does not work for cosmics
if (m_sctId->is_sct(surfaceID)) {
@@ -1316,7 +1306,7 @@ SCTHitEffMonTool::fillHistograms() {
}
for (TSOSItr = trackWithHoles->trackStateOnSurfaces()->begin(); TSOSItr != TSOSItrE; ++TSOSItr) {
- VERBOSE("Starting new hit");
+ ATH_MSG_VERBOSE("Starting new hit");
surfaceID = surfaceOnTrackIdentifier(*TSOSItr);
if (failCut(m_sctId->is_sct(surfaceID), "hit cut: is in SCT")) {
@@ -1327,13 +1317,13 @@ SCTHitEffMonTool::fillHistograms() {
if (failCut(not (isub == INVALID_INDEX), "hit cut: valid sub-detector")) {
continue;
}
- VERBOSE("New SCT candidate: " << m_sctId->print_to_string(surfaceID));
+ ATH_MSG_VERBOSE("New SCT candidate: " << m_sctId->print_to_string(surfaceID));
Int_t side(m_sctId->side(surfaceID));
Int_t layer(m_sctId->layer_disk(surfaceID));
const int detIndex = becIdxLayer2Index(isub, layer);
if (detIndex == -1) {
- WARNING("The detector region (barrel, endcap A, endcap C) could not be determined");
+ ATH_MSG_WARNING("The detector region (barrel, endcap A, endcap C) could not be determined");
continue;
}
Int_t histnumber(detIndex);
@@ -1342,7 +1332,7 @@ SCTHitEffMonTool::fillHistograms() {
Identifier module_id(m_sctId->module_id(surfaceID));
Float_t layerPlusHalfSide(float(layer) + float(side) * 0.5);
Float_t dedicated_layerPlusHalfSide(float(layer) + float((side + 1) % 2) * 0.5);
- const Trk::TrackParameters *trkParamOnSurface((*TSOSItr)->trackParameters());
+ const Trk::TrackParameters* trkParamOnSurface((*TSOSItr)->trackParameters());
Double_t trackHitResidual(getResidual(surfaceID, trkParamOnSurface, &*p_sctclcontainer));
@@ -1382,7 +1372,7 @@ SCTHitEffMonTool::fillHistograms() {
Double_t phiUp(90.);
Double_t theta(90.);
if (trkParamOnSurface and not findAnglesToWaferSurface(trkParamOnSurface->momentum(), surfaceID, elements, theta, phiUp)) {
- WARNING("Error from findAngles");
+ ATH_MSG_WARNING("Error from findAngles");
}
if (m_detailed) {
@@ -1423,7 +1413,7 @@ SCTHitEffMonTool::fillHistograms() {
m_Eff_timecorHisto[isub]->Fill(timecor, eff);
}
}
- DEBUG("Use TRT phase " << m_useTRTPhase << " is cosmic? " << m_isCosmic << " timecor " << timecor);
+ ATH_MSG_DEBUG("Use TRT phase " << m_useTRTPhase << " is cosmic? " << m_isCosmic << " timecor " << timecor);
if (m_useTRTPhase or m_isCosmic) {
if (timecor == 0) {
continue;
@@ -1476,7 +1466,7 @@ SCTHitEffMonTool::fillHistograms() {
if (failCut(timecor >= tmin and timecor <= tmax, "track cut: timing cut")) {
continue;
}
- DEBUG(timecor << " " << tmin << " " << tmax);
+ ATH_MSG_DEBUG(timecor << " " << tmin << " " << tmax);
}
if (m_detailed) {
m_SelectionHisto[isub]->Fill(3.); // Past TRT time/Hits selection
@@ -1489,7 +1479,7 @@ SCTHitEffMonTool::fillHistograms() {
zpos = (*TSOSItr)->trackParameters()->position().z();
enclosingHits = (zpos > zmin)and(zpos < zmax);
}else {
- WARNING("No track parameters found. Cannot determine whether it is an enclosed hit.");
+ ATH_MSG_WARNING("No track parameters found. Cannot determine whether it is an enclosed hit.");
enclosingHits = false;
}
}else {
@@ -1657,7 +1647,7 @@ SCTHitEffMonTool::fillHistograms() {
// Check bad chips
Bool_t nearBadChip(false);
IdentifierHash waferHash = m_sctId->wafer_hash(surfaceID);
- const InDetDD::SiDetectorElement *pElement = elements->getDetectorElement(waferHash);
+ const InDetDD::SiDetectorElement* pElement = elements->getDetectorElement(waferHash);
bool swap = (pElement->swapPhiReadoutDirection()) ? true : false;
Int_t chipPos(previousChip(xl, side, swap));
unsigned int status(0);
@@ -1677,7 +1667,7 @@ SCTHitEffMonTool::fillHistograms() {
if (m_vetoBadChips and failCut(not nearBadChip, "hit cut: not near bad chip")) {
continue;
}
- VERBOSE("Candidate passed all cuts");
+ ATH_MSG_VERBOSE("Candidate passed all cuts");
m_Eff_summaryHisto_old[isub]->Fill(layerPlusHalfSide, eff); // in order to calculate m_EffsummaryIncBadMod
m_Eff_summaryHisto[isub]->Fill(dedicated_layerPlusHalfSide, eff); // adjustment for dedicated_title()
m_Eff_hashCodeHisto->Fill(Double_t(sideHash), eff);
@@ -1742,7 +1732,7 @@ SCTHitEffMonTool::fillHistograms() {
const int ieta(m_sctId->eta_module(surfaceID));
const int iphi(m_sctId->phi_module(surfaceID));
m_effMap[histnumber][side]->Fill(ieta, iphi, eff);
- if( BCIDpos <= 0 ){
+ if ( BCIDpos <= 0 ){
m_effMapFirstBCID[histnumber][side]->Fill(ieta, iphi, eff);
}
m_effLumiBlock[histnumber][side]->Fill(pEvent->lumiBlock(), eff);
@@ -1753,7 +1743,7 @@ SCTHitEffMonTool::fillHistograms() {
m_ineffMap[histnumber][side]->Fill(ieta, iphi, (eff == 0));
}
if (testOffline) {
- INFO("Filling " << histnumber << ", " << side << " eta " << ieta << " phi " << iphi);
+ ATH_MSG_INFO("Filling " << histnumber << ", " << side << " eta " << ieta << " phi " << iphi);
}
} // End of loop over hits/holes
if (m_detailed) {
@@ -1792,7 +1782,7 @@ SCTHitEffMonTool::fillHistograms() {
delete trackWithHoles;
trackWithHoles = 0;
}
- VERBOSE("finished loop over tracks = " << (*tracks).size());
+ ATH_MSG_VERBOSE("finished loop over tracks = " << (*tracks).size());
if (m_detailed) {
m_nTrkHisto->Fill(nTrk);
m_nTrkParsHisto->Fill(nTrkPars);
@@ -1818,8 +1808,8 @@ SCTHitEffMonTool::procHistograms() {
return StatusCode::FAILURE;
}
- const std::set<Identifier> *badModules = m_configConditions->badModules();
- INFO("Found " << badModules->size() << " bad modules");
+ const std::set<Identifier>* badModules = m_configConditions->badModules();
+ ATH_MSG_INFO("Found " << badModules->size() << " bad modules");
std::array < std::array < double, N_ENDCAPS >, N_REGIONS > MaxEta;
std::array < std::array < double, N_ENDCAPS >, N_REGIONS > MaxPhi;
for (int isub(0); isub < N_REGIONS; ++isub) {
@@ -1868,7 +1858,7 @@ SCTHitEffMonTool::procHistograms() {
eff = (accSide[0] + accSide[1]) / 2;
}
}else {
- VERBOSE("Bad module : " << *wafItr << " " << m_sctId->wafer_hash(*wafItr));
+ ATH_MSG_VERBOSE("Bad module : " << *wafItr << " " << m_sctId->wafer_hash(*wafItr));
m_badModMap->SetPoint(m_badModMap->GetN(), amgPseudoRapidity(position), position.phi());
m_badModMap->SetPointError(m_badModMap->GetN() - 1, dEta / 2, dPhi / 2);
m_badModMap->GetXaxis()->SetRangeUser(-3, 3);
@@ -1892,7 +1882,7 @@ SCTHitEffMonTool::procHistograms() {
mapOfInEff[*wafItr] = eff;
Int_t histnumber(becIdxLayer2Index(isub, layer));
if (histnumber == -1) {
- WARNING("Barrel-or-endcap index is invalid");
+ ATH_MSG_WARNING("Barrel-or-endcap index is invalid");
return StatusCode::FAILURE;
}
m_accMap[histnumber]->Fill(m_sctId->eta_module(*wafItr), m_sctId->phi_module(*wafItr), (1. - eff) * N_CHIPS * 2);
@@ -1917,7 +1907,7 @@ SCTHitEffMonTool::procHistograms() {
std::sort(phibins[isub][i].begin(), phibins[isub][i].end());
Int_t histnumber(becIdxLayer2Index(isub, i));
if (histnumber < 0) {
- WARNING("Barrel-or-endcap index is invalid");
+ ATH_MSG_WARNING("Barrel-or-endcap index is invalid");
return StatusCode::FAILURE;
}
CHECK(bookEffHisto(m_accPhysMap[histnumber], histGroupE[isub],
@@ -1946,14 +1936,11 @@ SCTHitEffMonTool::procHistograms() {
Identifier surfaceID(bMod->first);
Int_t histnumber(becIdxLayer2Index(bec2Index(m_sctId->barrel_ec(surfaceID)), m_sctId->layer_disk(surfaceID)));
if (histnumber < 0) {
- WARNING("Barrel-or-endcap index is invalid");
+ ATH_MSG_WARNING("Barrel-or-endcap index is invalid");
return StatusCode::FAILURE;
}
IdentifierHash waferHash = m_sctId->wafer_hash(surfaceID);
- const InDetDD::SiDetectorElement *element = elements->getDetectorElement(waferHash);
- // const HepGeom::Point3D<float> position = element->center();
- // m_accPhysMap[histnumber]->Fill(position.pseudoRapidity(), position.phi(), (1. - bMod->second) * N_CHIPS *
- // 2);
+ const InDetDD::SiDetectorElement* element = elements->getDetectorElement(waferHash);
const Amg::Vector3D position = element->center();
m_accPhysMap[histnumber]->Fill(amgPseudoRapidity(position), position.phi(), (1. - bMod->second) * N_CHIPS * 2);
}
@@ -1983,10 +1970,10 @@ SCTHitEffMonTool::procHistograms() {
StatusCode
SCTHitEffMonTool::failCut(Bool_t value, std::string name) {
if (value) {
- VERBOSE("Passed " << name);
+ ATH_MSG_VERBOSE("Passed " << name);
return StatusCode::FAILURE;
}
- VERBOSE("Failed " << name);
+ ATH_MSG_VERBOSE("Failed " << name);
return StatusCode::SUCCESS;
}
@@ -2007,22 +1994,19 @@ SCTHitEffMonTool::previousChip(Double_t xl, Int_t side, bool swap) {
}
StatusCode
-SCTHitEffMonTool::findAnglesToWaferSurface(const Amg::Vector3D &mom, const Identifier id,
+SCTHitEffMonTool::findAnglesToWaferSurface(const Amg::Vector3D& mom, const Identifier id,
const InDetDD::SiDetectorElementCollection* elements,
- Double_t &theta, Double_t &phi) {
+ Double_t& theta, Double_t& phi) {
phi = 90.;
theta = 90.;
const Identifier waferId = m_sctId->wafer_id(id);
const IdentifierHash waferHash = m_sctId->wafer_hash(waferId);
- const InDetDD::SiDetectorElement *element = elements->getDetectorElement(waferHash);
+ const InDetDD::SiDetectorElement* element = elements->getDetectorElement(waferHash);
if (not element) {
- VERBOSE("findAnglesToWaferSurface: failed to find detector element for id = " << m_sctId->print_to_string(id));
+ ATH_MSG_VERBOSE("findAnglesToWaferSurface: failed to find detector element for id = " << m_sctId->print_to_string(id));
return StatusCode::FAILURE;
}
- // Double_t pNormal(mom * element->normal());
- // Double_t pEta(mom * element->etaAxis());
- // Double_t pPhi(mom * element->phiAxis());
Double_t pNormal(mom.dot(element->normal()));
Double_t pEta(mom.dot(element->etaAxis()));
Double_t pPhi(mom.dot(element->phiAxis()));
@@ -2040,41 +2024,41 @@ SCTHitEffMonTool::findAnglesToWaferSurface(const Amg::Vector3D &mom, const Ident
}
template <class T> StatusCode
-SCTHitEffMonTool::bookEffHisto(T * &histo, MonGroup &MG, TString name, TString title, Int_t nbin, Double_t x1,
+SCTHitEffMonTool::bookEffHisto(T*& histo, MonGroup& MG, TString name, TString title, Int_t nbin, Double_t x1,
Double_t x2) {
histo = new T(name, title, nbin, x1, x2);
CHECK(MG.regHist(histo));
- VERBOSE("Registered " << name << " at " << histo);
+ ATH_MSG_VERBOSE("Registered " << name << " at " << histo);
return StatusCode::SUCCESS;
}
template <class T> StatusCode
-SCTHitEffMonTool::bookEffHisto(T * &histo, MonGroup &MG, TString name, TString title,
+SCTHitEffMonTool::bookEffHisto(T*& histo, MonGroup& MG, TString name, TString title,
Int_t nbinx, Double_t x1, Double_t x2,
Int_t nbiny, Double_t y1, Double_t y2) {
histo = new T(name, title, nbinx, x1, x2, nbiny, y1, y2);
CHECK(MG.regHist(histo));
- VERBOSE("Registered " << name << " at " << histo);
+ ATH_MSG_VERBOSE("Registered " << name << " at " << histo);
return StatusCode::SUCCESS;
}
template <class T> StatusCode
-SCTHitEffMonTool::bookEffHisto(T * &histo, MonGroup &MG, TString name, TString title,
- Int_t nbinx, Double_t *xbins, Int_t nbiny, Double_t *ybins) {
+SCTHitEffMonTool::bookEffHisto(T*& histo, MonGroup& MG, TString name, TString title,
+ Int_t nbinx, Double_t* xbins, Int_t nbiny, Double_t* ybins) {
histo = new T(name, title, nbinx, xbins, nbiny, ybins);
CHECK(MG.regHist(histo));
- VERBOSE("Registered " << name << " at " << histo);
+ ATH_MSG_VERBOSE("Registered " << name << " at " << histo);
return StatusCode::SUCCESS;
}
// Find the residual to track.
Double_t
-SCTHitEffMonTool::getResidual(const Identifier &surfaceID, const Trk::TrackParameters *trkParam,
- const InDet::SCT_ClusterContainer *p_sctclcontainer) {
+SCTHitEffMonTool::getResidual(const Identifier& surfaceID, const Trk::TrackParameters* trkParam,
+ const InDet::SCT_ClusterContainer* p_sctclcontainer) {
Double_t trackHitResidual(-999.);
if (not trkParam) {
- WARNING("Not track parameters found. Returning default residual value.");
+ ATH_MSG_WARNING("Not track parameters found. Returning default residual value.");
return trackHitResidual;
}
IdentifierHash idh(m_sctId->wafer_hash(surfaceID));
@@ -2083,16 +2067,15 @@ SCTHitEffMonTool::getResidual(const Identifier &surfaceID, const Trk::TrackParam
for (; containerIterator != containerEnd; ++containerIterator) {
for (InDet::SCT_ClusterCollection::const_iterator rioIterator((*containerIterator)->begin());
rioIterator != (*containerIterator)->end(); ++rioIterator) {
- if (not (*rioIterator)or not (*rioIterator)->detectorElement()) {
- WARNING("NULL pointer to RIO or detElement");
+ if (not (*rioIterator) or not (*rioIterator)->detectorElement()) {
+ ATH_MSG_WARNING("nullptr to RIO or detElement");
continue;
}
if (m_sctId->wafer_id(surfaceID) == m_sctId->wafer_id(((*rioIterator)->detectorElement())->identify())) {
- const Trk::PrepRawData *rioo(dynamic_cast<const Trk::PrepRawData *>(*rioIterator));
- const Trk::RIO_OnTrack *rio(m_rotcreator->correct(*rioo, *trkParam));
+ const Trk::PrepRawData* rioo(dynamic_cast<const Trk::PrepRawData *>(*rioIterator));
+ const Trk::RIO_OnTrack* rio(m_rotcreator->correct(*rioo, *trkParam));
if (!m_residualPullCalculator.empty()) {
- // if(m_residualPullCalculator->residualPull(rio, trkParam,Trk::ResidualPull::Unbiased)==0)continue;
- const Trk::ResidualPull *residualPull(m_residualPullCalculator->residualPull(rio, trkParam,
+ const Trk::ResidualPull* residualPull(m_residualPullCalculator->residualPull(rio, trkParam,
Trk::ResidualPull::Unbiased));
if (residualPull == 0) {
continue;
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitsNoiseMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitsNoiseMonTool.cxx
index e18850fb3b3977cb3e0338278aa16addc0c3dc17..0fdd7ad6cc72407ac8dbf53ee6fda107f739ba93 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitsNoiseMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTHitsNoiseMonTool.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
/** @file SCTHitsNoiseMonTool.cxx
@@ -11,54 +11,45 @@
* 'The end of all of our exploring...' (Shaun, March 2008)
*/
-#include "SCT_NameFormatter.h"
-
-#include <sstream> // ?
-#include <iostream>
-#include <fstream> // for writing an xml summary (debugging)
-#include <algorithm>
-
-
-#include "GaudiKernel/IJobOptionsSvc.h"
#include "SCT_Monitoring/SCTHitsNoiseMonTool.h"
-#include "SCT_Monitoring/SCT_ClusterStruct.h"
-#include "TMath.h"
-#include "TH1F.h"
-#include "TH2I.h"
-#include "TH2F.h"
-#include "TProfile.h"
-#include "TProfile2D.h"
-#include "LWHists/TH1F_LW.h"
-#include "LWHists/TH2F_LW.h"
-#include "LWHists/TH2I_LW.h"
-#include "LWHists/TProfile_LW.h"
-#include "LWHists/TProfile2D_LW.h"
+#include "cArrayUtilities.h"
+#include "SCT_NameFormatter.h"
+#include "AthContainers/DataVector.h"
#include "InDetRawData/SCT3_RawData.h"
-#include "InDetRawData/SCT_TB03_RawData.h" // ?
#include "InDetRawData/InDetRawDataContainer.h" // ?
#include "InDetRawData/InDetRawDataCLASS_DEF.h" // ?
-#include "AthContainers/DataVector.h"
#include "Identifier/Identifier.h"
#include "InDetIdentifier/SCT_ID.h"
-
+#include "InDetPrepRawData/SCT_ClusterContainer.h"
+#include "InDetRIO_OnTrack/SiClusterOnTrack.h"
+#include "LWHists/TH1F_LW.h"
+#include "LWHists/TH2F_LW.h"
+#include "LWHists/TH2I_LW.h"
+#include "LWHists/TProfile_LW.h"
+#include "LWHists/TProfile2D_LW.h"
#include "SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h"
-
-#include "PathResolver/PathResolver.h" // ?
-#include "InDetPrepRawData/SCT_ClusterContainer.h" // ?
+#include "StoreGate/ReadHandle.h"
+#include "TrkEventUtils/RoT_Extractor.h"
+#include "TrkRIO_OnTrack/RIO_OnTrack.h"
#include "TrkSpacePoint/SpacePoint.h"
#include "TrkSpacePoint/SpacePointCollection.h"
#include "TrkSpacePoint/SpacePointOverlapCollection.h"
#include "TrkSpacePoint/SpacePointCLASS_DEF.h"
-#include "TrkRIO_OnTrack/RIO_OnTrack.h"
-#include "TrkEventUtils/RoT_Extractor.h"
-#include "InDetRIO_OnTrack/TRT_DriftCircleOnTrack.h" // ?
-#include "InDetRIO_OnTrack/PixelClusterOnTrack.h" // ?
-#include "cArrayUtilities.h"
+#include "GaudiKernel/IJobOptionsSvc.h"
-#include "StoreGate/ReadHandle.h"
+#include "TMath.h"
+#include "TH1F.h"
+#include "TH2I.h"
+#include "TH2F.h"
+#include "TProfile.h"
+#include "TProfile2D.h"
+
+#include <iostream>
+#include <fstream> // for writing an xml summary (debugging)
+#include <algorithm>
typedef Trk::SpacePoint SpacePoint;
using namespace std;
@@ -70,7 +61,7 @@ namespace { // use anonymous namespace to restrict scope to this file, equivalen
// is a variable in the specified range?
template <typename T>
bool
- inRange(const T &variable, const T &lo, const T &hi) {
+ inRange(const T& variable, const T& lo, const T& hi) {
return not ((variable < lo)or(variable > hi)); // assumes both less_than and greater_than exist for this type
}
@@ -139,9 +130,9 @@ namespace { // use anonymous namespace to restrict scope to this file, equivalen
* numbers to be used, and the timebin.
*/
// ====================================================================================================
-SCTHitsNoiseMonTool::SCTHitsNoiseMonTool(const std::string &type,
- const std::string &name,
- const IInterface *parent) :
+SCTHitsNoiseMonTool::SCTHitsNoiseMonTool(const std::string& type,
+ const std::string& name,
+ const IInterface* parent) :
SCTMotherTrigMonTool(type, name, parent),
m_nSP(nullptr),
m_nSP_buf(nullptr),
@@ -298,12 +289,12 @@ SCTHitsNoiseMonTool::SCTHitsNoiseMonTool(const std::string &type,
m_eventInfoKey(std::string("EventInfo")),
m_clusContainerKey("SCT_Clusters") {
/** sroe 3 Sept 2015:
- histoPathBase is declared as a property in the base class, assigned to m_path
- with default as empty string.
- Declaring it here as well gives rise to compilation warning
- WARNING duplicated property name 'histoPathBase', see https://its.cern.ch/jira/browse/GAUDI-1023
+ histoPathBase is declared as a property in the base class, assigned to m_path
+ with default as empty string.
+ Declaring it here as well gives rise to compilation warning
+ WARNING duplicated property name 'histoPathBase', see https://its.cern.ch/jira/browse/GAUDI-1023
- declareProperty("histoPathBase", m_stream = "/stat"); **/
+ declareProperty("histoPathBase", m_stream = "/stat"); **/
m_stream = "/stat";
declareProperty("localSummary", m_localSummary = 0);
declareProperty("doHitmapHistos", m_boolhitmaps = true);
@@ -634,11 +625,11 @@ SCTHitsNoiseMonTool::fillHistograms() {
}
m_hitoccTrigger_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb;
m_hitoccTriggerBAR_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerBAR_lb[*planeIterator] /
- m_eventsTrigger_lb;
+ m_eventsTrigger_lb;
m_hitoccTriggerECp_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerECp_lb[*planeIterator] /
- m_eventsTrigger_lb;
+ m_eventsTrigger_lb;
m_hitoccTriggerECm_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerECm_lb[*planeIterator] /
- m_eventsTrigger_lb;
+ m_eventsTrigger_lb;
if ((1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 100.) {
m_noisyMWithHOTrigger100[m_current_lb]++;
}
@@ -825,16 +816,16 @@ SCTHitsNoiseMonTool::generalHistsandNoise() {
std::vector<int> ECp_local_nhitslayer(N_DISKSx2, 0);
std::vector<int> ECm_local_nhitslayer(N_DISKSx2, 0);
//
- std::vector<H2_t> *hitHistogramVectors[3] = {
+ std::vector<H2_t>* hitHistogramVectors[3] = {
&m_phitsHistoVectorECm, &m_phitsHistoVector, &m_phitsHistoVectorECp
};
- std::vector<H2_t> *hitHistogramVectorsRecent[3] = {
+ std::vector<H2_t>* hitHistogramVectorsRecent[3] = {
&m_phitsHistoVectorRecentECm, &m_phitsHistoVectorRecent, &m_phitsHistoVectorRecentECp
};
H1_t hitPerLumiBlockHists[3] = {
m_numHitsPerLumiBlockECm, m_numBarrelHitsPerLumiBlock, m_numHitsPerLumiBlockECp
};
- std::vector<int> *hitsInLayer[3] = {
+ std::vector<int>* hitsInLayer[3] = {
&ECm_local_nhitslayer, &barrel_local_nhitslayer, &ECp_local_nhitslayer
};
const bool doThisSubsystem[3] = {
@@ -846,7 +837,7 @@ SCTHitsNoiseMonTool::generalHistsandNoise() {
SpacePointContainer::const_iterator spContainerIteratorEnd = sctContainer->end();
// Outer Loop on RDO Collection
for (; col_it != lastCol; ++col_it) {
- const InDetRawDataCollection<SCTRawDataType> *SCT_Collection(*col_it);
+ const InDetRawDataCollection<SCTRawDataType>* SCT_Collection(*col_it);
if (!SCT_Collection) {
continue; // select only SCT RDOs
}
@@ -871,11 +862,11 @@ SCTHitsNoiseMonTool::generalHistsandNoise() {
DataVector<Trk::SpacePoint>::const_iterator nextSpacePoint = (*spContainerIterator)->begin();
DataVector<Trk::SpacePoint>::const_iterator nextSpacePointEnd = (*spContainerIterator)->end();
for (; nextSpacePoint != nextSpacePointEnd; ++nextSpacePoint) {
- const Trk::SpacePoint &sp = **nextSpacePoint;
+ const Trk::SpacePoint& sp = **nextSpacePoint;
// the following is nasty; the 'normal' sides (where the sp is defined) swap from layer to layer. To be safe,
// we get both sides
- const VecId_t &rdoList0 = sp.clusterList().first->rdoList();
- const VecId_t &rdoList1 = sp.clusterList().second->rdoList();
+ const VecId_t& rdoList0 = sp.clusterList().first->rdoList();
+ const VecId_t& rdoList1 = sp.clusterList().second->rdoList();
// copy to mySetOfSPIds. Use inserter(set, iterator_hint) for a set, or back_inserter(vec) for vector...
copy(rdoList0.begin(), rdoList0.end(), inserter(mySetOfSPIds, mySetOfSPIds.end()));
copy(rdoList1.begin(), rdoList1.end(), inserter(mySetOfSPIds, mySetOfSPIds.end()));
@@ -889,7 +880,7 @@ SCTHitsNoiseMonTool::generalHistsandNoise() {
DataVector<SCTRawDataType>::const_iterator p_rdo = SCT_Collection->begin();
DataVector<SCTRawDataType>::const_iterator end_rdo = SCT_Collection->end();
for (; p_rdo != end_rdo; ++p_rdo) {
- const SCT3_RawData *rdo3 = dynamic_cast<const SCT3_RawData *>(*p_rdo);
+ const SCT3_RawData* rdo3 = dynamic_cast<const SCT3_RawData*>(*p_rdo);
int tbin;// = (*p_rdo)->getTimeBin();
if (rdo3 != 0) {
tbin = (rdo3)->getTimeBin();
@@ -1230,7 +1221,7 @@ SCTHitsNoiseMonTool::generalHistsandNoise() {
}
}
- // if(m_environment!=AthenaMonManager::online){ // Uncomment this line to turn off cluster hists in online
+ // if (m_environment!=AthenaMonManager::online){ // Uncomment this line to turn off cluster hists in online
// Fill Cluster size histogram
SG::ReadHandle<InDet::SCT_ClusterContainer> p_clucontainer(m_clusContainerKey);
if (not p_clucontainer.isValid()) {
@@ -1239,7 +1230,7 @@ SCTHitsNoiseMonTool::generalHistsandNoise() {
InDet::SCT_ClusterContainer::const_iterator clucol_it = p_clucontainer->begin();
InDet::SCT_ClusterContainer::const_iterator lastcluCol = p_clucontainer->end();
for (; clucol_it != lastcluCol; ++clucol_it) {
- const InDet::SCT_ClusterCollection *SCT_Collection(*clucol_it);
+ const InDet::SCT_ClusterCollection* SCT_Collection(*clucol_it);
if (!SCT_Collection) {
continue; // select only SCT RDOs
}
@@ -1248,7 +1239,7 @@ SCTHitsNoiseMonTool::generalHistsandNoise() {
DataVector<InDet::SCT_Cluster>::const_iterator clus_end = SCT_Collection->end();
for (; p_clu != clus_end; ++p_clu) {
Identifier cluId = (*p_clu)->identify();
- const InDet::SCT_Cluster &cluster = **p_clu;
+ const InDet::SCT_Cluster& cluster = **p_clu;
int GroupSize = cluster.rdoList().size();
// Fill Cluster Size histogram
int elementIndex = 2 * m_pSCTHelper->layer_disk(cluId) + m_pSCTHelper->side(cluId);
@@ -1394,13 +1385,13 @@ SCTHitsNoiseMonTool::bookGeneralHits(const unsigned int systemIndex) {
}
}
if (newRunFlag()) {
- VecH2_t *hitsArray[] = {
+ VecH2_t* hitsArray[] = {
&m_phitsHistoVectorECm, &m_phitsHistoVector, &m_phitsHistoVectorECp
};
- VecH2_t *hitsArrayRecent[] = {
+ VecH2_t* hitsArrayRecent[] = {
&m_phitsHistoVectorRecentECm, &m_phitsHistoVectorRecent, &m_phitsHistoVectorRecentECp
};
- VecH1_t *nClustersArray[] = {
+ VecH1_t* nClustersArray[] = {
&m_ncluHistoVectorECm, &m_ncluHistoVector, &m_ncluHistoVectorECp
};
(hitsArray[systemIndex])->clear();
@@ -1414,7 +1405,7 @@ SCTHitsNoiseMonTool::bookGeneralHits(const unsigned int systemIndex) {
string streamhits = "hits" + abbreviations[systemIndex] + "_" + layerSide.name();
std::string histotitle = "SCT Hitmap for " + names[systemIndex] + ": " + layerSide.title();
std::string histotitlerecent = "SCT Hitmap from recent events for " + names[systemIndex] + ": " +
- layerSide.title();
+ layerSide.title();
h2Factory(streamhitmap, histotitle, bec, hitHists, *(hitsArray[systemIndex]));
if (m_environment == AthenaMonManager::online) {
h2Factory(streamhitmaprecent, histotitlerecent, bec, hitHists, *(hitsArrayRecent[systemIndex]));
@@ -1498,10 +1489,10 @@ SCTHitsNoiseMonTool::bookClusterSize() {
StatusCode
SCTHitsNoiseMonTool::bookGeneralCluSize(const unsigned int systemIndex) {
const SCT_Monitoring::Bec bec(index2Bec(systemIndex));
- VecH1_t *clusterSizeArray[] = {
+ VecH1_t* clusterSizeArray[] = {
&m_clusizeHistoVectorECm, &m_clusizeHistoVector, &m_clusizeHistoVectorECp
};
- VecH1_t *clusterSizeArrayRecent[] = {
+ VecH1_t* clusterSizeArrayRecent[] = {
&m_clusizeHistoVectorRecentECm, &m_clusizeHistoVectorRecent, &m_clusizeHistoVectorRecentECp
};
@@ -1519,8 +1510,8 @@ SCTHitsNoiseMonTool::bookGeneralCluSize(const unsigned int systemIndex) {
ATH_MSG_FATAL("Invalid subsystem index, should be 0-2, was " << systemIndex);
return StatusCode::FAILURE;
}
- VecH1_t &clusterSizeVector = *(clusterSizeArray[systemIndex]);
- VecH1_t &clusterSizeVectorRecent = *(clusterSizeArrayRecent[systemIndex]);
+ VecH1_t& clusterSizeVector = *(clusterSizeArray[systemIndex]);
+ VecH1_t& clusterSizeVectorRecent = *(clusterSizeArrayRecent[systemIndex]);
if (newRunFlag()) {
clusterSizeVector.clear();
clusterSizeVectorRecent.clear();
@@ -1536,7 +1527,7 @@ SCTHitsNoiseMonTool::bookGeneralCluSize(const unsigned int systemIndex) {
if (m_environment == AthenaMonManager::online) {
const string streamclusizerecent = "clusize_recent" + abbreviations[systemIndex] + "_" + layerSide.name();
std::string histotitlerecent = "SCT " + names[systemIndex] + " Cluster size from recent events: " +
- layerSide.title();
+ layerSide.title();
h1Factory(streamclusizerecent, histotitlerecent, clusterSize, clusterSizeVectorRecent, 0., 200., 200);
// clusterSizeVectorRecent[systemIndex]->GetXaxis()->SetTitle("Cluster Size");
// clusterSizeVectorRecent[systemIndex]->GetYaxis()->SetTitle("Num of Events");
@@ -1561,14 +1552,14 @@ SCTHitsNoiseMonTool::bookGeneralNoiseOccupancyMaps(const unsigned int systemInde
const unsigned int limits[] = {
N_DISKSx2, N_BARRELSx2, N_DISKSx2
};
- VecProf2_t *storageVectors[] = {
+ VecProf2_t* storageVectors[] = {
&m_pnoiseoccupancymapHistoVectorECm, &m_pnoiseoccupancymapHistoVector, &m_pnoiseoccupancymapHistoVectorECp
};
- VecProf2_t *storageVectorsTrigger[] = {
+ VecProf2_t* storageVectorsTrigger[] = {
&m_pnoiseoccupancymapHistoVectorECmTrigger, &m_pnoiseoccupancymapHistoVectorTrigger,
&m_pnoiseoccupancymapHistoVectorECpTrigger
};
- VecProf2_t *storageVectorsRecent[] = {
+ VecProf2_t* storageVectorsRecent[] = {
&m_pnoiseoccupancymapHistoVectorECmRecent, &m_pnoiseoccupancymapHistoVectorRecent,
&m_pnoiseoccupancymapHistoVectorECpRecent
};
@@ -1582,13 +1573,13 @@ SCTHitsNoiseMonTool::bookGeneralNoiseOccupancyMaps(const unsigned int systemInde
LayerSideFormatter layerSide(i, systemIndex);
const string streamhitmap = "noiseoccupancymap" + abbreviations[systemIndex] + "_" + layerSide.name();
const string streamhitmaptrigger = "noiseoccupancymaptrigger" + abbreviations[systemIndex] + "_" +
- layerSide.name();
+ layerSide.name();
const string streamhitmaprecent = "noiseoccupancymaprecent" + abbreviations[systemIndex] + "_" + layerSide.name();
std::string histotitle = "SCT Noise Occupancy map for " + names[systemIndex] + ": " + layerSide.title();
std::string histotitletrigger = "SCT Noise Occupancy map for " + m_NOTrigger + " Trigger and " +
- names[systemIndex] + ": " + layerSide.title();
+ names[systemIndex] + ": " + layerSide.title();
std::string histotitlerecent = "SCT Noise Occupancy map in recent events for " + names[systemIndex] + ": " +
- layerSide.title();
+ layerSide.title();
prof2Factory(streamhitmap, histotitle, bec, noiseOccMaps, *(storageVectors[systemIndex]));
prof2Factory(streamhitmaptrigger, histotitletrigger, bec, noiseOccMaps, *(storageVectorsTrigger[systemIndex]));
if (m_environment == AthenaMonManager::online) {
@@ -1751,14 +1742,14 @@ SCTHitsNoiseMonTool::bookGeneralHitOccupancyMaps(const unsigned int systemIndex)
const unsigned int limits[] = {
N_DISKSx2, N_BARRELSx2, N_DISKSx2
};
- VecProf2_t *storageVectorsHO[] = {
+ VecProf2_t* storageVectorsHO[] = {
&m_phitoccupancymapHistoVectorECm, &m_phitoccupancymapHistoVector, &m_phitoccupancymapHistoVectorECp
};
- VecProf2_t *storageVectorsTriggerHO[] = {
+ VecProf2_t* storageVectorsTriggerHO[] = {
&m_phitoccupancymapHistoVectorECmTrigger, &m_phitoccupancymapHistoVectorTrigger,
&m_phitoccupancymapHistoVectorECpTrigger
};
- VecProf2_t *storageVectorsRecentHO[] = {
+ VecProf2_t* storageVectorsRecentHO[] = {
&m_phitoccupancymapHistoVectorECmRecent, &m_phitoccupancymapHistoVectorRecent,
&m_phitoccupancymapHistoVectorECpRecent
};
@@ -1774,13 +1765,13 @@ SCTHitsNoiseMonTool::bookGeneralHitOccupancyMaps(const unsigned int systemIndex)
LayerSideFormatter layerSide(i, systemIndex);
const string streamhitmapR = "hitoccupancymap" + abbreviations[systemIndex] + "_" + layerSide.name();
const string streamhitmaptriggerR = "hitoccupancymaptrigger" + abbreviations[systemIndex] + "_" +
- layerSide.name();
+ layerSide.name();
const string streamhitmaprecentR = "hitoccupancymaprecent" + abbreviations[systemIndex] + "_" + layerSide.name();
std::string histotitleR = "SCT Hit Occupancy map for " + names[systemIndex] + ": " + layerSide.title();
std::string histotitletriggerR = "SCT Hit Occupancy map for " + m_NOTrigger + " Trigger and " +
- names[systemIndex] + ": " + layerSide.title();
+ names[systemIndex] + ": " + layerSide.title();
std::string histotitlerecentR = "SCT Hit Occupancy map in recent events for " + names[systemIndex] + ": " +
- layerSide.title();
+ layerSide.title();
prof2Factory(streamhitmapR, histotitleR, bec, hitOccMaps, *(storageVectorsHO[systemIndex]));
prof2Factory(streamhitmaptriggerR, histotitletriggerR, bec, hitOccMaps, *(storageVectorsTriggerHO[systemIndex]));
if (m_environment == AthenaMonManager::online) {
@@ -2099,141 +2090,141 @@ SCTHitsNoiseMonTool::checkNoiseMaps(bool final) {
}
}
- if(m_current_lb<=SCT_Monitoring::NBINS_LBs) {
- m_noisyM100[m_current_lb] = 0;
- m_noisyM1000[m_current_lb] = 0;
- m_noisyM10000[m_current_lb] = 0;
- m_occ_lb[m_current_lb] = 0;
- m_occBAR_lb[m_current_lb] = 0;
- m_occECp_lb[m_current_lb] = 0;
- m_occECm_lb[m_current_lb] = 0;
- m_noisyMTrigger100[m_current_lb] = 0;
- m_noisyMTrigger1000[m_current_lb] = 0;
- m_noisyMTrigger10000[m_current_lb] = 0;
- m_occTrigger_lb[m_current_lb] = 0;
- m_occTriggerBAR_lb[m_current_lb] = 0;
- m_occTriggerECp_lb[m_current_lb] = 0;
- m_occTriggerECm_lb[m_current_lb] = 0;
- m_noisyMWithHO100[m_current_lb] = 0;
- m_noisyMWithHO1000[m_current_lb] = 0;
- m_noisyMWithHO10000[m_current_lb] = 0;
- m_hitocc_lb[m_current_lb] = 0;
- m_hitoccBAR_lb[m_current_lb] = 0;
- m_hitoccECp_lb[m_current_lb] = 0;
- m_hitoccECm_lb[m_current_lb] = 0;
- m_noisyMWithHOTrigger100[m_current_lb] = 0;
- m_noisyMWithHOTrigger1000[m_current_lb] = 0;
- m_noisyMWithHOTrigger10000[m_current_lb] = 0;
- m_hitoccTrigger_lb[m_current_lb] = 0;
- m_hitoccTriggerBAR_lb[m_current_lb] = 0;
- m_hitoccTriggerECp_lb[m_current_lb] = 0;
- m_hitoccTriggerECm_lb[m_current_lb] = 0;
-
- int nlinks = 0;
- int nlinksBAR = 0;
- int nlinksECp = 0;
- int nlinksECm = 0;
- SCT_ID::const_id_iterator planeIterator(m_pSCTHelper->wafer_begin());
- SCT_ID::const_id_iterator planeEnd = m_pSCTHelper->wafer_end();
- for (; planeIterator not_eq planeEnd; ++planeIterator) {
- Identifier planeId(*planeIterator);
- const int bec(m_pSCTHelper->barrel_ec(planeId));
- // Don't initialize a value for disabled modules
- if (!m_ConfigurationTool->isGood(*planeIterator, InDetConditions::SCT_SIDE)) {
- continue;
- }
- if (m_events_lb > 0) {
- m_occ_lb[m_current_lb] += (1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb;
- m_occBAR_lb[m_current_lb] += (1E5) * m_occSumUnbiasedBAR_lb[*planeIterator] / m_events_lb;
- m_occECp_lb[m_current_lb] += (1E5) * m_occSumUnbiasedECp_lb[*planeIterator] / m_events_lb;
- m_occECm_lb[m_current_lb] += (1E5) * m_occSumUnbiasedECm_lb[*planeIterator] / m_events_lb;
- if ((1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb > 100.) {
- m_noisyM100[m_current_lb]++;
- }
- if ((1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb > 1000.) {
- m_noisyM1000[m_current_lb]++;
- }
- if ((1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb > 10000.) {
- m_noisyM10000[m_current_lb]++;
- }
- m_hitocc_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb;
- m_hitoccBAR_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedBAR_lb[*planeIterator] / m_events_lb;
- m_hitoccECp_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedECp_lb[*planeIterator] / m_events_lb;
- m_hitoccECm_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedECm_lb[*planeIterator] / m_events_lb;
- if ((1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb > 100.) {
- m_noisyMWithHO100[m_current_lb]++;
- }
- if ((1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb > 1000.) {
- m_noisyMWithHO1000[m_current_lb]++;
- }
- if ((1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb > 10000.) {
- m_noisyMWithHO10000[m_current_lb]++;
- }
- }
- if (m_eventsTrigger_lb > 0) {
- m_occTrigger_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb;
- m_occTriggerBAR_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTriggerBAR_lb[*planeIterator] /
- m_eventsTrigger_lb;
- m_occTriggerECp_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTriggerECp_lb[*planeIterator] /
- m_eventsTrigger_lb;
- m_occTriggerECm_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTriggerECm_lb[*planeIterator] /
- m_eventsTrigger_lb;
- if ((1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 100.) {
- m_noisyMTrigger100[m_current_lb]++;
- }
- if ((1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 1000.) {
- m_noisyMTrigger1000[m_current_lb]++;
- }
- if ((1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 10000.) {
- m_noisyMTrigger10000[m_current_lb]++;
- }
- m_hitoccTrigger_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] /
- m_eventsTrigger_lb;
- m_hitoccTriggerBAR_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerBAR_lb[*planeIterator] /
- m_eventsTrigger_lb;
- m_hitoccTriggerECp_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerECp_lb[*planeIterator] /
- m_eventsTrigger_lb;
- m_hitoccTriggerECm_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerECm_lb[*planeIterator] /
- m_eventsTrigger_lb;
- if ((1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 100.) {
- m_noisyMWithHOTrigger100[m_current_lb]++;
- }
- if ((1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 1000.) {
- m_noisyMWithHOTrigger1000[m_current_lb]++;
- }
- if ((1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 10000.) {
- m_noisyMWithHOTrigger10000[m_current_lb]++;
- }
- }
- if (bec == BARREL) nlinksBAR++;
- if (bec == ENDCAP_A)nlinksECp++;
- if (bec == ENDCAP_C)nlinksECm++;
- nlinks++;
- }
- if (nlinks >0){
- m_occ_lb[m_current_lb] /= nlinks;
- m_occTrigger_lb[m_current_lb] /= nlinks;
- m_hitocc_lb[m_current_lb] /= nlinks;
- m_hitoccTrigger_lb[m_current_lb] /= nlinks;
- }
- if (nlinksBAR >0){
- m_occBAR_lb[m_current_lb] /= nlinksBAR;
- m_occTriggerBAR_lb[m_current_lb] /= nlinksBAR;
- m_hitoccBAR_lb[m_current_lb] /= nlinksBAR;
- m_hitoccTriggerBAR_lb[m_current_lb] /= nlinksBAR;
- }
- if (nlinksECp >0){
- m_occECp_lb[m_current_lb] /= nlinksECp;
- m_occTriggerECp_lb[m_current_lb] /= nlinksECp;
- m_hitoccECp_lb[m_current_lb] /= nlinksECp;
- m_hitoccTriggerECp_lb[m_current_lb] /= nlinksECp;
- }
- if (nlinksECm >0){
- m_occECm_lb[m_current_lb] /= nlinksECm;
- m_occTriggerECm_lb[m_current_lb] /= nlinksECm;
- m_hitoccECm_lb[m_current_lb] /= nlinksECm;
- m_hitoccTriggerECm_lb[m_current_lb] /= nlinksECm;
- }
+ if (m_current_lb<=SCT_Monitoring::NBINS_LBs) {
+ m_noisyM100[m_current_lb] = 0;
+ m_noisyM1000[m_current_lb] = 0;
+ m_noisyM10000[m_current_lb] = 0;
+ m_occ_lb[m_current_lb] = 0;
+ m_occBAR_lb[m_current_lb] = 0;
+ m_occECp_lb[m_current_lb] = 0;
+ m_occECm_lb[m_current_lb] = 0;
+ m_noisyMTrigger100[m_current_lb] = 0;
+ m_noisyMTrigger1000[m_current_lb] = 0;
+ m_noisyMTrigger10000[m_current_lb] = 0;
+ m_occTrigger_lb[m_current_lb] = 0;
+ m_occTriggerBAR_lb[m_current_lb] = 0;
+ m_occTriggerECp_lb[m_current_lb] = 0;
+ m_occTriggerECm_lb[m_current_lb] = 0;
+ m_noisyMWithHO100[m_current_lb] = 0;
+ m_noisyMWithHO1000[m_current_lb] = 0;
+ m_noisyMWithHO10000[m_current_lb] = 0;
+ m_hitocc_lb[m_current_lb] = 0;
+ m_hitoccBAR_lb[m_current_lb] = 0;
+ m_hitoccECp_lb[m_current_lb] = 0;
+ m_hitoccECm_lb[m_current_lb] = 0;
+ m_noisyMWithHOTrigger100[m_current_lb] = 0;
+ m_noisyMWithHOTrigger1000[m_current_lb] = 0;
+ m_noisyMWithHOTrigger10000[m_current_lb] = 0;
+ m_hitoccTrigger_lb[m_current_lb] = 0;
+ m_hitoccTriggerBAR_lb[m_current_lb] = 0;
+ m_hitoccTriggerECp_lb[m_current_lb] = 0;
+ m_hitoccTriggerECm_lb[m_current_lb] = 0;
+
+ int nlinks = 0;
+ int nlinksBAR = 0;
+ int nlinksECp = 0;
+ int nlinksECm = 0;
+ SCT_ID::const_id_iterator planeIterator(m_pSCTHelper->wafer_begin());
+ SCT_ID::const_id_iterator planeEnd = m_pSCTHelper->wafer_end();
+ for (; planeIterator not_eq planeEnd; ++planeIterator) {
+ Identifier planeId(*planeIterator);
+ const int bec(m_pSCTHelper->barrel_ec(planeId));
+ // Don't initialize a value for disabled modules
+ if (!m_ConfigurationTool->isGood(*planeIterator, InDetConditions::SCT_SIDE)) {
+ continue;
+ }
+ if (m_events_lb > 0) {
+ m_occ_lb[m_current_lb] += (1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb;
+ m_occBAR_lb[m_current_lb] += (1E5) * m_occSumUnbiasedBAR_lb[*planeIterator] / m_events_lb;
+ m_occECp_lb[m_current_lb] += (1E5) * m_occSumUnbiasedECp_lb[*planeIterator] / m_events_lb;
+ m_occECm_lb[m_current_lb] += (1E5) * m_occSumUnbiasedECm_lb[*planeIterator] / m_events_lb;
+ if ((1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb > 100.) {
+ m_noisyM100[m_current_lb]++;
+ }
+ if ((1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb > 1000.) {
+ m_noisyM1000[m_current_lb]++;
+ }
+ if ((1E5) * m_occSumUnbiased_lb[*planeIterator] / m_events_lb > 10000.) {
+ m_noisyM10000[m_current_lb]++;
+ }
+ m_hitocc_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb;
+ m_hitoccBAR_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedBAR_lb[*planeIterator] / m_events_lb;
+ m_hitoccECp_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedECp_lb[*planeIterator] / m_events_lb;
+ m_hitoccECm_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedECm_lb[*planeIterator] / m_events_lb;
+ if ((1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb > 100.) {
+ m_noisyMWithHO100[m_current_lb]++;
+ }
+ if ((1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb > 1000.) {
+ m_noisyMWithHO1000[m_current_lb]++;
+ }
+ if ((1E5) * m_hitoccSumUnbiased_lb[*planeIterator] / m_events_lb > 10000.) {
+ m_noisyMWithHO10000[m_current_lb]++;
+ }
+ }
+ if (m_eventsTrigger_lb > 0) {
+ m_occTrigger_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb;
+ m_occTriggerBAR_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTriggerBAR_lb[*planeIterator] /
+ m_eventsTrigger_lb;
+ m_occTriggerECp_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTriggerECp_lb[*planeIterator] /
+ m_eventsTrigger_lb;
+ m_occTriggerECm_lb[m_current_lb] += (1E5) * m_occSumUnbiasedTriggerECm_lb[*planeIterator] /
+ m_eventsTrigger_lb;
+ if ((1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 100.) {
+ m_noisyMTrigger100[m_current_lb]++;
+ }
+ if ((1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 1000.) {
+ m_noisyMTrigger1000[m_current_lb]++;
+ }
+ if ((1E5) * m_occSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 10000.) {
+ m_noisyMTrigger10000[m_current_lb]++;
+ }
+ m_hitoccTrigger_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] /
+ m_eventsTrigger_lb;
+ m_hitoccTriggerBAR_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerBAR_lb[*planeIterator] /
+ m_eventsTrigger_lb;
+ m_hitoccTriggerECp_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerECp_lb[*planeIterator] /
+ m_eventsTrigger_lb;
+ m_hitoccTriggerECm_lb[m_current_lb] += (1E5) * m_hitoccSumUnbiasedTriggerECm_lb[*planeIterator] /
+ m_eventsTrigger_lb;
+ if ((1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 100.) {
+ m_noisyMWithHOTrigger100[m_current_lb]++;
+ }
+ if ((1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 1000.) {
+ m_noisyMWithHOTrigger1000[m_current_lb]++;
+ }
+ if ((1E5) * m_hitoccSumUnbiasedTrigger_lb[*planeIterator] / m_eventsTrigger_lb > 10000.) {
+ m_noisyMWithHOTrigger10000[m_current_lb]++;
+ }
+ }
+ if (bec == BARREL) nlinksBAR++;
+ if (bec == ENDCAP_A)nlinksECp++;
+ if (bec == ENDCAP_C)nlinksECm++;
+ nlinks++;
+ }
+ if (nlinks >0){
+ m_occ_lb[m_current_lb] /= nlinks;
+ m_occTrigger_lb[m_current_lb] /= nlinks;
+ m_hitocc_lb[m_current_lb] /= nlinks;
+ m_hitoccTrigger_lb[m_current_lb] /= nlinks;
+ }
+ if (nlinksBAR >0){
+ m_occBAR_lb[m_current_lb] /= nlinksBAR;
+ m_occTriggerBAR_lb[m_current_lb] /= nlinksBAR;
+ m_hitoccBAR_lb[m_current_lb] /= nlinksBAR;
+ m_hitoccTriggerBAR_lb[m_current_lb] /= nlinksBAR;
+ }
+ if (nlinksECp >0){
+ m_occECp_lb[m_current_lb] /= nlinksECp;
+ m_occTriggerECp_lb[m_current_lb] /= nlinksECp;
+ m_hitoccECp_lb[m_current_lb] /= nlinksECp;
+ m_hitoccTriggerECp_lb[m_current_lb] /= nlinksECp;
+ }
+ if (nlinksECm >0){
+ m_occECm_lb[m_current_lb] /= nlinksECm;
+ m_occTriggerECm_lb[m_current_lb] /= nlinksECm;
+ m_hitoccECm_lb[m_current_lb] /= nlinksECm;
+ m_hitoccTriggerECm_lb[m_current_lb] /= nlinksECm;
+ }
}
m_BARNO_vsLB->Reset();
@@ -2266,92 +2257,92 @@ SCTHitsNoiseMonTool::checkNoiseMaps(bool final) {
m_NoisyModulesWithHOTrigger10000_vsLB->Reset();
//
for (int bin = 1; bin <= SCT_Monitoring::NBINS_LBs; bin++) {
- if (m_occBAR_lb[bin] != 0) {
- m_BARNO_vsLB->Fill(bin, m_occBAR_lb[bin]);
- }
- if (m_occECm_lb[bin] != 0) {
- m_ECmNO_vsLB->Fill(bin, m_occECm_lb[bin]);
- }
- if (m_occECp_lb[bin] != 0) {
- m_ECpNO_vsLB->Fill(bin, m_occECp_lb[bin]);
- }
- if (m_occ_lb[bin] != 0) {
- m_SCTNO_vsLB->Fill(bin, m_occ_lb[bin]);
- }
- if (m_noisyM100[bin] != 0) {
- m_NoisyModules100_vsLB->Fill(bin, m_noisyM100[bin]);
- }
- if (m_noisyM1000[bin] != 0) {
- m_NoisyModules1000_vsLB->Fill(bin, m_noisyM1000[bin]);
- }
- if (m_noisyM10000[bin] != 0) {
- m_NoisyModules10000_vsLB->Fill(bin, m_noisyM10000[bin]);
- }
- if (m_occTriggerBAR_lb[bin] != 0) {
- m_BARNOTrigger_vsLB->Fill(bin, m_occTriggerBAR_lb[bin]);
- }
- if (m_occTriggerECm_lb[bin] != 0) {
- m_ECmNOTrigger_vsLB->Fill(bin, m_occTriggerECm_lb[bin]);
- }
- if (m_occTriggerECp_lb[bin] != 0) {
- m_ECpNOTrigger_vsLB->Fill(bin, m_occTriggerECp_lb[bin]);
- }
- if (m_occTrigger_lb[bin] != 0) {
- m_SCTNOTrigger_vsLB->Fill(bin, m_occTrigger_lb[bin]);
- }
- if (m_noisyMTrigger100[bin] != 0) {
- m_NoisyModulesTrigger100_vsLB->Fill(bin, m_noisyMTrigger100[bin]);
- }
- if (m_noisyMTrigger1000[bin] != 0) {
- m_NoisyModulesTrigger1000_vsLB->Fill(bin, m_noisyMTrigger1000[bin]);
- }
- if (m_noisyMTrigger10000[bin] != 0) {
- m_NoisyModulesTrigger10000_vsLB->Fill(bin, m_noisyMTrigger10000[bin]);
- }
+ if (m_occBAR_lb[bin] != 0) {
+ m_BARNO_vsLB->Fill(bin, m_occBAR_lb[bin]);
+ }
+ if (m_occECm_lb[bin] != 0) {
+ m_ECmNO_vsLB->Fill(bin, m_occECm_lb[bin]);
+ }
+ if (m_occECp_lb[bin] != 0) {
+ m_ECpNO_vsLB->Fill(bin, m_occECp_lb[bin]);
+ }
+ if (m_occ_lb[bin] != 0) {
+ m_SCTNO_vsLB->Fill(bin, m_occ_lb[bin]);
+ }
+ if (m_noisyM100[bin] != 0) {
+ m_NoisyModules100_vsLB->Fill(bin, m_noisyM100[bin]);
+ }
+ if (m_noisyM1000[bin] != 0) {
+ m_NoisyModules1000_vsLB->Fill(bin, m_noisyM1000[bin]);
+ }
+ if (m_noisyM10000[bin] != 0) {
+ m_NoisyModules10000_vsLB->Fill(bin, m_noisyM10000[bin]);
+ }
+ if (m_occTriggerBAR_lb[bin] != 0) {
+ m_BARNOTrigger_vsLB->Fill(bin, m_occTriggerBAR_lb[bin]);
+ }
+ if (m_occTriggerECm_lb[bin] != 0) {
+ m_ECmNOTrigger_vsLB->Fill(bin, m_occTriggerECm_lb[bin]);
+ }
+ if (m_occTriggerECp_lb[bin] != 0) {
+ m_ECpNOTrigger_vsLB->Fill(bin, m_occTriggerECp_lb[bin]);
+ }
+ if (m_occTrigger_lb[bin] != 0) {
+ m_SCTNOTrigger_vsLB->Fill(bin, m_occTrigger_lb[bin]);
+ }
+ if (m_noisyMTrigger100[bin] != 0) {
+ m_NoisyModulesTrigger100_vsLB->Fill(bin, m_noisyMTrigger100[bin]);
+ }
+ if (m_noisyMTrigger1000[bin] != 0) {
+ m_NoisyModulesTrigger1000_vsLB->Fill(bin, m_noisyMTrigger1000[bin]);
+ }
+ if (m_noisyMTrigger10000[bin] != 0) {
+ m_NoisyModulesTrigger10000_vsLB->Fill(bin, m_noisyMTrigger10000[bin]);
+ }
}
for (int bin = 1; bin <= SCT_Monitoring::NBINS_LBs; bin++) {
- if (m_hitoccBAR_lb[bin] != 0) {
- m_BARHO_vsLB->Fill(bin, m_hitoccBAR_lb[bin]);
- }
- if (m_hitoccECm_lb[bin] != 0) {
- m_ECmHO_vsLB->Fill(bin, m_hitoccECm_lb[bin]);
- }
- if (m_hitoccECp_lb[bin] != 0) {
- m_ECpHO_vsLB->Fill(bin, m_hitoccECp_lb[bin]);
- }
- if (m_hitocc_lb[bin] != 0) {
- m_SCTHO_vsLB->Fill(bin, m_hitocc_lb[bin]);
- }
- if (m_noisyMWithHO100[bin] != 0) {
- m_NoisyModulesWithHO100_vsLB->Fill(bin, m_noisyMWithHO100[bin]);
- }
- if (m_noisyMWithHO1000[bin] != 0) {
- m_NoisyModulesWithHO1000_vsLB->Fill(bin, m_noisyMWithHO1000[bin]);
- }
- if (m_noisyMWithHO10000[bin] != 0) {
- m_NoisyModulesWithHO10000_vsLB->Fill(bin, m_noisyMWithHO10000[bin]);
- }
- if (m_hitoccTriggerBAR_lb[bin] != 0) {
- m_BARHOTrigger_vsLB->Fill(bin, m_hitoccTriggerBAR_lb[bin]);
- }
- if (m_hitoccTriggerECm_lb[bin] != 0) {
- m_ECmHOTrigger_vsLB->Fill(bin, m_hitoccTriggerECm_lb[bin]);
- }
- if (m_hitoccTriggerECp_lb[bin] != 0) {
- m_ECpHOTrigger_vsLB->Fill(bin, m_hitoccTriggerECp_lb[bin]);
- }
- if (m_hitoccTrigger_lb[bin] != 0) {
- m_SCTHOTrigger_vsLB->Fill(bin, m_hitoccTrigger_lb[bin]);
- }
- if (m_noisyMWithHOTrigger100[bin] != 0) {
- m_NoisyModulesWithHOTrigger100_vsLB->Fill(bin, m_noisyMWithHOTrigger100[bin]);
- }
- if (m_noisyMWithHOTrigger1000[bin] != 0) {
- m_NoisyModulesWithHOTrigger1000_vsLB->Fill(bin, m_noisyMWithHOTrigger1000[bin]);
- }
- if (m_noisyMWithHOTrigger10000[bin] != 0) {
- m_NoisyModulesWithHOTrigger10000_vsLB->Fill(bin, m_noisyMWithHOTrigger10000[bin]);
- }
+ if (m_hitoccBAR_lb[bin] != 0) {
+ m_BARHO_vsLB->Fill(bin, m_hitoccBAR_lb[bin]);
+ }
+ if (m_hitoccECm_lb[bin] != 0) {
+ m_ECmHO_vsLB->Fill(bin, m_hitoccECm_lb[bin]);
+ }
+ if (m_hitoccECp_lb[bin] != 0) {
+ m_ECpHO_vsLB->Fill(bin, m_hitoccECp_lb[bin]);
+ }
+ if (m_hitocc_lb[bin] != 0) {
+ m_SCTHO_vsLB->Fill(bin, m_hitocc_lb[bin]);
+ }
+ if (m_noisyMWithHO100[bin] != 0) {
+ m_NoisyModulesWithHO100_vsLB->Fill(bin, m_noisyMWithHO100[bin]);
+ }
+ if (m_noisyMWithHO1000[bin] != 0) {
+ m_NoisyModulesWithHO1000_vsLB->Fill(bin, m_noisyMWithHO1000[bin]);
+ }
+ if (m_noisyMWithHO10000[bin] != 0) {
+ m_NoisyModulesWithHO10000_vsLB->Fill(bin, m_noisyMWithHO10000[bin]);
+ }
+ if (m_hitoccTriggerBAR_lb[bin] != 0) {
+ m_BARHOTrigger_vsLB->Fill(bin, m_hitoccTriggerBAR_lb[bin]);
+ }
+ if (m_hitoccTriggerECm_lb[bin] != 0) {
+ m_ECmHOTrigger_vsLB->Fill(bin, m_hitoccTriggerECm_lb[bin]);
+ }
+ if (m_hitoccTriggerECp_lb[bin] != 0) {
+ m_ECpHOTrigger_vsLB->Fill(bin, m_hitoccTriggerECp_lb[bin]);
+ }
+ if (m_hitoccTrigger_lb[bin] != 0) {
+ m_SCTHOTrigger_vsLB->Fill(bin, m_hitoccTrigger_lb[bin]);
+ }
+ if (m_noisyMWithHOTrigger100[bin] != 0) {
+ m_NoisyModulesWithHOTrigger100_vsLB->Fill(bin, m_noisyMWithHOTrigger100[bin]);
+ }
+ if (m_noisyMWithHOTrigger1000[bin] != 0) {
+ m_NoisyModulesWithHOTrigger1000_vsLB->Fill(bin, m_noisyMWithHOTrigger1000[bin]);
+ }
+ if (m_noisyMWithHOTrigger10000[bin] != 0) {
+ m_NoisyModulesWithHOTrigger10000_vsLB->Fill(bin, m_noisyMWithHOTrigger10000[bin]);
+ }
}
}
}
@@ -2622,9 +2613,7 @@ SCTHitsNoiseMonTool::resetVecH1(VecH1_t hists) {
// ====================================================================================================
StatusCode
SCTHitsNoiseMonTool::bookNoiseDistributions() {
- // SCTHitsNoiseMonTool::bookNoiseDistributions(bool isNewRun){
- // if(isNewRun){
if (newRunFlag()) {
MonGroup NoiseDistributions(this, "SCT/GENERAL/noise", ManagedMonitorToolBase::run, ATTRIB_UNMANAGED);
const Int_t bins = 8000;
@@ -2967,7 +2956,7 @@ SCTHitsNoiseMonTool::bookSPvsEventNumber() {
m_nSP->GetYaxis()->SetTitle("Num of Spacepoints");
size_t nSP_buf_size;
nSP_buf_size = m_evtsbins * sizeof(int);
- m_nSP_buf = (int *) malloc(nSP_buf_size);
+ m_nSP_buf = (int*) malloc(nSP_buf_size);
m_nSP_pos = 0;
m_nHits = th1Factory("sct_av_hits_vs_en", "Number of Average Hits vs Event Number", BarrelSPHist, 1, m_evtsbins + 1,
@@ -2976,7 +2965,7 @@ SCTHitsNoiseMonTool::bookSPvsEventNumber() {
m_nHits->GetYaxis()->SetTitle("Num of Average Hits");
size_t nHits_buf_size;
nHits_buf_size = m_evtsbins * sizeof(int);
- m_nHits_buf = (int *) malloc(nHits_buf_size);
+ m_nHits_buf = (int*) malloc(nHits_buf_size);
m_nHits_pos = 0;
m_nmaxHits = th1Factory("sct_max_hits_vs_en", "Max Number of Hits vs Event Number", BarrelSPHist, 1, m_evtsbins + 1,
@@ -2985,10 +2974,10 @@ SCTHitsNoiseMonTool::bookSPvsEventNumber() {
m_nmaxHits->GetYaxis()->SetTitle("Num of Max Hits");
size_t nmaxHits_buf_size;
nmaxHits_buf_size = m_evtsbins * sizeof(int);
- m_nmaxHits_buf = (int *) malloc(nmaxHits_buf_size);
+ m_nmaxHits_buf = (int*) malloc(nmaxHits_buf_size);
size_t nmaxModule_buf_size;
nmaxModule_buf_size = m_evtsbins * sizeof(Identifier);
- m_nmaxModule_buf = (Identifier *) malloc(nmaxModule_buf_size);
+ m_nmaxModule_buf = (Identifier*) malloc(nmaxModule_buf_size);
m_nminHits = th1Factory("sct_min_hits_vs_en", "Min Number of Hits vs Event Number", BarrelSPHist, 1, m_evtsbins + 1,
m_evtsbins);
@@ -2996,10 +2985,10 @@ SCTHitsNoiseMonTool::bookSPvsEventNumber() {
m_nminHits->GetYaxis()->SetTitle("Num of Min Hits");
size_t nminHits_buf_size;
nminHits_buf_size = m_evtsbins * sizeof(int);
- m_nminHits_buf = (int *) malloc(nminHits_buf_size);
+ m_nminHits_buf = (int*) malloc(nminHits_buf_size);
size_t nminModule_buf_size;
nminModule_buf_size = m_evtsbins * sizeof(Identifier);
- m_nminModule_buf = (Identifier *) malloc(nminModule_buf_size);
+ m_nminModule_buf = (Identifier*) malloc(nminModule_buf_size);
}
return StatusCode::SUCCESS;
}
@@ -3022,7 +3011,7 @@ SCTHitsNoiseMonTool::makeSPvsEventNumber() {
SpacePointContainer::const_iterator it = SCT_spcontainer->begin();
SpacePointContainer::const_iterator endit = SCT_spcontainer->end();
for (; it != endit; ++it) {
- const SpacePointCollection *colNext = &(**it);
+ const SpacePointCollection* colNext = &(**it);
if (!colNext) {
continue;
}
@@ -3077,7 +3066,7 @@ SCTHitsNoiseMonTool::makeSPvsEventNumber() {
}
std::string
-SCTHitsNoiseMonTool::positionString(const Identifier &plane) const {
+SCTHitsNoiseMonTool::positionString(const Identifier& plane) const {
ostringstream position_txt;
position_txt << m_pSCTHelper->barrel_ec(plane) << "_" << m_pSCTHelper->layer_disk(plane) << "_" <<
@@ -3110,31 +3099,31 @@ SCTHitsNoiseMonTool::makeVectorOfTrackRDOIdentifiers() {
}
// assemble list of rdo ids associated with tracks
for (int i = 0; i < (int) tracks->size(); i++) {
- const Trk::Track *track = (*tracks)[i];
+ const Trk::Track* track = (*tracks)[i];
if (track == 0) {
ATH_MSG_WARNING("no pointer to track!!!");
break;
}
// Get pointer to track state on surfaces
- const DataVector<const Trk::TrackStateOnSurface> *trackStates = track->trackStateOnSurfaces();
+ const DataVector<const Trk::TrackStateOnSurface>* trackStates = track->trackStateOnSurfaces();
if (trackStates == 0) {
ATH_MSG_WARNING("for current track is TrackStateOnSurfaces == Null, no data will be written for this track");
}else {// Loop over all track states on surfaces
for (DataVector<const Trk::TrackStateOnSurface>::const_iterator it = trackStates->begin();
it != trackStates->end(); it++) {
// Get pointer to RIO of right type
- const InDet::SiClusterOnTrack *clus =
- dynamic_cast<const InDet::SiClusterOnTrack *>((*it)->measurementOnTrack());
+ const InDet::SiClusterOnTrack* clus =
+ dynamic_cast<const InDet::SiClusterOnTrack*>((*it)->measurementOnTrack());
if (clus) {
// Get Pointer to prepRawDataObject
- const InDet::SiCluster *RawDataClus = dynamic_cast<const InDet::SiCluster *>(clus->prepRawData());
+ const InDet::SiCluster* RawDataClus = dynamic_cast<const InDet::SiCluster*>(clus->prepRawData());
if (RawDataClus == 0) {
ATH_MSG_WARNING("SiCluster WITHOUT prepRawData!!!!");
break;
}
// if Cluster is in SCT ...
if (RawDataClus->detectorElement()->isSCT()) {
- const std::vector<Identifier> &rdoList = RawDataClus->rdoList();
+ const std::vector<Identifier>& rdoList = RawDataClus->rdoList();
m_RDOsOnTracks.insert(m_RDOsOnTracks.end(), rdoList.begin(), rdoList.end());
}
}
@@ -3160,10 +3149,10 @@ SCTHitsNoiseMonTool::bookGeneralTrackHits(const unsigned int systemIndex) {
const unsigned int limits[] = {
N_DISKSx2, N_BARRELSx2, N_DISKSx2
};
- VecH2_t *histoVec[] = {
+ VecH2_t* histoVec[] = {
&m_ptrackhitsHistoVectorECm, &m_ptrackhitsHistoVector, &m_ptrackhitsHistoVectorECp
};
- VecH2_t *histoVecRecent[] = {
+ VecH2_t* histoVecRecent[] = {
&m_ptrackhitsHistoVectorRecentECm, &m_ptrackhitsHistoVectorRecent, &m_ptrackhitsHistoVectorRecentECp
};
string stem = m_stream + "/" + paths[systemIndex] + "mapsOfHitsOnTracks";
@@ -3175,13 +3164,13 @@ SCTHitsNoiseMonTool::bookGeneralTrackHits(const unsigned int systemIndex) {
for (unsigned int i(0); i != limits[systemIndex]; ++i) {
LayerSideFormatter layerSide(i, systemIndex);
const string streamhitmap = "mapsOfHitsOnTracks" + abbreviations[systemIndex] + streamDelimiter +
- "trackhitsmap_" + layerSide.name();
+ "trackhitsmap_" + layerSide.name();
const string streamhitmaprecent = "mapsOfHitsOnTracksRecent" + abbreviations[systemIndex] + streamDelimiter +
- "trackhitsmap_" + layerSide.name();
+ "trackhitsmap_" + layerSide.name();
std::string histoName = stem + streamhitmap;
std::string histotitle = "SCT hits on tracks for " + names[systemIndex] + " " + layerSide.title();
std::string histotitlerecent = "SCT hits on tracks from recent events for " + names[systemIndex] + " " +
- layerSide.title();
+ layerSide.title();
h2Factory(streamhitmap, histotitle, bec, tracksMon, *(histoVec[systemIndex]));
if (m_environment == AthenaMonManager::online) {
h2Factory(streamhitmaprecent, histotitlerecent, bec, tracksMon, *(histoVecRecent[systemIndex]));
@@ -3200,15 +3189,15 @@ SCTHitsNoiseMonTool::bookGeneralTrackTimeHistos(const unsigned int systemIndex)
const unsigned int limits[N_REGIONS] = {
N_DISKS, N_BARRELS, N_DISKS
};
- std::vector<H1_t> *tbinHistoVectorArray[] = {
+ std::vector<H1_t>* tbinHistoVectorArray[] = {
&m_tbinHistoVectorECm, &m_tbinHistoVector, &m_tbinHistoVectorECp
};
- std::vector<H1_t> *tbinHistoVectorArrayRecent[] = {
+ std::vector<H1_t>* tbinHistoVectorArrayRecent[] = {
&m_tbinHistoVectorRecentECm, &m_tbinHistoVectorRecent, &m_tbinHistoVectorRecentECp
};
//
- std::vector<H1_t> &tbinHistoVector = *(tbinHistoVectorArray[systemIndex]);
- std::vector<H1_t> &tbinHistoVectorRecent = *(tbinHistoVectorArrayRecent[systemIndex]);
+ std::vector<H1_t>& tbinHistoVector = *(tbinHistoVectorArray[systemIndex]);
+ std::vector<H1_t>& tbinHistoVectorRecent = *(tbinHistoVectorArrayRecent[systemIndex]);
tbinHistoVector.clear();
tbinHistoVectorRecent.clear();
MonGroup timeGroup(this, path[systemIndex], run, ATTRIB_UNMANAGED);
@@ -3308,7 +3297,7 @@ SCTHitsNoiseMonTool::bookGeneralTrackTimeHistos(const unsigned int systemIndex)
const string streamlayer(std::to_string(i));
const string streamhitmap = "TrackTimeBin" + abbreviations[systemIndex] + streamDelimiter + streamlayer;
const string streamhitmaprecent = "TrackTimeBinRecent" + abbreviations[systemIndex] + streamDelimiter +
- streamlayer;
+ streamlayer;
histoName = stem + streamhitmap;
histoNameRecent = stem + streamhitmaprecent;
histoTitle = "RDO Track TimeBin: layer " + streamlayer;
@@ -3336,8 +3325,8 @@ SCTHitsNoiseMonTool::bookGeneralTrackTimeHistos(const unsigned int systemIndex)
}
SCTHitsNoiseMonTool::H2_t
-SCTHitsNoiseMonTool::h2Factory(const std::string &name, const std::string &title, const SCT_Monitoring::Bec bec,
- MonGroup ®istry, VecH2_t &storageVector) {
+SCTHitsNoiseMonTool::h2Factory(const std::string& name, const std::string& title, const SCT_Monitoring::Bec bec,
+ MonGroup& registry, VecH2_t& storageVector) {
int firstEta(FIRST_ETA_BIN), lastEta(LAST_ETA_BIN), firstPhi(FIRST_PHI_BIN), lastPhi(LAST_PHI_BIN), nEta(N_ETA_BINS),
nPhi(N_PHI_BINS);
@@ -3350,7 +3339,7 @@ SCTHitsNoiseMonTool::h2Factory(const std::string &name, const std::string &title
nPhi = N_PHI_BINS_EC;
}
H2_t tmp = TH2F_LW::create(TString(name), TString(
- title), nEta, firstEta - 0.5, lastEta + 0.5, nPhi, firstPhi - 0.5, lastPhi + 0.5);
+ title), nEta, firstEta - 0.5, lastEta + 0.5, nPhi, firstPhi - 0.5, lastPhi + 0.5);
tmp->SetXTitle("Index in the direction of #eta");
tmp->SetYTitle("Index in the direction of #phi");
bool success(registry.regHist(tmp).isSuccess());
@@ -3358,11 +3347,11 @@ SCTHitsNoiseMonTool::h2Factory(const std::string &name, const std::string &title
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
storageVector.push_back(tmp);
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTHitsNoiseMonTool::H2I_t
-SCTHitsNoiseMonTool::h2IFactory(const std::string &name, const std::string &title, MonGroup ®istry, int nbinx,
+SCTHitsNoiseMonTool::h2IFactory(const std::string& name, const std::string& title, MonGroup& registry, int nbinx,
float xlo, float xhi, int nbiny, float ylo, float yhi) {
H2I_t tmp = TH2I_LW::create(TString(name), TString(title), nbinx, xlo, xhi, nbiny, ylo, yhi);
@@ -3372,11 +3361,11 @@ SCTHitsNoiseMonTool::h2IFactory(const std::string &name, const std::string &titl
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTHitsNoiseMonTool::Prof2_t
-SCTHitsNoiseMonTool::prof2DFactory(const std::string &name, const std::string &title, MonGroup ®istry, int nbinx,
+SCTHitsNoiseMonTool::prof2DFactory(const std::string& name, const std::string& title, MonGroup& registry, int nbinx,
float xlo, float xhi, int nbiny, float ylo, float yhi) {
Prof2_t tmp = new TProfile2D(TString(name), TString(title), nbinx, xlo - 0.5, xhi + 0.5, nbiny, ylo - 0.5, yhi + 0.5);
@@ -3386,11 +3375,11 @@ SCTHitsNoiseMonTool::prof2DFactory(const std::string &name, const std::string &t
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTHitsNoiseMonTool::Prof_t
-SCTHitsNoiseMonTool::profFactory(const std::string &name, const std::string &title, MonGroup ®istry, int nbin,
+SCTHitsNoiseMonTool::profFactory(const std::string& name, const std::string& title, MonGroup& registry, int nbin,
float lo, float hi) {
Prof_t tmp = TProfile_LW::create(TString(name), TString(title), nbin, lo, hi);
@@ -3400,11 +3389,11 @@ SCTHitsNoiseMonTool::profFactory(const std::string &name, const std::string &tit
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTHitsNoiseMonTool::Prof_t
-SCTHitsNoiseMonTool::profFactory(const std::string &name, const std::string &title, MonGroup ®istry) {
+SCTHitsNoiseMonTool::profFactory(const std::string& name, const std::string& title, MonGroup& registry) {
Prof_t tmp = TProfile_LW::create(TString(name), TString(title), 3, 0, 3);
tmp->SetYTitle("Fraction of 01X");
@@ -3415,12 +3404,12 @@ SCTHitsNoiseMonTool::profFactory(const std::string &name, const std::string &tit
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTHitsNoiseMonTool::Prof2_t
-SCTHitsNoiseMonTool::prof2Factory(const std::string &name, const std::string &title, const SCT_Monitoring::Bec bec,
- MonGroup ®istry, VecProf2_t &storageVector) {
+SCTHitsNoiseMonTool::prof2Factory(const std::string& name, const std::string& title, const SCT_Monitoring::Bec bec,
+ MonGroup& registry, VecProf2_t& storageVector) {
int firstEta(FIRST_ETA_BIN), lastEta(LAST_ETA_BIN), firstPhi(FIRST_PHI_BIN), lastPhi(LAST_PHI_BIN), nEta(N_ETA_BINS),
nPhi(N_PHI_BINS);
@@ -3433,7 +3422,7 @@ SCTHitsNoiseMonTool::prof2Factory(const std::string &name, const std::string &ti
nPhi = N_PHI_BINS_EC;
}
Prof2_t tmp = new TProfile2D(TString(name), TString(
- title), nEta, firstEta - 0.5, lastEta + 0.5, nPhi, firstPhi - 0.5, lastPhi + 0.5);
+ title), nEta, firstEta - 0.5, lastEta + 0.5, nPhi, firstPhi - 0.5, lastPhi + 0.5);
tmp->SetXTitle("Index in the direction of #eta");
tmp->SetYTitle("Index in the direction of #phi");
bool success(registry.regHist(tmp).isSuccess());
@@ -3441,11 +3430,11 @@ SCTHitsNoiseMonTool::prof2Factory(const std::string &name, const std::string &ti
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
storageVector.push_back(tmp);
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTHitsNoiseMonTool::H1_t
-SCTHitsNoiseMonTool::h1Factory(const std::string &name, const std::string &title, MonGroup ®istry, const float lo,
+SCTHitsNoiseMonTool::h1Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo,
const float hi, const unsigned int nbins) {
H1_t tmp = TH1F_LW::create(TString(name), TString(title), nbins, lo, hi);
bool success(registry.regHist(tmp).isSuccess());
@@ -3453,12 +3442,12 @@ SCTHitsNoiseMonTool::h1Factory(const std::string &name, const std::string &title
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTHitsNoiseMonTool::H1_t
-SCTHitsNoiseMonTool::h1Factory(const std::string &name, const std::string &title, MonGroup ®istry,
- VecH1_t &storageVector, const float lo, const float hi, const unsigned int nbins) {
+SCTHitsNoiseMonTool::h1Factory(const std::string& name, const std::string& title, MonGroup& registry,
+ VecH1_t& storageVector, const float lo, const float hi, const unsigned int nbins) {
H1_t tmp = TH1F_LW::create(TString(name), TString(title), nbins, lo, hi);
bool success(registry.regHist(tmp).isSuccess());
@@ -3466,24 +3455,24 @@ SCTHitsNoiseMonTool::h1Factory(const std::string &name, const std::string &title
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
storageVector.push_back(tmp);
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
TH1F*
-SCTHitsNoiseMonTool::th1Factory(const std::string &name, const std::string &title, MonGroup ®istry, const float lo,
- const float hi, const unsigned int nbins) {
+SCTHitsNoiseMonTool::th1Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo,
+ const float hi, const unsigned int nbins) {
TH1F* tmp = new TH1F(TString(name), TString(title), nbins, lo, hi);
bool success(registry.regHist(tmp).isSuccess());
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
TH1F*
-SCTHitsNoiseMonTool::th1Factory(const std::string &name, const std::string &title, MonGroup ®istry,
- std::vector<TH1F*> &storageVector, const float lo, const float hi, const unsigned int nbins) {
+SCTHitsNoiseMonTool::th1Factory(const std::string& name, const std::string& title, MonGroup& registry,
+ std::vector<TH1F*>& storageVector, const float lo, const float hi, const unsigned int nbins) {
TH1F* tmp = new TH1F(TString(name), TString(title), nbins, lo, hi);
bool success(registry.regHist(tmp).isSuccess());
@@ -3491,5 +3480,5 @@ SCTHitsNoiseMonTool::th1Factory(const std::string &name, const std::string &titl
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
storageVector.push_back(tmp);
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTLorentzMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTLorentzMonTool.cxx
index cf4ccd067287e18fc9734eb3ebfef3e874b2b289..f01a5b140c3f598d2444e7fe83ef19ea1785052f 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTLorentzMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTLorentzMonTool.cxx
@@ -9,28 +9,29 @@
* Modified by Yuta
*/
#include "SCT_Monitoring/SCTLorentzMonTool.h"
+
#include "SCT_NameFormatter.h"
-#include <cmath>
-#include <type_traits>
-#include "GaudiKernel/StatusCode.h"
-#include "GaudiKernel/IToolSvc.h"
+#include "AthContainers/DataVector.h"
+#include "Identifier/Identifier.h"
+#include "InDetIdentifier/SCT_ID.h"
+#include "InDetPrepRawData/SiCluster.h"
+#include "InDetRIO_OnTrack/SiClusterOnTrack.h"
#include "StoreGate/ReadCondHandle.h"
#include "StoreGate/ReadHandle.h"
+#include "TrkParameters/TrackParameters.h"
+#include "TrkTrackSummary/TrackSummary.h" // for sct residuals
+
+#include "GaudiKernel/StatusCode.h"
+#include "GaudiKernel/IToolSvc.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TProfile2D.h"
#include "TF1.h"
-#include "AthContainers/DataVector.h"
-#include "Identifier/Identifier.h"
-#include "InDetIdentifier/SCT_ID.h"
-#include "InDetRIO_OnTrack/SiClusterOnTrack.h"
-#include "InDetPrepRawData/SiCluster.h"
-#include "TrkParameters/TrackParameters.h"
-// for sct residuals
-#include "TrkTrackSummary/TrackSummary.h"
+#include <cmath>
+#include <type_traits>
using namespace std;
using namespace Rec;
@@ -43,8 +44,8 @@ using namespace SCT_Monitoring;
* of the filepath for histograms etc
*/
// ====================================================================================================
-SCTLorentzMonTool::SCTLorentzMonTool(const string &type, const string &name,
- const IInterface *parent) : SCTMotherTrigMonTool(type, name, parent),
+SCTLorentzMonTool::SCTLorentzMonTool(const string& type, const string& name,
+ const IInterface* parent) : SCTMotherTrigMonTool(type, name, parent),
m_trackToVertexTool("Reco::TrackToVertex", this), // for TrackToVertexTool
m_phiVsNstrips{},
m_phiVsNstrips_100{},
@@ -164,20 +165,20 @@ SCTLorentzMonTool::fillHistograms() {
for (; trkitr != trkend; ++trkitr) {
// Get track
- const Trk::Track *track = (*trkitr);
+ const Trk::Track* track = (*trkitr);
if (not track) {
ATH_MSG_ERROR("no pointer to track!!!");
continue;
}
// Get pointer to track state on surfaces
- const DataVector<const Trk::TrackStateOnSurface> *trackStates = track->trackStateOnSurfaces();
+ const DataVector<const Trk::TrackStateOnSurface>* trackStates = track->trackStateOnSurfaces();
if (not trackStates) {
ATH_MSG_WARNING("for current track, TrackStateOnSurfaces == Null, no data will be written for this track");
continue;
}
- const Trk::TrackSummary *summary = track->trackSummary();
+ const Trk::TrackSummary* summary = track->trackSummary();
if (not summary) {
ATH_MSG_WARNING(" null trackSummary");
continue;
@@ -186,10 +187,10 @@ SCTLorentzMonTool::fillHistograms() {
DataVector<const Trk::TrackStateOnSurface>::const_iterator endit = trackStates->end();
for (DataVector<const Trk::TrackStateOnSurface>::const_iterator it = trackStates->begin(); it != endit; ++it) {
if ((*it)->type(Trk::TrackStateOnSurface::Measurement)) {
- const InDet::SiClusterOnTrack *clus =
- dynamic_cast<const InDet::SiClusterOnTrack *>((*it)->measurementOnTrack());
+ const InDet::SiClusterOnTrack* clus =
+ dynamic_cast<const InDet::SiClusterOnTrack*>((*it)->measurementOnTrack());
if (clus) { // Is it a SiCluster? If yes...
- const InDet::SiCluster *RawDataClus = dynamic_cast<const InDet::SiCluster *>(clus->prepRawData());
+ const InDet::SiCluster* RawDataClus = dynamic_cast<const InDet::SiCluster*>(clus->prepRawData());
if (not RawDataClus) {
continue; // Continue if dynamic_cast returns null
}
@@ -213,15 +214,15 @@ SCTLorentzMonTool::fillHistograms() {
}
}
// find cluster size
- const std::vector<Identifier> &rdoList = RawDataClus->rdoList();
+ const std::vector<Identifier>& rdoList = RawDataClus->rdoList();
int nStrip = rdoList.size();
- const Trk::TrackParameters *trkp = dynamic_cast<const Trk::TrackParameters *>((*it)->trackParameters());
+ const Trk::TrackParameters* trkp = dynamic_cast<const Trk::TrackParameters*>((*it)->trackParameters());
if (not trkp) {
ATH_MSG_WARNING(" Null pointer to MeasuredTrackParameters");
continue;
}
- const Trk::Perigee *perigee = track->perigeeParameters();
+ const Trk::Perigee* perigee = track->perigeeParameters();
if (perigee) {
// Get angle to wafer surface
@@ -274,8 +275,8 @@ SCTLorentzMonTool::fillHistograms() {
}// end if mtrkp
// delete perigee;perigee = 0;
} // end if SCT..
- } // end if(clus)
- } // if((*it)->type(Trk::TrackStateOnSurface::Measurement)){
+ } // end if (clus)
+ } // if ((*it)->type(Trk::TrackStateOnSurface::Measurement)){
}// end of loop on TrackStatesonSurface (they can be SiClusters, TRTHits,..)
} // end of loop on tracks
@@ -372,9 +373,9 @@ SCTLorentzMonTool::bookLorentzHistos() {
return StatusCode::SUCCESS;
}
-TProfile *
-SCTLorentzMonTool::pFactory(const std::string &name, const std::string &title, int nbinsx, float xlow, float xhigh,
- MonGroup ®istry, int &iflag) {
+TProfile*
+SCTLorentzMonTool::pFactory(const std::string& name, const std::string& title, int nbinsx, float xlow, float xhigh,
+ MonGroup& registry, int& iflag) {
Prof_t tmp = new TProfile(TString(name), TString(title), nbinsx, xlow, xhigh);
bool success(registry.regHist(tmp).isSuccess());
@@ -389,8 +390,8 @@ SCTLorentzMonTool::pFactory(const std::string &name, const std::string &title, i
}
bool
-SCTLorentzMonTool::h1Factory(const std::string &name, const std::string &title, const float extent, MonGroup ®istry,
- VecH1_t &storageVector) {
+SCTLorentzMonTool::h1Factory(const std::string& name, const std::string& title, const float extent, MonGroup& registry,
+ VecH1_t& storageVector) {
const unsigned int nbins(100);
const float lo(-extent), hi(extent);
H1_t tmp = new TH1F(TString(name), TString(title), nbins, lo, hi);
@@ -404,9 +405,9 @@ SCTLorentzMonTool::h1Factory(const std::string &name, const std::string &title,
}
int
-SCTLorentzMonTool::findAnglesToWaferSurface(const float (&vec)[3], const float &sinAlpha, const Identifier &id,
+SCTLorentzMonTool::findAnglesToWaferSurface(const float (&vec)[3], const float& sinAlpha, const Identifier& id,
const InDetDD::SiDetectorElementCollection* elements,
- float &theta, float &phi) {
+ float& theta, float& phi) {
int iflag(-1);
phi = 90.;
@@ -414,7 +415,7 @@ SCTLorentzMonTool::findAnglesToWaferSurface(const float (&vec)[3], const float &
const Identifier waferId = m_pSCTHelper->wafer_id(id);
const IdentifierHash waferHash = m_pSCTHelper->wafer_hash(waferId);
- const InDetDD::SiDetectorElement *element = elements->getDetectorElement(waferHash);
+ const InDetDD::SiDetectorElement* element = elements->getDetectorElement(waferHash);
if (!element) {
ATH_MSG_ERROR("findAnglesToWaferSurface: failed to find detector element for id=" <<
m_pSCTHelper->show_to_string(id));
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTMotherTrigMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTMotherTrigMonTool.cxx
index b935037b7828667be53b6f783bef387ac235f7a3..b882276e2f16630e38f25ce2b335c7a66dc9890b 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTMotherTrigMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTMotherTrigMonTool.cxx
@@ -10,16 +10,17 @@
// Local
#include "SCT_Monitoring/SCTMotherTrigMonTool.h"
// Framework
-#include "GaudiKernel/IInterface.h"
-#include "GaudiKernel/StatusCode.h"
#include "StoreGate/ReadHandle.h"
#include "TrigDecisionInterface/ITrigDecisionTool.h"
+#include "GaudiKernel/IInterface.h"
+#include "GaudiKernel/StatusCode.h"
+
const std::string SCTMotherTrigMonTool::m_triggerNames[] = {
"RNDM", "BPTX", "L1CAL", "TGC", "RPC", "MBTS", "COSM", "Calib"
};
-SCTMotherTrigMonTool::SCTMotherTrigMonTool(const std::string &type, const std::string &name, const IInterface *parent)
+SCTMotherTrigMonTool::SCTMotherTrigMonTool(const std::string& type, const std::string& name, const IInterface* parent)
: ManagedMonitorToolBase(type, name, parent),
m_doTrigger(true),
m_isStream(false),
@@ -65,14 +66,14 @@ SCTMotherTrigMonTool::hasTriggerFired(const unsigned int trigger) const {
}
bool
-SCTMotherTrigMonTool::isCalibrationNoise(const std::string &L1_Item) {
+SCTMotherTrigMonTool::isCalibrationNoise(const std::string& L1_Item) {
ATH_MSG_DEBUG("Trigger " << L1_Item << " = " << m_trigDecTool->isPassed(L1_Item));
return m_trigDecTool->isPassed(L1_Item);
}
bool
-SCTMotherTrigMonTool::isStream(const std::string &StreamName) {
+SCTMotherTrigMonTool::isStream(const std::string& StreamName) {
SG::ReadHandle<xAOD::EventInfo> evtInfo(m_eventInfoKey);
if (evtInfo.isValid()) {
m_isStream = false;
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTRatioNoiseMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTRatioNoiseMonTool.cxx
index 778dc20c4bc13cd22a811df912cdb5edc55835a6..3674db6db4c86000466816a4eb4ebd85b9007377 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTRatioNoiseMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTRatioNoiseMonTool.cxx
@@ -8,37 +8,34 @@
*
*/
#include "SCT_Monitoring/SCTRatioNoiseMonTool.h"
-#include "SCT_NameFormatter.h"
-#include <cmath>
-#include "GaudiKernel/IToolSvc.h"
+#include "SCT_NameFormatter.h"
-#include "TH1F.h"
-#include "TH2F.h"
-#include "TProfile2D.h"
-#include "TF1.h"
#include "AthContainers/DataVector.h"
+#include "AthenaKernel/errorcheck.h"
#include "Identifier/Identifier.h"
+#include "InDetConditionsSummaryService/InDetHierarchy.h"
#include "InDetIdentifier/SCT_ID.h"
#include "InDetRawData/SCT3_RawData.h"
-#include "AthenaKernel/errorcheck.h"
-#include "SCT_Monitoring/SCT_ClusterStruct.h"
+#include "InDetRawData/InDetRawDataContainer.h"
+#include "InDetRawData/InDetRawDataCLASS_DEF.h"
+#include "InDetIdentifier/SCT_ID.h"
+#include "LWHists/TH1F_LW.h"
+#include "LWHists/TH2F_LW.h"
+#include "StoreGate/ReadHandle.h"
+
#include "GaudiKernel/ITHistSvc.h"
+#include "GaudiKernel/IToolSvc.h"
-// conditions stuff
-#include "InDetConditionsSummaryService/InDetHierarchy.h"
-#include "TMath.h"
+#include "TF1.h"
#include "TH1F.h"
+#include "TH2F.h"
#include "TH2I.h"
-#include "LWHists/TH1F_LW.h"
-#include "LWHists/TH2F_LW.h"
+#include "TMath.h"
#include "TProfile2D.h"
-#include "InDetRawData/SCT3_RawData.h"
-#include "InDetRawData/InDetRawDataContainer.h"
-#include "InDetRawData/InDetRawDataCLASS_DEF.h"
-#include "Identifier/Identifier.h"
-#include "InDetIdentifier/SCT_ID.h"
-#include "StoreGate/ReadHandle.h"
+#include "TProfile2D.h"
+
+#include <cmath>
//
using namespace std;
@@ -90,8 +87,8 @@ namespace { // use anonymous namespace to restrict scope to this file, equivalen
* numbers to be used, and the timebin.
*/
// ====================================================================================================
-SCTRatioNoiseMonTool::SCTRatioNoiseMonTool(const string &type,
- const string &name,
+SCTRatioNoiseMonTool::SCTRatioNoiseMonTool(const string& type,
+ const string& name,
const IInterface *parent) :
SCTMotherTrigMonTool(type, name, parent),
m_eventID(0),
@@ -241,7 +238,7 @@ SCTRatioNoiseMonTool::SCTRatioNoiseMonTool(const string &type,
declareProperty("NOTrigger", m_NOTrigger = "L1_RD0_EMPTY");
declareProperty("IgnoreRDOCutOnline", m_ignore_RDO_cut_online);
- for (auto &i:m_goodModules) {
+ for (auto& i:m_goodModules) {
i = true;
}
}
@@ -373,11 +370,11 @@ SCTRatioNoiseMonTool::fillHistograms() {
if (isSelectedTrigger == true) {
for (; col_it != lastCol; ++col_it) {
m_correct_TimeBin = false;
- const InDetRawDataCollection<SCTRawDataType> *SCT_Collection(*col_it);
+ const InDetRawDataCollection<SCTRawDataType>* SCT_Collection(*col_it);
if (!SCT_Collection) {
continue; // select only SCT RDOs
}
- const InDetRawDataCollection<SCT_RDORawData> *rd(*col_it);
+ const InDetRawDataCollection<SCT_RDORawData>* rd(*col_it);
Identifier SCT_Identifier = SCT_Collection->identify();
int thisBec = m_pSCTHelper->barrel_ec(SCT_Identifier);
@@ -399,7 +396,7 @@ SCTRatioNoiseMonTool::fillHistograms() {
DataVector<SCTRawDataType>::const_iterator p_rdo_end = SCT_Collection->end();
for (DataVector<SCTRawDataType>::const_iterator p_rdo = SCT_Collection->begin(); p_rdo != p_rdo_end; ++p_rdo) {
count_SCT_RDO++;
- const SCT3_RawData *rdo3 = dynamic_cast<const SCT3_RawData *>(*p_rdo);
+ const SCT3_RawData* rdo3 = dynamic_cast<const SCT3_RawData *>(*p_rdo);
if (rdo3 != 0) {
m_tbin = (rdo3)->getTimeBin();
}
@@ -424,7 +421,7 @@ SCTRatioNoiseMonTool::fillHistograms() {
// ignores the RDO cut online since the empty events are pre-filtered there
if (count_SCT_RDO < 1E6 || (m_ignore_RDO_cut_online && m_environment == AthenaMonManager::online)) {
m_num_RDO->Fill(count_SCT_RDO);
- if(m_current_lb<=SCT_Monitoring::NBINS_LBs) m_noisyM[m_current_lb] = 0;
+ if (m_current_lb<=SCT_Monitoring::NBINS_LBs) m_noisyM[m_current_lb] = 0;
for (int j = 0; j < n_mod[GENERAL_INDEX]; j++) {
m_noSidesHit = false;
m_oneSideHit = false;
@@ -506,7 +503,7 @@ SCTRatioNoiseMonTool::fillHistograms() {
}
// --------------------------------------
if (calculateNoiseOccupancyUsingRatioMethod(m_nOneSide_lb[j], m_nNoSides_lb[j]) * 1E5 > 100.) {
- if(m_current_lb<=SCT_Monitoring::NBINS_LBs) m_noisyM[m_current_lb] += 1;
+ if (m_current_lb<=SCT_Monitoring::NBINS_LBs) m_noisyM[m_current_lb] += 1;
}
}
@@ -912,14 +909,14 @@ SCTRatioNoiseMonTool::bookRatioNoiseHistos() {
const unsigned int limits[] = {
N_DISKS, N_BARRELS, N_DISKS
};
- VecProf2_t *storageVectors[] = {
+ VecProf2_t* storageVectors[] = {
&m_pnoiseoccupancymapHistoVectorECC, &m_pnoiseoccupancymapHistoVectorBAR, &m_pnoiseoccupancymapHistoVectorECA
};
- VecProf2_t *storageVectorsSide0[] = {
+ VecProf2_t* storageVectorsSide0[] = {
&m_pnoiseoccupancymapHistoVectorECCSide0, &m_pnoiseoccupancymapHistoVectorBARSide0,
&m_pnoiseoccupancymapHistoVectorECASide0
};
- VecProf2_t *storageVectorsSide1[] = {
+ VecProf2_t* storageVectorsSide1[] = {
&m_pnoiseoccupancymapHistoVectorECCSide1, &m_pnoiseoccupancymapHistoVectorBARSide1,
&m_pnoiseoccupancymapHistoVectorECASide1
};
@@ -1081,7 +1078,7 @@ SCTRatioNoiseMonTool::bookRatioNoiseHistos() {
}
SCTRatioNoiseMonTool::Prof_t
-SCTRatioNoiseMonTool::pFactory(const std::string &name, const std::string &title, MonGroup ®istry, const float lo,
+SCTRatioNoiseMonTool::pFactory(const std::string& name, const std::string& title, MonGroup& registry, const float lo,
const float hi, const unsigned int nbins) {
Prof_t tmp = new TProfile(TString(name), TString(title), nbins, lo, hi);
bool success(registry.regHist(tmp).isSuccess());
@@ -1089,11 +1086,11 @@ SCTRatioNoiseMonTool::pFactory(const std::string &name, const std::string &title
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTRatioNoiseMonTool::H1_t
-SCTRatioNoiseMonTool::h1Factory(const std::string &name, const std::string &title, MonGroup ®istry, const float lo,
+SCTRatioNoiseMonTool::h1Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo,
const float hi, const unsigned int nbins) {
H1_t tmp = TH1F_LW::create(TString(name), TString(title), nbins, lo, hi);
bool success(registry.regHist(tmp).isSuccess());
@@ -1101,11 +1098,11 @@ SCTRatioNoiseMonTool::h1Factory(const std::string &name, const std::string &titl
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTRatioNoiseMonTool::H2_t
-SCTRatioNoiseMonTool::h2Factory(const std::string &name, const std::string &title, MonGroup ®istry, const float lo_x,
+SCTRatioNoiseMonTool::h2Factory(const std::string& name, const std::string& title, MonGroup& registry, const float lo_x,
const float hi_x, const unsigned int nbins_x, const float lo_y, const float hi_y,
const unsigned int nbins_y) {
H2_t tmp = TH2F_LW::create(TString(name), TString(title), nbins_x, lo_x, hi_x, nbins_y, lo_y, hi_y);
@@ -1114,12 +1111,12 @@ SCTRatioNoiseMonTool::h2Factory(const std::string &name, const std::string &titl
if (not success) {
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTRatioNoiseMonTool::H1_t
-SCTRatioNoiseMonTool::h1Factory(const std::string &name, const std::string &title, MonGroup ®istry,
- VecH1_t &storageVector, const float lo, const float hi, const unsigned int nbins) {
+SCTRatioNoiseMonTool::h1Factory(const std::string& name, const std::string& title, MonGroup& registry,
+ VecH1_t& storageVector, const float lo, const float hi, const unsigned int nbins) {
H1_t tmp = TH1F_LW::create(TString(name), TString(title), nbins, lo, hi);
bool success(registry.regHist(tmp).isSuccess());
@@ -1127,12 +1124,12 @@ SCTRatioNoiseMonTool::h1Factory(const std::string &name, const std::string &titl
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
storageVector.push_back(tmp);
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
SCTRatioNoiseMonTool::Prof2_t
-SCTRatioNoiseMonTool::prof2Factory(const std::string &name, const std::string &title, const unsigned int &bec,
- MonGroup ®istry, VecProf2_t &storageVector) {
+SCTRatioNoiseMonTool::prof2Factory(const std::string& name, const std::string& title, const unsigned int& bec,
+ MonGroup& registry, VecProf2_t& storageVector) {
int firstEta(FIRST_ETA_BIN), lastEta(LAST_ETA_BIN), firstPhi(FIRST_PHI_BIN), lastPhi(LAST_PHI_BIN), nEta(N_ETA_BINS),
nPhi(N_PHI_BINS);
@@ -1153,7 +1150,7 @@ SCTRatioNoiseMonTool::prof2Factory(const std::string &name, const std::string &t
ATH_MSG_WARNING("Cannot book SCT histogram: " << name);
}
storageVector.push_back(tmp);
- return success ? tmp : NULL;
+ return success ? tmp : nullptr;
}
float
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTSummaryMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTSummaryMonTool.cxx
index 00d41c61cb319113f2abb0bd4333d11c499f4937..50cb2358d17681a7c9e477b88aac5b286cc39973 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTSummaryMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTSummaryMonTool.cxx
@@ -19,8 +19,8 @@
* numbers to be used, and the timebin.
*/
// ====================================================================================================
-SCTSummaryMonTool::SCTSummaryMonTool(const std::string &type, const std::string &name,
- const IInterface *parent) : SCTMotherTrigMonTool(type, name, parent) {
+SCTSummaryMonTool::SCTSummaryMonTool(const std::string& type, const std::string& name,
+ const IInterface* parent) : SCTMotherTrigMonTool(type, name, parent) {
m_numberOfEvents = 0;
}
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTTracksMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTTracksMonTool.cxx
index 69914f5e1c3e0a1955e49dd4ca8eef351f4400d8..af5c55d06ec04e8bcbca46ca852d951a5c3af998 100644
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTTracksMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTTracksMonTool.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
/** @file SCTTracksMonTool.cxx
@@ -8,29 +8,29 @@
* Also uses code from InDet::SCT_ResidualPullCalculator
*/
#include "SCT_Monitoring/SCTTracksMonTool.h"
+
#include "SCT_NameFormatter.h"
-#include <cmath>
-#include "AthenaKernel/errorcheck.h"
-#include "GaudiKernel/StatusCode.h"
-#include "GaudiKernel/IToolSvc.h"
-#include "TH1F.h"
-#include "TH2F.h"
-#include "TProfile2D.h"
-#include "TF1.h"
#include "AthContainers/DataVector.h"
+#include "AthenaKernel/errorcheck.h"
#include "Identifier/Identifier.h"
#include "InDetIdentifier/SCT_ID.h"
-#include "InDetRIO_OnTrack/SiClusterOnTrack.h"
#include "InDetPrepRawData/SiCluster.h"
+#include "InDetRIO_OnTrack/SiClusterOnTrack.h"
+#include "StoreGate/ReadHandle.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkTrackSummary/TrackSummary.h"
-// for sct residuals
-// for GetKalmanUpdator
+#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/ListItem.h"
+#include "GaudiKernel/StatusCode.h"
-#include "StoreGate/ReadHandle.h"
+#include "TF1.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TProfile2D.h"
+
+#include <cmath>
using namespace std;
using namespace SCT_Monitoring;
@@ -65,9 +65,9 @@ namespace {
* numbers to be used, and the timebin.
*/
// ====================================================================================================
-SCTTracksMonTool::SCTTracksMonTool(const string &type,
- const string &name,
- const IInterface *parent)
+SCTTracksMonTool::SCTTracksMonTool(const string& type,
+ const string& name,
+ const IInterface* parent)
: SCTMotherTrigMonTool(type, name, parent),
m_nTracks(nullptr),
m_trackTrigger(nullptr),
@@ -288,14 +288,14 @@ SCTTracksMonTool::fillHistograms() {
ATH_MSG_DEBUG("Begin loop over " << tracks->size() << " tracks");
for (TrackCollection::const_iterator trkitr(tracks->begin()); trkitr != trkend; ++trkitr) {
int local_scthits = 0;
- const Trk::Track *track = (*trkitr);
+ const Trk::Track* track = (*trkitr);
if (not track) {
ATH_MSG_ERROR("No pointer to track");
break;
}
int scthits_on_trk(0); // Breaks out of loop if track has less than 3 sct hits
- const Trk::TrackSummary *trkSum(track->trackSummary());
- if (trkSum != NULL) {
+ const Trk::TrackSummary* trkSum(track->trackSummary());
+ if (trkSum) {
scthits_on_trk = trkSum->get(Trk::numberOfSCTHits);
} else {
ATH_MSG_WARNING("TrackSummary not found not using track!");
@@ -336,13 +336,13 @@ SCTTracksMonTool::fillHistograms() {
false, false, false
}; // Define bools to check whether the track has barrel, EA/C hits
// Get pointer to track state on surfaces
- const DataVector<const Trk::TrackStateOnSurface> *trackStates(track->trackStateOnSurfaces());
+ const DataVector<const Trk::TrackStateOnSurface>* trackStates(track->trackStateOnSurfaces());
if (not trackStates) {
ATH_MSG_ERROR("for current track, TrackStateOnSurfaces == Null, no data will be written for this track");
break;
}
- VecProf2_t *residualsHistogramArray[3];
- VecProf2_t *pullsHistogramArray[3];
+ VecProf2_t* residualsHistogramArray[3];
+ VecProf2_t* pullsHistogramArray[3];
Prof2_t residualsHistogram(0);
Prof2_t pullsHistogram(0);
if (m_environment != AthenaMonManager::online) {
@@ -354,11 +354,11 @@ SCTTracksMonTool::fillHistograms() {
pullsHistogramArray[2] = &m_psctpullsHistoVectorECp;
}
- VecH1_t *residualsSummaryHistogramArray[3] = {
+ VecH1_t* residualsSummaryHistogramArray[3] = {
&m_psctresiduals_summaryHistoVectorECm,
&m_psctresiduals_summaryHistoVector, &m_psctresiduals_summaryHistoVectorECp
};
- VecH1_t *pullsSummaryHistogramArray[3] = {
+ VecH1_t* pullsSummaryHistogramArray[3] = {
&m_psctpulls_summaryHistoVectorECm,
&m_psctpulls_summaryHistoVector, &m_psctpulls_summaryHistoVectorECp
};
@@ -367,9 +367,9 @@ SCTTracksMonTool::fillHistograms() {
DataVector<const Trk::TrackStateOnSurface>::const_iterator endit(trackStates->end());
for (DataVector<const Trk::TrackStateOnSurface>::const_iterator it(trackStates->begin()); it != endit; ++it) {
if ((*it)->type(Trk::TrackStateOnSurface::Measurement)) {
- const InDet::SiClusterOnTrack *clus(dynamic_cast<const InDet::SiClusterOnTrack *>((*it)->measurementOnTrack()));
+ const InDet::SiClusterOnTrack* clus(dynamic_cast<const InDet::SiClusterOnTrack*>((*it)->measurementOnTrack()));
if (clus) { // Is it a SiCluster? If yes...
- const InDet::SiCluster *RawDataClus(dynamic_cast<const InDet::SiCluster *>(clus->prepRawData()));
+ const InDet::SiCluster* RawDataClus(dynamic_cast<const InDet::SiCluster*>(clus->prepRawData()));
if (not RawDataClus) {
continue; // Continue if dynamic_cast returns null
}
@@ -379,19 +379,19 @@ SCTTracksMonTool::fillHistograms() {
const int phi(m_pSCTHelper->phi_module(sct_id));
const int bec(m_pSCTHelper->barrel_ec(sct_id));
const int layer(m_pSCTHelper->layer_disk(sct_id));
- const int element(2 * layer + m_pSCTHelper->side(sct_id));
+ const int element(2* layer + m_pSCTHelper->side(sct_id));
const int subsystemIndex(bec2Index(bec));
const bool doThisDetector(doThisSubsystem[subsystemIndex]);
hasHits[subsystemIndex] = true;
- const Trk::TrackParameters *trkParameters(0);
- const Trk::RIO_OnTrack *rio(dynamic_cast<const Trk::RIO_OnTrack *>((*it)->measurementOnTrack()));
+ const Trk::TrackParameters* trkParameters(0);
+ const Trk::RIO_OnTrack* rio(dynamic_cast<const Trk::RIO_OnTrack*>((*it)->measurementOnTrack()));
bool updateSucceeds(true);
if (rio) {
#ifndef NDEBUG
ATH_MSG_DEBUG("if rio");
#endif
if (m_doUnbiasedCalc) {
- const Trk::TrackParameters *trkParam((*it)->trackParameters());
+ const Trk::TrackParameters* trkParam((*it)->trackParameters());
if (trkParam) {
trkParameters = m_updator->removeFromState(*trkParam, rio->localParameters(), rio->localCovariance());
updateSucceeds = (trkParameters != 0);
@@ -410,7 +410,7 @@ SCTTracksMonTool::fillHistograms() {
ATH_MSG_DEBUG("Cluster Position Phi= " << clus->localParameters()[Trk::locX]);
#endif
if (!m_residualPullCalculator.empty()) {
- const Trk::ResidualPull *residualPull(m_residualPullCalculator->residualPull(rio, trkParameters,
+ const Trk::ResidualPull* residualPull(m_residualPullCalculator->residualPull(rio, trkParameters,
m_doUnbiasedCalc ? Trk::ResidualPull::Unbiased : Trk::ResidualPull::Biased));
if (!residualPull) {
ATH_MSG_WARNING("Residual Pull Calculator did not succeed!");
@@ -460,25 +460,25 @@ SCTTracksMonTool::fillHistograms() {
} else { // no measured local parameters, pull won't be calculated
ATH_MSG_WARNING("No measured local parameters, pull won't be calculated");
// sroe: trkParameters is null at this point, by definition, so the following code is dead
- // const Trk::AtaPlane * trackAtPlane(dynamic_cast<const Trk::AtaPlane*> (trkParameters));
+ // const Trk::AtaPlane* trackAtPlane(dynamic_cast<const Trk::AtaPlane*> (trkParameters));
/**
if (trackAtPlane) {
// const CLHEP::HepVector LocalTrackParameters(trackAtPlane->parameters());
const AmgVector(5) LocalTrackParameters(trackAtPlane->parameters());
- if(clus->localParameters().parameterKey() == ONE_D_LOCATION){
+ if (clus->localParameters().parameterKey() == ONE_D_LOCATION){
float local_residual(LocalTrackParameters[Trk::locX] -
clus->localParameters()[Trk::locX]);
if (doThisDetector){
residualsSummaryHistogram =
(*residualsSummaryHistogramArray[subsystemIndex])[element];
- if(m_environment != AthenaMonManager::online){
+ if (m_environment != AthenaMonManager::online){
residualsHistogram = (*residualsHistogramArray[subsystemIndex])[element];
if (residualsHistogram) residualsHistogram->Fill(eta, phi, local_residual);
}
if (residualsSummaryHistogram) residualsSummaryHistogram->Fill(local_residual,
1.);
- if(bec == 0) m_totalBarrelResidual->Fill(local_residual, 1.);
- else if(bec > 0) m_totalEndCapAResidual->Fill(local_residual, 1.);
+ if (bec == 0) m_totalBarrelResidual->Fill(local_residual, 1.);
+ else if (bec > 0) m_totalEndCapAResidual->Fill(local_residual, 1.);
else m_totalEndCapCResidual->Fill(local_residual, 1.);
}
} else {
@@ -493,7 +493,7 @@ SCTTracksMonTool::fillHistograms() {
+ (LocalTrackParameters[Trk::locY] - clus->localParameters()[Trk::locY]) * sinAlpha);
residualsSummaryHistogram = (bec == BARREL) ? 0 :
+(*residualsSummaryHistogramArray[subsystemIndex])[element];
- if(m_environment != AthenaMonManager::online){
+ if (m_environment != AthenaMonManager::online){
residualsHistogram = (bec == BARREL) ? 0 :
+(*residualsHistogramArray[subsystemIndex])[layer];//!!! this is 'layer' in
+the original code, others are elements
@@ -501,8 +501,8 @@ SCTTracksMonTool::fillHistograms() {
}
if (residualsSummaryHistogram) residualsSummaryHistogram->Fill(local_residual,
+1.);
- if(bec == 0) m_totalBarrelResidual->Fill(local_residual, 1.);
- else if(bec > 0) m_totalEndCapAResidual->Fill(local_residual, 1.);
+ if (bec == 0) m_totalBarrelResidual->Fill(local_residual, 1.);
+ else if (bec > 0) m_totalEndCapAResidual->Fill(local_residual, 1.);
else m_totalEndCapCResidual->Fill(local_residual, 1.);
}
}
@@ -518,8 +518,8 @@ SCTTracksMonTool::fillHistograms() {
}
}
} // end if SCT..
- } // end if(clus)
- } // if((*it)->type(Trk::TrackStateOnSurface::Measurement))
+ } // end if (clus)
+ } // if ((*it)->type(Trk::TrackStateOnSurface::Measurement))
}// end of loop on TrackStatesonSurface (they can be SiClusters, TRTHits,..)
m_trk_ncluHisto->Fill(local_scthits, 1.);
// We now know whether this particular track had hits in the barrel or endcaps- update the profile histogram
@@ -616,16 +616,16 @@ SCTTracksMonTool::checkHists(bool /*fromFinalize*/) {
if (m_environment != AthenaMonManager::online) {
- const VecProf2_t *residuals[3] = {
+ const VecProf2_t* residuals[3] = {
&m_psctresidualsHistoVectorECm, &m_psctresidualsHistoVector, &m_psctresidualsHistoVectorECp
};
- const VecProf2_t *pulls[3] = {
+ const VecProf2_t* pulls[3] = {
&m_psctpullsHistoVectorECm, &m_psctpullsHistoVector, &m_psctpullsHistoVectorECp
};
- const VecH2_t *pullsRms[3] = {
+ const VecH2_t* pullsRms[3] = {
&m_psctpullsRMSHistoVectorECm, &m_psctpullsRMSHistoVector, &m_psctpullsRMSHistoVectorECp
};
- const VecH2_t *residualsRms[3] = {
+ const VecH2_t* residualsRms[3] = {
&m_psctresidualsRMSHistoVectorECm, &m_psctresidualsRMSHistoVector, &m_psctresidualsRMSHistoVectorECp
};
@@ -687,7 +687,7 @@ SCTTracksMonTool::checkHists(bool /*fromFinalize*/) {
//====================================================================================================
StatusCode SCTTracksMonTool::GetKalmanUpdator(){
// use kalman updator to get unbiased states
- IAlgTool * algTool;
+ IAlgTool* algTool;
ListItem ltool("Trk::KalmanUpdator/TrkKalmanUpdator");
CHECK(toolSvc()->retrieveTool(ltool.type(), ltool.name(), algTool));
m_updator = dynamic_cast<Trk::IUpdator*>(algTool);
@@ -705,7 +705,7 @@ float
SCTTracksMonTool::calculatePull(const float residual, const float trkErr, const float hitErr) {
float ErrorSum(pow(trkErr * trkErr + hitErr * hitErr, 0.5));
- if (ErrorSum > 1.0e-20) { // if(ErrorSum != 0) //as floats are rarely exactly zero
+ if (ErrorSum > 1.0e-20) { // as floats are rarely exactly zero
return residual / ErrorSum;
} else {
ATH_MSG_DEBUG("Error on Track and Cluster are 0. Returning Pull value 0.");
@@ -818,7 +818,7 @@ SCTTracksMonTool::bookGeneralHistos() {
m_nTracks->GetYaxis()->SetTitle("Num of Tracks");
size_t nTracks_buf_size;
nTracks_buf_size = m_evtsbins * sizeof(int);
- m_nTracks_buf = (int *) malloc(nTracks_buf_size);
+ m_nTracks_buf = (int*) malloc(nTracks_buf_size);
m_nTracks_pos = 0;
CHECK(Tracks.regHist(m_nTracks));
}
@@ -853,10 +853,10 @@ SCTTracksMonTool::bookTrackHistos(const SCT_Monitoring::Bec becVal) {
};
const unsigned int systemIndex(bec2Index(becVal));
- VecH1_t *residualsSummaryArray[] = {
+ VecH1_t* residualsSummaryArray[] = {
&m_psctresiduals_summaryHistoVectorECm, &m_psctresiduals_summaryHistoVector, &m_psctresiduals_summaryHistoVectorECp
};
- VecH1_t *pullsSummaryArray[] = {
+ VecH1_t* pullsSummaryArray[] = {
&m_psctpulls_summaryHistoVectorECm, &m_psctpulls_summaryHistoVector, &m_psctpulls_summaryHistoVectorECp
};
@@ -867,7 +867,8 @@ SCTTracksMonTool::bookTrackHistos(const SCT_Monitoring::Bec becVal) {
const string localPathResi(localPathsResi[systemIndex]);
const string localPathPull(localPathsPull[systemIndex]);
const unsigned int limit(limits[systemIndex]);
- VecH1_t *p_residualsSummary(residualsSummaryArray[systemIndex]), *p_pullsSummary(pullsSummaryArray[systemIndex]);
+ VecH1_t* p_residualsSummary(residualsSummaryArray[systemIndex]);
+ VecH1_t* p_pullsSummary(pullsSummaryArray[systemIndex]);
MonGroup endCapTracks(this, m_path + localPath, run, ATTRIB_UNMANAGED);
MonGroup endCapTracksResi(this, m_path + localPathResi, run, ATTRIB_UNMANAGED);
@@ -890,24 +891,24 @@ SCTTracksMonTool::bookTrackHistos(const SCT_Monitoring::Bec becVal) {
if (m_environment != AthenaMonManager::online) {
- VecProf2_t *residualsArray[] = {
+ VecProf2_t* residualsArray[] = {
&m_psctresidualsHistoVectorECm, &m_psctresidualsHistoVector, &m_psctresidualsHistoVectorECp
};
- VecH2_t *residualsRmsArray[] = {
+ VecH2_t* residualsRmsArray[] = {
&m_psctresidualsRMSHistoVectorECm, &m_psctresidualsRMSHistoVector, &m_psctresidualsRMSHistoVectorECp
};
- VecProf2_t *pullsArray[] = {
+ VecProf2_t* pullsArray[] = {
&m_psctpullsHistoVectorECm, &m_psctpullsHistoVector, &m_psctpullsHistoVectorECp
};
- VecH2_t *pullsRmsArray[] = {
+ VecH2_t* pullsRmsArray[] = {
&m_psctpullsRMSHistoVectorECm, &m_psctpullsRMSHistoVector, &m_psctpullsRMSHistoVectorECp
};
- VecProf2_t *p_residuals(residualsArray[systemIndex]);
- VecProf2_t *p_pulls(pullsArray[systemIndex]);
- VecH2_t *p_residualsRms(residualsRmsArray[systemIndex]);
- VecH2_t *p_pullsRms(pullsRmsArray[systemIndex]);
+ VecProf2_t* p_residuals(residualsArray[systemIndex]);
+ VecProf2_t* p_pulls(pullsArray[systemIndex]);
+ VecH2_t* p_residualsRms(residualsRmsArray[systemIndex]);
+ VecH2_t* p_pullsRms(pullsRmsArray[systemIndex]);
p_residuals->clear();
p_pulls->clear();
@@ -943,8 +944,8 @@ SCTTracksMonTool::bookTrackHistos(const SCT_Monitoring::Bec becVal) {
}
StatusCode
-SCTTracksMonTool::h2Factory(const std::string &name, const std::string &title,
- const SCT_Monitoring::Bec bec, MonGroup ®istry, VecH2_t &storageVector) {
+SCTTracksMonTool::h2Factory(const std::string& name, const std::string& title,
+ const SCT_Monitoring::Bec bec, MonGroup& registry, VecH2_t& storageVector) {
int firstEta(FIRST_ETA_BIN), lastEta(LAST_ETA_BIN), firstPhi(FIRST_PHI_BIN), lastPhi(LAST_PHI_BIN), nEta(N_ETA_BINS),
nPhi(N_PHI_BINS);
@@ -964,8 +965,8 @@ SCTTracksMonTool::h2Factory(const std::string &name, const std::string &title,
}
StatusCode
-SCTTracksMonTool::p2Factory(const std::string &name, const std::string &title,
- const SCT_Monitoring::Bec bec, MonGroup ®istry, VecProf2_t &storageVector) {
+SCTTracksMonTool::p2Factory(const std::string& name, const std::string& title,
+ const SCT_Monitoring::Bec bec, MonGroup& registry, VecProf2_t& storageVector) {
int firstEta(FIRST_ETA_BIN), lastEta(LAST_ETA_BIN), firstPhi(FIRST_PHI_BIN), lastPhi(LAST_PHI_BIN), nEta(N_ETA_BINS),
nPhi(N_PHI_BINS);
@@ -985,8 +986,8 @@ SCTTracksMonTool::p2Factory(const std::string &name, const std::string &title,
}
StatusCode
-SCTTracksMonTool::h1Factory(const std::string &name, const std::string &title, const float extent, MonGroup ®istry,
- VecH1_t &storageVector) {
+SCTTracksMonTool::h1Factory(const std::string& name, const std::string& title, const float extent, MonGroup& registry,
+ VecH1_t& storageVector) {
const unsigned int nbins(100);
const float lo(-extent), hi(extent);
H1_t tmp = new TH1F(TString(name), TString(title), nbins, lo, hi);