Calorimeter/CaloMonitoring/CMakeLists.txt

@@ -10,6 +10,7 @@ atlas_depends_on_subdirs( PUBLIC
                           Calorimeter/CaloEvent
                           Calorimeter/CaloIdentifier
                           Calorimeter/CaloInterface
+                          Calorimeter/CaloGeoHelpers
                           Commission/CommissionEvent
                           Control/AthenaMonitoring
                           Control/StoreGate
@@ -27,7 +28,6 @@ atlas_depends_on_subdirs( PUBLIC
 			  Trigger/TrigAnalysis/TrigAnalysisInterfaces
                           PRIVATE
                           Calorimeter/CaloDetDescr
-                          Calorimeter/CaloGeoHelpers
                           Control/AthenaKernel
                           Event/xAOD/xAODEventInfo
                           LArCalorimeter/LArRecEvent
@@ -48,3 +48,4 @@ atlas_add_component( CaloMonitoring
 atlas_install_headers( CaloMonitoring )
 atlas_install_joboptions( share/*.py )
 
+#SET( CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -Og " ) 

Calorimeter/CaloMonitoring/CaloMonitoring/CaloBaselineMon.h

@@ -70,6 +70,7 @@ class CaloBaselineMon : public CaloMonToolBase {
    bool m_bool_bcidtoolMon;
 
    // Services
+   //const CaloIdManager* m_caloIdMgr;
    const CaloCell_ID*   m_calo_id;
 
    // Tools
@@ -86,9 +87,12 @@ class CaloBaselineMon : public CaloMonToolBase {
      TProfile_LW* hProf_bcidtoolMon_vs_Eta=nullptr;
      TProfile_LW* hProf_bcidtoolMon_vs_LB=nullptr;
      std::vector<TProfile_LW*> hProf_bcidtoolMon_vs_EtaBCID;
+     //     TProfile2D_LW* hProf2d_bcidtoolMon_vs_EtaBCID=nullptr;
+
      TProfile_LW* hProf_pedestalMon_vs_Eta=nullptr;
      TProfile_LW* hProf_pedestalMon_vs_LB=nullptr;
      std::vector<TProfile_LW*> hProf_pedestalMon_vs_EtaBCID;
+     //TProfile2D_LW* hProf2d_pedestalMon_vs_EtaBCID=nullptr;
    };
 
    // List of partitions given in job options;

Calorimeter/CaloMonitoring/CaloMonitoring/CaloLayer.h → Calorimeter/CaloMonitoring/CaloMonitoring/LArCellBinning.h

-/*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
 // ***********************************************************
 //                                                            
-// CaloLayer - class to hold granularity info   
-// for layers of the Calorimeter. To be used with             
+// CaloCellbinning - class to hold granularity info   
+// for cellbinnings of the Calorimeter. To be used with             
 // CaloCellVecMon class                                       
 //                                                            
 // ***********************************************************                                                                                                                                                   
 
-#ifndef CALO_LAYER_H
-#define CALO_LAYER_H
+#ifndef LAR_CELLBINNING_H
+#define LAR_CELLBINNING_H
+
+#include <vector>
 
 namespace CaloMonitoring {
 
-  class CaloLayer {
+  class LArCellBinning {
   
   public:
-
-    enum Partition { EMB, HEC, EMEC, FCAL, MAXPART };
-
-    enum Side { A, C };  
-
-    CaloLayer(const char* name,Partition partition, int layerNumber, Side side);
-    ~CaloLayer();
-
-    // inline functions
-    const char* getName()        { return m_name;        };
-    int         getNTotEtaBins() { return m_nTotEtaBins; };
-    int         getNTotPhiBins() { return m_nTotPhiBins; };
-    double*     getEtaBinArray() { return m_etaBinArray; };
-    double*     getPhiBinArray() { return m_phiBinArray; };
-    int         getLayerNumber() { return m_layerNumber; };
-    Partition   getPartition()   { return m_partition;   };
-    Side        getSide()        { return m_side;        };
-
-    void        setProperties(Partition partition, int layerNumber, Side side);
+    LArCellBinning() {};
+    ~LArCellBinning();
+
+    //Getters
+    int         getNTotEtaBins() const { return  m_etaBinArray.size()-1; };
+    int         getNTotPhiBins() const { return m_phiBinArray.size()-1; };
+    const double*     getEtaBinArray() const { return m_etaBinArray.data(); };
+    const double*     getPhiBinArray() const { return m_phiBinArray.data(); };
   
     // Binning - creates variable sized bin arrays
-    void        doEtaBinning(const int nEtaRegions, double* etaBreakPts, int* nEtaBins);
-    void        doPhiBinning(const int nPhiRegions, double* phiBreakPts, int* nPhiBins);
+    void        doEtaBinning(const int nEtaRegions, const double* etaBreakPts, const int* nEtaBins);
+    void        doPhiBinning(const int nPhiRegions, const double* phiBreakPts, const int* nPhiBins);
 
     // Binning for phi for the common case with only one granularity region
     void        doPhiBinning(int nPhiBins);
 
-    // Takes an existing "side A" CaloLayer and creates phi and eta bin arrays
-    // for side C
-    void        doSideCBinning(CaloLayer * lyr);
+    
+    LArCellBinning etaMirror() const;
 
   private:
-    const char* m_name;
-
-    int         m_nTotEtaBins;
-    double*     m_etaBinArray;
-    int         m_nTotPhiBins;
-    double*     m_phiBinArray;
-
-    int         m_layerNumber;
-    Partition   m_partition;
-    Side        m_side;
+    std::vector<double> m_etaBinArray;
+    std::vector<double> m_phiBinArray;
   };
 }
 
-#endif // CALO_LAYER_H
+#endif // LAr_CELLBINNING_H

Calorimeter/CaloMonitoring/CaloMonitoring/LArCellMonTool.h

+//Dear emacs, this is -*-c++-*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+//W.Lampl  - Spring 2017: Major re-design
+
+#ifndef CALOMONITORING_LARCELLMONTOOL_H
+#define CALOMONITORING_LARCELLMONTOOL_H
+
+#include "CaloMonitoring/CaloMonToolBase.h"
+#include "GaudiKernel/ToolHandle.h"
+
+#include "LArRecConditions/ILArBadChanTool.h"
+#include "LArRecConditions/ILArBadChannelMasker.h"
+#include "CaloInterface/ICalorimeterNoiseTool.h"
+
+#include "LArCabling/LArCablingService.h"
+#include "LArIdentifier/LArOnlineID.h"
+#include "Identifier/IdentifierHash.h"
+
+#include "TrigDecisionTool/TrigDecisionTool.h"
+
+#include "CaloMonitoring/LArCellBinning.h"
+          
+#include <vector>
+#include <string>
+#include <bitset>
+#include <array>
+#include <map>
+#include <unordered_map>
+ 
+namespace Trig {
+  class ChainGroup;
+}
+
+class CaloCell;
+class TileID;
+class CaloCell_ID;
+
+class TH1F;
+class TH1D;
+class TH2F;
+class TProfile;
+
+
+class LArCellMonTool : public CaloMonToolBase {
+ 
+ public:
+
+  LArCellMonTool(const std::string & type, const std::string& name, 
+		 const IInterface* parent);
+  ~LArCellMonTool();
+  
+  //Methods implementing the ManagedMonitorToolBase interface
+  virtual StatusCode initialize();
+  virtual StatusCode finalize();
+  virtual StatusCode bookHistograms();
+  virtual StatusCode procHistograms();
+  virtual StatusCode fillHistograms();
+
+private:
+
+  //enums to help with the conversion of Layer, partitions and such:
+
+  //Enumerate layers 
+  enum LayerEnum{EMBPA=0, EMBPC, EMB1A, EMB1C, EMB2A, EMB2C, EMB3A, EMB3C,
+		 HEC0A, HEC0C, HEC1A, HEC1C, HEC2A, HEC2C, HEC3A, HEC3C,
+		 EMECPA,EMECPC,EMEC1A,EMEC1C,EMEC2A,EMEC2C,EMEC3A,EMEC3C,
+		 FCAL1A,FCAL1C,FCAL2A,FCAL2C,FCAL3A,FCAL3C,MAXLAYER};
+
+  //Enumerate layer-types, ignoring sides. Useful for configuration that is per-definition symmetric 
+  enum LayerEnumNoSides{EMBPNS=0, EMB1NS, EMB2NS, EMB3NS, HEC0NS, HEC1NS, HEC2NS, HEC3NS,
+			EMECPNS,EMEC1NS,EMEC2NS,EMEC3NS,FCAL1NS,FCAL2NS,FCAL3NS,MAXLYRNS};
+
+  //Enumerate partitions
+  enum PartitionEnum{EMBA,EMBC,EMECA,EMECC,HECA,HECC,FCALA,FCALC,MAXPARTITIONS};
+
+
+  //Mapping of layer-enum to their string-names (for histogram titles, etc)
+  const std::array<std::string,MAXLAYER> m_layerNames={{"EMBPA", "EMBPC", "EMB1A", "EMB1C", "EMB2A", "EMB2C", "EMB3A", "EMB3C",
+							"HEC0A", "HEC0C", "HEC1A", "HEC1C", "HEC2A", "HEC2C", "HEC3A", "HEC3C",
+							"EMECPA", "EMECPC", "EMEC1A", "EMEC1C", "EMEC2A", "EMEC2C", "EMEC3A", "EMEC3C", 
+							"FCAL1A", "FCAL1C", "FCAL2A", "FCAL2C", "FCAL3A", "FCAL3C"}};
+
+  //Mapping of layer-no-side enum to their string-names (for histogram titles, etc)
+  const std::array<std::string,MAXLYRNS> m_lyrNSNames={{"EMBPS","EMB1" ,"EMB2" ,"EMB3" ,"HEC0" ,"HEC1" ,"HEC2","HEC3",
+							"EMECP","EMEC1","EMEC2","EMEC3","FCAL1","FCAL2","FCAL3"}};
+  //Mapping of partition-enum to their string-name
+  const std::array<std::string,MAXPARTITIONS> m_partitionNames{{"EMBA","EMBC","EMECA","EMECC","HECA","HECC","FCALA","FCALC"}};  
+
+  //Mapping of CaloCell nomencature to CaloCellMonitoring nomencature
+  const std::map<unsigned,LayerEnumNoSides> m_caloSamplingToLyrNS{ 
+    {CaloSampling::PreSamplerB, EMBPNS},{CaloSampling::EMB1,EMB1NS},{CaloSampling::EMB2,EMB2NS},{CaloSampling::EMB3,EMB3NS},         //LAr Barrel
+    {CaloSampling::PreSamplerE, EMECPNS},{CaloSampling::EME1,EMEC1NS}, {CaloSampling::EME2,EMEC2NS}, {CaloSampling::EME3,EMEC3NS},   //LAr Endcap     
+    {CaloSampling::HEC0,HEC0NS}, {CaloSampling::HEC1,HEC1NS}, {CaloSampling::HEC2,HEC2NS}, {CaloSampling::HEC3,HEC3NS},              //Hadronic endcap
+    {CaloSampling::FCAL0,FCAL1NS}, {CaloSampling::FCAL1,FCAL2NS}, {CaloSampling::FCAL2,FCAL3NS}                                      //FCAL
+  };
+
+  //Mapping of layers to the partition the layer belongs to
+  const std::array<PartitionEnum,MAXLAYER> m_layerEnumtoPartitionEnum{{
+    //EMBPA EMBPC, EMB1A, EMB1C, EMB2A, EMB2C, EMB3A, EMB3C,
+      EMBA, EMBC,  EMBA,  EMBC,  EMBA,  EMBC,  EMBA,  EMBC,
+   //HEC0A, HEC0C, HEC1A, HEC1C, HEC2A, HEC2C, HEC3A, HEC3C,
+      HECA, HECC,  HECA,  HECC,  HECA,  HECC,  HECA,   HECC,
+  //EMECPA,  EMECPC,EMEC1A,EMEC1C,EMEC2A,EMEC2C,EMEC3A,EMEC3C,
+      EMECA, EMECC, EMECA, EMECC, EMECA, EMECC, EMECA, EMECC,
+   //FCAL1A,FCAL1C,FCAL2A,FCAL2C, FCAL3A,FCAL3C,MAXLAYER
+      FCALA, FCALC, FCALA, FCALC, FCALA, FCALC
+	}};
+  
+  //Enumerations of possible threshold directions and trigger types:
+  enum Direction{OVER,UNDER,NONE,BOTH}; 
+  enum TriggerType{RNDM,CALO,MINBIAS,MET,MISC,NOTA,MAXTRIGTYPE};
+
+
+  //Histogram path in root file:
+  const std::string m_lArPath{"/CaloMonitoring/LArCellMon_NoTrigSel/"};
+
+  // Thresholds for time and Time vs Energy plots:
+  // Energy thresholds hardcoded following official timing analysis. See for example:
+  // https://indico.cern.ch/event/522351/
+  const std::array<float ,MAXLYRNS> m_eCutForTiming {
+  //{EMBPNS=0, EMB1NS, EMB2NS, EMB3NS, HEC0NS, HEC1NS, HEC2NS, HEC3NS,EMECPNS,EMEC1NS,EMEC2NS,EMEC3NS,FCAL1NS,FCAL2NS,FCAL3NS
+    {1000.,    1000.,  3000.,  1500.,  3500.,  3500.,  3500.,  3500., 1500.,  3000.,  3000.,  2000.,  10000., 10000., 10000.}
+  };
+
+
+  //Private methods: Initialization and job-option interpretation
+  StatusCode initThreshHists();
+  void setLArCellBinning();
+  void resetInternals();
+
+  //Private methods: Histogramm booking
+  StatusCode bookLarMultThreHists(); 
+  StatusCode bookSporHists();
+  StatusCode bookLarNonThreHists();
+  TH2F* newEtaPhiHist(const std::string& hName, const std::string& hTitle, const CaloMonitoring::LArCellBinning& binning) const;
+  std::string strToLower(const std::string& input) const;
+  void regTempHist(TH1* h, MonGroup& mg);
+
+  //Private methods: Histogram filling
+  StatusCode createPerJobHistograms(const CaloCellContainer* cellcont);
+  void checkTriggerAndBeamBackground();
+  void sporadicNoiseCandidate(const CaloCell* cell, const LArCellMonTool::LayerEnum iLyr,const float threshold);
+
+  //Helpers for histogram filling
+  void getHistoCoordinates(const CaloDetDescrElement* dde, float& celleta, float& cellphi, unsigned& iLyr, unsigned& iLyrNS) const; 
+  void divideByOccupancy(TH2F* fraction, const TH2F* total, const TH2* occupancy) ;
+
+
+  //Job Properties and other private variables
+  bool m_oncePerJobHistosDone=false;
+  std::string m_cellContainerName;
+
+  bool m_useElectronicNoiseOnly;
+  ICalorimeterNoiseTool::CalorimeterNoiseType m_noiseType=ICalorimeterNoiseTool::TOTALNOISE;
+  ToolHandle<ICalorimeterNoiseTool> m_noiseTool;
+
+
+  // Trigger Awareness:
+  bool m_useTrigger;
+  ToolHandle<Trig::TrigDecisionTool> m_trigDec; //!< TDT handle
+  std::array<std::string,NOTA> m_triggerNames;
+  //std::string m_rndmTriggerNames;
+  //std::string m_caloTriggerNames;
+  //std::string m_minBiasTriggerNames;
+  //std::string m_metTriggerNames;
+  //std::string m_miscTriggerNames;
+ 
+  std::array<const Trig::ChainGroup*, NOTA> m_chainGroups{{}};
+ 
+  // bad channel mask  
+  ToolHandle<ILArBadChannelMasker> m_badChannelMask;
+  ToolHandle<ILArBadChanTool> m_badChannelTool;
+  bool m_maskKnownBadChannels;
+  bool m_maskNoCondChannels;
+
+  bool m_doSaveTempHists;
+  bool m_doKnownBadChannelsVsEtaPhi;
+  bool m_doDatabaseNoiseVsEtaPhi;
+  bool m_doEnergyVsTime;
+  bool m_doUnnormalized1DEnergy;
+  bool m_useLogarithmicEnergyBinning;
+  bool m_useWeightedEffMerging;
+    
+ //threshold for sporadic plots
+  bool m_sporadic_switch;
+  float m_threshold_em_S0S1;
+  float m_threshold_HECFCALEMS2S3;
+  unsigned m_sporadicPlotLimit;
+  unsigned m_sporadic_protc;
+  unsigned m_minSporadicNoiseEventsPerCell;
+
+ // Variables to configure LAr threshold plots:
+ // Used to pass variable sized array through JO
+  StringArrayProperty  m_thresholdNameProp;
+  StringArrayProperty  m_thresholdDirectionProp;
+  StringArrayProperty  m_triggersToIncludeProp;
+  StringArrayProperty  m_triggersToExcludeProp;
+  StringArrayProperty  m_thresholdTitleTemplates;
+  FloatArrayProperty   m_defaultThresholds;
+  BooleanArrayProperty m_inSigNoise;
+  BooleanArrayProperty m_doPercentageOccupancyProp;
+  BooleanArrayProperty m_doEtaPhiOccupancyProp;
+  BooleanArrayProperty m_doEtaOccupancyProp;
+  BooleanArrayProperty m_doPhiOccupancyProp;
+  BooleanArrayProperty m_doEtaPhiTotalEnergyProp;
+  BooleanArrayProperty m_doEtaPhiAverageEnergyProp;
+  BooleanArrayProperty m_doEtaPhiAverageQualityProp;
+  BooleanArrayProperty m_doEtaPhiFractionOverQthProp;
+  FloatArrayProperty   m_qualityFactorThresholdProp;
+  BooleanArrayProperty m_doEtaPhiAverageTimeProp;
+  BooleanArrayProperty m_doEtaPhiFractionPastTthProp;
+  FloatArrayProperty   m_timeThresholdProp;
+  BooleanArrayProperty m_doBeamBackgroundRemovalProp; 
+
+  StringArrayProperty  m_thresholdColumnType;
+  FloatArrayProperty   m_thresholdsProp[MAXLYRNS];
+
+  //The threshold-related variables and histograms are grouped in the following struct
+  //one instance per threshold-type
+  struct thresholdHist_t {
+    //Configuration variables
+    std::string m_threshName;                        /// Name of this threshold
+    std::string m_threshTitleTemplate;               /// Histogram title template
+    std::array<float,MAXLYRNS> m_threshValue{{}};    /// The actual threshold (per layer)
+    std::array<std::string,MAXLYRNS> m_threshTitles; /// Part of the histogram title (containing the threshold value, so per-layer)
+    bool m_inSigNoise=false;                         /// Absolute threshold or in sigma noise?
+    Direction m_threshDirection=OVER;
+    bool m_doBeamBackgroundRemoval=false; 
+    float m_qualityFactorThreshold=4000;
+    float m_timeThreshold=4.;
+
+    //Variables related to trigger-filtering
+    std::bitset<MAXTRIGTYPE> m_triggersToInclude;
+    std::bitset<MAXTRIGTYPE> m_triggersToExclude;
+    bool m_threshTriggerDecision=true;
+
+    //Switch histograms on/off
+    bool m_doPercentageOccupancy=false;
+    bool m_doEtaPhiOccupancy=false;
+    bool m_doEtaOccupancy=false;
+    bool m_doPhiOccupancy=false;
+
+    bool m_doEtaPhiTotalEnergy=false;
+    bool m_doEtaPhiAverageEnergy=false;
+
+    bool m_doEtaPhiAverageQuality=false;
+    bool m_doEtaPhiFractionOverQth=false;
+    
+    bool m_doEtaPhiAverageTime=false;
+    bool m_doEtaPhiFractionPastTth=false;
+
+    //Histogram pointers, per layer
+    std::array<TH2F*,MAXLAYER> m_h_occupancy_etaphi{{}};  //Filled from  m_occupancyCounter
+    std::array<TH1F*,MAXLAYER> m_h_occupancy_eta{{}};     //Filled from  m_occupancyCounter
+    std::array<TH1F*,MAXLAYER> m_h_occupancy_phi{{}};     //Filled from  m_occupancyCounter
+    
+    std::array<TH2F*,MAXLAYER> m_h_totalEnergy_etaphi{{}}; //Filled directly
+    std::array<TH2F*,MAXLAYER> m_h_averageEnergy_etaphi{{}}; //derived
+    
+    std::array<TH2F*,MAXLAYER> m_h_poorQualityOccupancy_etaphi{{}}; //Filled directly
+    std::array<TH2F*,MAXLAYER> m_h_totalQuality_etaphi{{}}; //Filled directly
+    std::array<TH2F*,MAXLAYER> m_h_fractionOverQth_etaphi{{}}; //derived
+    std::array<TH2F*,MAXLAYER> m_h_averageQuality_etaphi{{}};//derived
+
+    std::array<TH2F*,MAXLAYER> m_h_poorTimeOccupancy_etaphi{{}}; //Filled directly
+    std::array<TH2F*,MAXLAYER> m_h_totalTime_etaphi{{}}; //Filled directly
+    std::array<TH2F*,MAXLAYER> m_h_fractionPastTth_etaphi{{}}; //derived
+    std::array<TH2F*,MAXLAYER> m_h_averageTime_etaphi{{}}; //derived
+
+    //Occupancy-counter
+    std::array<unsigned,185000> m_occupancyCounter{}; //Hardwired max not ideal but more efficient
+
+    //Counter (for normalization)
+    unsigned m_eventsPassed=0;
+  };
+
+  std::vector<thresholdHist_t> m_thresholdHists;
+
+  StatusCode fillOccupancyHist(LArCellMonTool::thresholdHist_t& thr);
+ 
+  // Identifer helpers and such
+  ToolHandle<LArCablingService> m_LArCablingService;
+
+  const LArOnlineID* m_LArOnlineIDHelper;
+  const CaloCell_ID* m_calo_id;
+  
+  std::array<CaloMonitoring::LArCellBinning,MAXLAYER> m_binning;
+
+  //Sporadic monitoring related variables and structs
+  std::string m_sporadicDir;
+  unsigned m_counter_sporadic_protc=0;
+
+  struct SporadicNoiseCell_t{
+    TH1F* m_h_energy=nullptr;
+    TH1F* m_h_quality=nullptr;
+    TProfile* m_h_energyVsLB=nullptr;
+    unsigned m_counter=0; 
+    //Note wrt AthenaMP: Counting noisy event is obviously flawed, even for 
+    //serial processing as events are scattered over many files
+  };
+
+  struct idHasher {
+    std::size_t operator()(const Identifier& id) const {
+      return std::hash<Identifier::value_type>{}(id.get_compact());
+    }
+  };
+
+  std::unordered_map<Identifier,SporadicNoiseCell_t,idHasher> m_sporadicNoiseCells;
+  
+  void bookNoisyCellHistos(SporadicNoiseCell_t& result, const CaloDetDescrElement* dde, const PartitionEnum part, const float threshold);
+
+  std::array<TH1F*,MAXPARTITIONS> m_h_sporadicHists;
+  std::array<unsigned,MAXPARTITIONS> m_sporadicPerPartCounter{};
+
+
+  // summary plot
+  TH1F* m_h_n_trigEvent=nullptr;
+
+  // energy and time distribution for cell neither badcell nor noconditions 
+  std::array<TH1F*,MAXLAYER> m_h_energy{{}};  // define when m_doUnnormalized1DEnergy==1
+  std::array<TH2F*,MAXLAYER> m_h_energyVsTime{{}};
+  std::array<TH1F*,MAXLAYER> m_h_cellTime{{}};
+  std::array<TH1F*,MAXLAYER> m_h_energyVsTime_DifferThresholds{{}};
+
+
+  // Reference Type Histograms (Filled solely with database information)
+  std::array<TH2F*,MAXLAYER> m_h_badChannels_etaphi{{}};
+  std::array<TH2F*,MAXLAYER> m_h_dbnoise_etaphi{{}};
+
+  // temporary plots used for m_percentOccupancy_eta(phi) 
+  std::array<TH1F*,MAXLAYER>  m_h_nActiveCellsFirstEvent_eta{{}}; 
+  std::array<TH1F*,MAXLAYER>  m_h_nActiveCellsFirstEvent_phi{{}};
+
+};
+
+#endif 
+
+//Histograms dropped during the redesign in spring 2017:
+// * All inverse-masking
+// * Cell Occupancy Eta/Phi Vs LumiBlock
+// * DBNoiseNormalizedEnergy per layer 
+// * doEtaPhiEnergyRMS per layer and threshold
+// * DoEtaPhiRMSvsDBnoise per layer and threshold
+

Calorimeter/CaloMonitoring/CaloMonitoring/TileCalCellMonTool.h

+//Dear emacs, this is -*-c++-*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TILEMONTOOL_H
+#define TILEMONTOOL_H
+
+#include "CaloMonitoring/CaloMonToolBase.h"
+#include "GaudiKernel/ToolHandle.h"
+
+
+#include "AthenaMonitoring/IDQFilterTool.h"
+#include "TrigDecisionTool/TrigDecisionTool.h"
+#include "CaloInterface/ICalorimeterNoiseTool.h"
+
+class CaloCell;
+class TileID;
+
+class TH1F;
+class TH1D;
+class TH2F;
+class TProfile2D;
+class TProfile;
+
+
+class TileCalCellMonTool : public CaloMonToolBase {
+ 
+ public:
+
+  TileCalCellMonTool(const std::string & type, const std::string& name, 
+		 const IInterface* parent);
+  ~TileCalCellMonTool();
+  
+  virtual StatusCode initialize();
+  virtual StatusCode bookHistograms();
+  virtual StatusCode procHistograms();
+  virtual StatusCode fillHistograms();
+
+
+private:
+  const std::string m_tilePath{"/CaloMonitoring/TileCellMon_NoTrigSel/General"};
+
+  //Private methods:
+  void initParam();
+  void getRMSdevNoise(TProfile *t1, TProfile *t2, TH1F *t3);
+
+  //Job Properties and other private variables
+  std::string m_cellContainerName;
+
+  bool m_useElectronicNoiseOnly;
+  bool m_useTwoGaus;
+  ICalorimeterNoiseTool::CalorimeterNoiseType m_noiseType=ICalorimeterNoiseTool::TOTALNOISE;
+  ToolHandle<ICalorimeterNoiseTool> m_noiseTool;
+
+  // tile energy threshold
+  float m_tileThreshold;
+
+  const TileID* m_tile_id;
+  const CaloCell_ID* m_calo_id;
+  
+ //   Tile histograms parameters 
+  std::vector<double> m_b_Ncells;
+
+  std::vector<double> m_b_CellsE;
+
+  std::vector<double> m_b_CellsEta;
+  std::vector<double> m_b_CellsEtaTile;
+
+  std::vector<double> m_b_CellsPhi;
+
+  std::vector<double> m_b_CellsTower;
+  std::vector<double> m_b_CellsModule;
+
+  std::vector<double> m_b_CellsEtaPhi;
+
+  // Tile histograms
+  TH1F* m_h_CellsNoiseE=nullptr;  // E/DBnoise distribution for all not bad tile cells in sample <3
+
+  // for tile cells with energy > m_tileThreshold 
+  TH1F* m_h_Ncells=nullptr;
+  TH1F* m_h_CellsE=nullptr;  
+  TH2F* m_h_CellsEtaPhi=nullptr;
+  TProfile*  m_h_CellsEta=nullptr;
+  TProfile*  m_h_CellsPhi=nullptr;
+  TProfile* m_h_CellsModuleS1=nullptr;
+  TProfile* m_h_CellsModuleS2=nullptr;
+  TProfile* m_h_CellsModuleS3=nullptr;
+  TProfile* m_h_CellsModuleS4=nullptr;
+  TProfile* m_h_CellsTower=nullptr;
+
+  // for not bad tile cells with |E/DBnoise| >4.0 in sample<3
+  TH2F* m_h_CellsNoiseEtaPhi=nullptr;
+  TH2F* m_h_CellsNoiseEtaPhiA=nullptr;
+  TH2F* m_h_CellsNoiseEtaPhiBC=nullptr;
+  TH2F* m_h_CellsNoiseEtaPhiD=nullptr;
+  TH1F* m_h_CellsNoiseHash=nullptr;
+
+  // for all not bad tile cells in sample <3; h_CellsRMSdivDBnoiseEta(Phi) are derived  from temporary plots h_CellsNoiseEta(phi) and h_CellsRMSEta(Phi) 
+  TProfile*  m_h_CellsNoiseEta=nullptr;
+  TProfile*  m_h_CellsNoisePhi=nullptr;
+  TProfile*  m_h_CellsRMSPhi=nullptr;
+  TProfile*  m_h_CellsRMSEta=nullptr;
+  TH1F * m_h_CellsRMSdivDBnoiseEta=nullptr;
+  TH1F * m_h_CellsRMSdivDBnoisePhi=nullptr;
+
+
+};
+
+#endif 
+

Calorimeter/CaloMonitoring/share/CaloBaselineMon_jobOpt.py

@@ -14,6 +14,8 @@ if not 'rec' in dir():
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
 include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
 
+from TrigBunchCrossingTool.BunchCrossingTool import BunchCrossingTool
+
 tmp_CaloBaselineMon = {"useBadLBTool":FALSE,
                        "useReadyFilterTool":FALSE,
                        "useLArNoisyAlg":FALSE,
@@ -37,9 +39,10 @@ if rec.triggerStream()=='ZeroBias':
 
 CaloBaseline = CaloBaselineMon(
    name           = "CaloBaseline",
-
+   
    useBadLBTool=tmp_CaloBaselineMon["useBadLBTool"],
    BadLBTool = GetLArBadLBFilterTool(),
+   BunchCrossingTool=BunchCrossingTool(),
    useReadyFilterTool = tmp_CaloBaselineMon["useReadyFilterTool"],
    ReadyFilterTool = monAtlasReadyFilterTool,
    useLArCollisionFilterTool = tmp_CaloBaselineMon["useLArCollisionFilter"],

Calorimeter/CaloMonitoring/share/CaloCellVecMonCollisions_jobOpt.py

@@ -5,11 +5,9 @@
 # LArCellVecMon_jobOpt.py   Francesco Spano  07/15/07
 # LArCellVecMon_jobOpt.py   R. Kehoe         07/03/06
 
-from CaloMonitoring.CaloMonitoringConf import CaloCellVecMon
-from CaloRec.CaloTopoClusterFlags import jobproperties
+from CaloMonitoring.CaloMonitoringConf import LArCellMonTool
 
-if not 'rec' in dir():
-   from RecExConfig.RecFlags import rec
+from RecExConfig.RecFlags import rec
 
 from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
@@ -19,14 +17,14 @@ include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
 
 from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
 theCaloNoiseTool=CaloNoiseToolDefault()
-ToolSvc+=theCaloNoiseTool
 
 from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
 theLArChanMasker=LArBadChannelMasker("LArChanMasker")
 theLArChanMasker.DoMasking=True
 theLArChanMasker.ProblemsToMask=[
-     "deadReadout","deadPhys","short",
+     "deadReadout","deadPhys","almostDead","short",
      "sporadicBurstNoise",
+     "unstableNoiseLG","unstableNoiseMG","unstableNoiseHG",
      "highNoiseHG","highNoiseMG","highNoiseLG"
 ]
 ToolSvc+=theLArChanMasker
@@ -35,119 +33,63 @@ from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
 theLArBadChannelTool=LArBadChanTool()
 ToolSvc+=theLArBadChannelTool
 
-if (DQMonFlags.monManEnvironment == 'online'):
-  tmp_isOnline=TRUE
-else:
-  tmp_isOnline=FALSE
-
-if (DQMonFlags.monManEnvironment == 'online' or globalflags.DataSource.get_Value() == 'geant4' or globalflags.DataSource.get_Value() == 'geant3'):
-  tmp_useBadLBTool=FALSE
-else:
-  tmp_useBadLBTool=TRUE
 
-if DQMonFlags.monManEnvironment() == 'online':
-  tmp_useReadyFilterTool=FALSE
-else:
-  tmp_useReadyFilterTool=TRUE
 
-if (rec.triggerStream()=='CosmicCalo'):
-  tmp_useLArCollisionTime = TRUE
-else:
-  tmp_useLArCollisionTime = FALSE
-
-if DQMonFlags.monManEnvironment() == 'online':
-   tmp_useLArNoisyAlg = FALSE
-else:
-   tmp_useLArNoisyAlg = TRUE
-
-tmp_useElectronicNoiseOnly = FALSE
-tmp_useTwoGaus = TRUE
-
-if DQMonFlags.monManEnvironment() == 'online':
-   tmp_useBeamBackgroundRemoval = FALSE
+# All 2D plot occupancy are activate only for express and cosmiccalo
+if (rec.triggerStream()=='CosmicCalo' or rec.triggerStream()=='express') or (DQMonFlags.monManEnvironment() == 'online'):
+   do2DOcc = True
 else:
-   tmp_useBeamBackgroundRemoval = TRUE
-
-if not (rec.triggerStream()=='CosmicCalo'):
-  tmp_useBeamBackgroundRemoval = FALSE 
-  print "not CosmicCalo stream" 
-
-print "tmp_useBeamBackgroundRemoval=", tmp_useBeamBackgroundRemoval
-
+   do2DOcc = False
 
-tmp_useTrigger = TRUE 
-if 'DQMonFlags' in dir():
-   if not DQMonFlags.useTrigger:
-      tmp_useTrigger = FALSE
+LArCellMon = LArCellMonTool(
 
-tmp_sporadicSwitch = FALSE
-if (rec.triggerStream()=='CosmicCalo') and not (DQMonFlags.monManEnvironment() == 'online'):
-   tmp_sporadicSwitch = TRUE
+    #DoSaveTempHists=True,
+    #OutputLevel=DEBUG,
 
-tmp_oc2D = FALSE # All 2D plot occupancy are activate only for express and cosmiccalo
-if (rec.triggerStream()=='CosmicCalo' or rec.triggerStream()=='express') or (DQMonFlags.monManEnvironment() == 'online'):
-   tmp_oc2D = TRUE
-
-
-CaloCellMon = CaloCellVecMon(
-    name = "CaloCellMon",
+    name = "LArCellMon",
     CaloCellContainer = "AllCalo",
 
-    TimeGran = "run",
-    ProcessNEvents = 100,  #determines eventsblock time granularity, defined in ManagedMonitorToolBase.
-
-    isOnline=tmp_isOnline,
-    useBadLBTool=tmp_useBadLBTool,
     BadLBTool = GetLArBadLBFilterTool(),
 
-    useReadyFilterTool = tmp_useReadyFilterTool,
     ReadyFilterTool = monAtlasReadyFilterTool,
 
-   useLArCollisionFilterTool = tmp_useLArCollisionTime,
-
-    useLArNoisyAlg = tmp_useLArNoisyAlg,
-    useElectronicNoiseOnly = tmp_useElectronicNoiseOnly,
-    useTwoGaus = tmp_useTwoGaus,
+    useElectronicNoiseOnly = False,
+    #useTwoGaus = True, Tile-only
 
     CaloNoiseTool=theCaloNoiseTool,
-    useBeamBackgroundRemoval = tmp_useBeamBackgroundRemoval,
 
-    useTrigger          = tmp_useTrigger,
+    useTrigger          =  DQMonFlags.useTrigger(),
     rndmTriggerNames    = "L1_RD0, L1_RD0_FILLED, L1_RD0_EMPTY, L1_RD1, L1_RD1_NOISE, L1_RD1_HIST, L1_RD1_BGRP4, L1_RD1_BGRP5",
     caloTriggerNames    = "L1_EM[0-9]+, L1_HA[0-9]+, L1_J[0-9]+.*, L1_JB[0-9]+, L1_JF[0-9]+, L1_TE[0-9]+, L1_JE[0-9]+, L1_XE[0-9]+, L1_2EM[0-9]+, L1_2FJ[0-9]+, L1_2J[0-9]+,L1_3J[0-9]+.*,L1_4J[0-9]+.*,L1_5J[0-9]+,L1_6J[0-9]+,L1_FJ[0-9]+.*",
     minBiasTriggerNames = "L1_RD0_FILLED, L1_MBTS_1, L1_MBTS_2, L1_MBTS_1_1",
     metTriggerNames     = "EF_xe[0-9]+.*",
     miscTriggerNames    = "",
-
     LArBadChannelMask=theLArChanMasker,
     LArBadChannelTool=theLArBadChannelTool,
-    MaskBadChannels    = FALSE,
-    MaskNoCondChannels = FALSE,
-    doInverseMasking   = FALSE,
-    doMaskingOnline    = FALSE,
-    problemsToMaskOffline =["deadReadout","deadPhys","almostDead","short","sporadicBurstNoise","unstableNoiseLG",
-                            "unstableNoiseMG","unstableNoiseHG","highNoiseHG","highNoiseMG","highNoiseLG"],
+    MaskBadChannels    = False,
+    MaskNoCondChannels = False,
+    #doInverseMasking   = False,
+ #   doMaskingOnline    = False,
+    #problemsToMaskOffline =["deadReadout","deadPhys","almostDead","short","sporadicBurstNoise","unstableNoiseLG",
+    #                        "unstableNoiseMG","unstableNoiseHG","highNoiseHG","highNoiseMG","highNoiseLG"],
 
     # Database Record Plots (filled in first event)
-    doDatabaseNoiseVsEtaPhi     = TRUE,
-    doKnownBadChannelsVsEtaPhi  = TRUE,
-    doDBNoiseNormalized1DEnergy = FALSE,
-    doUnnormalized1DEnergy      = TRUE,
-    useLogarithmicEnergyBinning = TRUE,
+    doDatabaseNoiseVsEtaPhi     = True,
+    doKnownBadChannelsVsEtaPhi  = True,
+    doUnnormalized1DEnergy      = True,
+    useLogarithmicEnergyBinning = True,
 
     # Use WeightedEff rather than Weighted Average Merging, where appropriate:
     #  (if merging / errors are all correct, this should have no effect, hence this is a good validation tool)
-    useWeightedEffMerging = TRUE,
+    useWeightedEffMerging = True,
 
-    Sporadic_switch = tmp_sporadicSwitch,
     Threshold_EM_S0S1= 5000,
     Threshold_HECFCALEMS2S3= 15000,
-    EventNumber_thres = 10,
     NsporadicPlotLimit = 300,
     Sporadic_protection = 4000,
 
-    DoEtaLumi = FALSE,
-    DoPhiLumi = FALSE, 
+    #DoEtaLumi = False,
+    #DoPhiLumi = False, 
     
 # EtaPhi Cell Plots:
     
@@ -163,35 +105,33 @@ CaloCellMon = CaloCellVecMon(
 
 # Global Settings:
 
-    ThresholdType          = ["default", "noEth", "noEth_rndm", "medEth", "5Sigma", "hiEth", "hiEth_noVeto", "met"  ],
-    ThresholdDirection     = ["over"   , "none" , "none"      , "both"  , "both"  , "over" , "over"        , "over" ],
-    TriggersToInclude      = ["all"    , "all"  , "all"       , "all"   , "all"   , "all"  , "all"         , "met"  ],
-    TriggersToExclude      = ["none"   , "none" , "none"      ],
+    ThresholdType          = [ "noEth", "noEth_rndm", "medEth", "5Sigma", "hiEth", "hiEth_noVeto", "met"  ],
+    ThresholdDirection     = [ "none" , "none"      , "both"  , "both"  , "over" , "over"        , "over" ],
+    TriggersToInclude      = [ "all"  , "all"       , "all"   , "all"   , "all"  , "all"         , "met"  ],
+    TriggersToExclude      = [ "none" , "none"      , "none"  , "none"  , "none" , "none"        , "none" ],
 
-    DoPercentageOccupancy  = [ FALSE   , FALSE  , FALSE       , TRUE    , FALSE   , FALSE  , FALSE         , FALSE  ],
-    DoEtaPhiOccupancy      = [ FALSE   , FALSE  , FALSE       , FALSE   , tmp_oc2D,tmp_oc2D, tmp_oc2D      , FALSE  ],
-    DoEtaOccupancy         = [ FALSE   , FALSE  , FALSE       , TRUE    ],
-    DoPhiOccupancy         = [ FALSE   , FALSE  , FALSE       , TRUE    ],
+    DoPercentageOccupancy  = [ False  , False       , True    , False   , False  , False         , False  ],
+    DoEtaPhiOccupancy      = [ False  , False       , False   , do2DOcc,do2DOcc, do2DOcc      , False  ],
+    DoEtaOccupancy         = [ False  , False       , False   , False   , False  , False         , False  ],
+    DoPhiOccupancy         = [ False  , False       , True    , False   , False  , False         , False  ],
 
-    DoEtaPhiAverageEnergy  = [ FALSE   , FALSE  , tmp_oc2D    , FALSE   , tmp_oc2D],
-    DoEtaPhiTotalEnergy    = [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   ],
-    DoEtaPhiEnergyRMS      = [ FALSE   , FALSE  , FALSE       ],
-    DoEtaPhiRMSvsDBnoise   = [ FALSE   , FALSE  , FALSE       ],
+    DoEtaPhiAverageEnergy  = [ False  , do2DOcc    , False   , do2DOcc  , False   , False        , False  ],
+    DoEtaPhiTotalEnergy    = [ False  , False       , False   , False   , False   , False        , False  ],
+    #DoEtaPhiEnergyRMS      = , False  , False       , False   , False   , False   , False        , False  ],
+    #DoEtaPhiRMSvsDBnoise   = , False  , False       , False   , False   , False   , False        , False  ], 
 
-    DoEtaPhiAverageQuality = [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   ],
-    DoEtaPhiFractionOverQth= [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   , tmp_oc2D , tmp_oc2D        ],
-    QualityFactorThreshold = [ 4000.   ],
+    DoEtaPhiAverageQuality = [ False  , False       , False   , False   , False   , False        , False  ],
+    DoEtaPhiFractionOverQth= [ False  , False       , False   , False   , do2DOcc , do2DOcc      , False  ],
+    QualityFactorThreshold = [ 4000. ]*7,
 
-    DoEtaPhiAverageTime    = [ FALSE   , FALSE  , FALSE       , FALSE   , TRUE    ],
-    DoEtaPhiFractionPastTth= [ FALSE   , FALSE  , FALSE       , FALSE   , TRUE    ],
-    TimeThreshold          = [ 4.      ],
+    DoEtaPhiAverageTime    = [ False  , False       , False   , True    , False   , False        , False  ],
+    DoEtaPhiFractionPastTth= [ False  , False       , False   , True    , False   , False        , False  ],
+    TimeThreshold          = [ 4.      ]*7,
 
-    MaskEmptyBins          = [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   , FALSE  , FALSE         , FALSE  ], #bins w/o calocell = -1  
-    DoBeamBackgroundRemoval= [ TRUE    , TRUE   , TRUE        , TRUE    , TRUE    , TRUE   , FALSE         , TRUE   ],
+    DoBeamBackgroundRemoval= [ True   , True        , True    , True    , True   , False         , True   ],
 
     # Defaults: (Can be over ridden by layer specific values) ; plots will be made for all layers with DefaultThreshold != -9999999
-    DefaultThresholdTitles= ["default" ,
-                             "no Threshold",
+    ThresholdTitleTemplates= ["no Threshold",
                              "no Threshold",
                              "|E_{cell}| > %0.f#sigma_{noise}^{database}",
                              "E_{cell} beyond %0.f#sigma_{noise}^{database}",
@@ -199,9 +139,8 @@ CaloCellMon = CaloCellVecMon(
                              "E_{cell} > %0.f MeV",
                              "E_{cell} > %0.f MeV, MET trigger"],
 
-    DefaultThresholdNames = ["default" ,"noEth","noEth"], ## if none specified, use threshold type for name
-    DefaultThresholds     = [-9999999.,-4000000.,-4000000.    , 3.      , 5.      , 500.   , 500.          , 1000.  ],
-    DefaultUseNoiseTool   = [ FALSE    , FALSE  , FALSE       , TRUE    , TRUE    , FALSE  , FALSE         , FALSE  ],
+    DefaultThresholds     = [-4000000.,-4000000.    , 3.      , 5.      , 500.   , 500.          , 1000.  ],
+    ThresholdinSigNoise   = [ False   , False       , True    , True    , False  , False         , False  ],
 
     ThresholdColumnType   = ["hiEth", "hiEth_noVeto"],
 
@@ -226,5 +165,49 @@ CaloCellMon = CaloCellVecMon(
     FCAL3_Thresh          = [ 6000. , 6000.         ],
 )
 
-ToolSvc+=CaloCellMon
-CaloMon.AthenaMonTools += [CaloCellMon]
+#Tile monitoring:
+from CaloMonitoring.CaloMonitoringConf import TileCalCellMonTool
+TileCalCellMon=TileCalCellMonTool("TileCalCellMon",
+                             CaloNoiseTool=theCaloNoiseTool
+                            )
+
+
+if DQMonFlags.monManEnvironment == 'online':
+   LArCellMon.isOnline=True
+   LArCellMon.useLArNoisyAlg=False
+   LArCellMon.ProcessNEvents = 100
+else:
+   #Offline processing:
+   LArCellMon.useLArNoisyAlg=True
+
+   if (rec.triggerStream()=='CosmicCalo'):
+      LArCellMon.Sporadic_switch=True
+      LArCellMon.useBeamBackgroundRemoval = True
+      LArCellMon.useLArCollisionFilterTool = True
+      TileCalCellMon.useBeamBackgroundRemoval = True
+      TileCalCellMon.useLArCollisionFilterTool = True
+   else:
+      LArCellMon.Sporadic_switch=False
+      LArCellMon.useBeamBackgroundRemoval = False
+      LArCellMon.useLArCollisionFilterTool = False
+      TileCalCellMon.useBeamBackgroundRemoval = False
+      TileCalCellMon.useLArCollisionFilterTool = False
+
+   if globalflags.DataSource() == 'data': #not MC
+      LArCellMon.useBadLBTool=True
+      LArCellMon.useReadyFilterTool = True
+      TileCalCellMon.useBadLBTool=True
+      TileCalCellMon.useReadyFilterTool = True
+   else:
+      LArCellMon.useBadLBTool=False
+      LArCellMon.useReadyFilterTool = False
+      TileCalCellMon.useBadLBTool=False
+      TileCalCellMon.useReadyFilterTool = False
+      
+
+
+ToolSvc+=LArCellMon
+ToolSvc+=TileCalCellMon
+CaloMon.AthenaMonTools += [LArCellMon,TileCalCellMon]
+
+

Calorimeter/CaloMonitoring/share/CaloCellVecMonCosmics_jobOpt.py

@@ -5,21 +5,17 @@
 # LArCellVecMon_jobOpt.py   Francesco Spano  07/15/07
 # LArCellVecMon_jobOpt.py   R. Kehoe         07/03/06
 
-from CaloMonitoring.CaloMonitoringConf import CaloCellVecMon
-from CaloRec.CaloTopoClusterFlags import jobproperties
+from CaloMonitoring.CaloMonitoringConf import LArCellMonTool
 
-if not 'rec' in dir():
-   from RecExConfig.RecFlags import rec
+from RecExConfig.RecFlags import rec
 
 from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
 
 from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
 theCaloNoiseTool=CaloNoiseToolDefault()
-ToolSvc+=theCaloNoiseTool
 
 from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
 theLArChanMasker=LArBadChannelMasker("LArChanMasker")
@@ -35,100 +31,60 @@ from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
 theLArBadChannelTool=LArBadChanTool()
 ToolSvc+=theLArBadChannelTool
 
-if (DQMonFlags.monManEnvironment == 'online'):
-  tmp_isOnline=TRUE
-else:
-  tmp_isOnline=FALSE
-
-if (DQMonFlags.monManEnvironment == 'online' or globalflags.DataSource.get_Value() == 'geant4' or globalflags.DataSource.get_Value() == 'geant3'):
-  tmp_useBadLBTool=FALSE
-else:
-  tmp_useBadLBTool=TRUE
 
-if DQMonFlags.monManEnvironment() == 'online':
-  tmp_useReadyFilterTool=FALSE
-else:
-  tmp_useReadyFilterTool=FALSE
-
-if DQMonFlags.monManEnvironment() == 'online':
-   tmp_useLArNoisyAlg = FALSE
-else:
-   tmp_useLArNoisyAlg = TRUE
-
-tmp_useElectronicNoiseOnly = FALSE
-tmp_useTwoGaus = TRUE
-
-tmp_useTrigger = TRUE
-if 'DQMonFlags' in dir():
-   if not DQMonFlags.useTrigger:
-      tmp_useTrigger = FALSE
-
-#if DQMonFlags.monManEnvironment() == 'online':
-#   tmp_sporadicSwitch = FALSE
-#else:
-#   tmp_sporadicSwitch = TRUE
-tmp_sporadicSwitch = FALSE
-if (rec.triggerStream()=='CosmicCalo') and not (DQMonFlags.monManEnvironment() == 'online'):
-   tmp_sporadicSwitch = TRUE
-
-CaloCellMonCosmics = CaloCellVecMon(
-    name              = "CaloCellMonCosmics",
+LArCellMon = LArCellMonTool(
+    name = "LArCellMonCosmics",
     CaloCellContainer = "AllCalo",
 
-    TimeGran = "run",
+    #TimeGran = "run",
     ProcessNEvents = 100,  #determines eventsblock time granularity, defined in ManagedMonitorToolBase.
 
-    isOnline=tmp_isOnline,
-    useBadLBTool=tmp_useBadLBTool,
     BadLBTool = GetLArBadLBFilterTool(),
 
-    useReadyFilterTool = tmp_useReadyFilterTool,
     ReadyFilterTool = monAtlasReadyFilterTool,
 
-    useLArNoisyAlg = tmp_useLArNoisyAlg,
-    useElectronicNoiseOnly = tmp_useElectronicNoiseOnly,
-    useTwoGaus = tmp_useTwoGaus,
+    useElectronicNoiseOnly = False,
+    #useTwoGaus = True, Tile-only
 
     CaloNoiseTool=theCaloNoiseTool,
-    useBeamBackgroundRemoval = False,
 
-    useTrigger          = tmp_useTrigger,
+    useTrigger          =  DQMonFlags.useTrigger(),
     rndmTriggerNames    = "L1_RD0, L1_RD0_FILLED, L1_RD0_EMPTY, L1_RD1, L1_RD1_NOISE, L1_RD1_HIST, L1_RD1_BGRP4, L1_RD1_BGRP5",
     caloTriggerNames    = "L1_EM[0-9]+, L1_HA[0-9]+, L1_J[0-9]+.*, L1_JB[0-9]+, L1_JF[0-9]+, L1_TE[0-9]+, L1_JE[0-9]+, L1_XE[0-9]+, L1_2EM[0-9]+, L1_2FJ[0-9]+, L1_2J[0-9]+,L1_3J[0-9]+.*,L1_4J[0-9]+.*,L1_5J[0-9]+,L1_6J[0-9]+,L1_FJ[0-9]+.*",
     minBiasTriggerNames = "L1_RD0_FILLED, L1_MBTS_1, L1_MBTS_2, L1_MBTS_1_1",
     metTriggerNames     = "EF_xe[0-9]+.*",
     miscTriggerNames    = "",
-
     LArBadChannelMask=theLArChanMasker,
     LArBadChannelTool=theLArBadChannelTool,
-    MaskBadChannels    = FALSE,
-    MaskNoCondChannels = FALSE,
-    doInverseMasking   = FALSE,
-    doMaskingOnline    = FALSE,
-    problemsToMaskOffline =["deadReadout","deadPhys","almostDead","short","sporadicBurstNoise","unstableNoiseLG",
-                            "unstableNoiseMG","unstableNoiseHG","highNoiseHG","highNoiseMG","highNoiseLG"],
+    MaskBadChannels    = False,
+    MaskNoCondChannels = False,
+
+    useReadyFilterTool = False,
+    useBeamBackgroundRemoval = False,
+
+    #doInverseMasking   = False,
+ #   doMaskingOnline    = False,
+    #problemsToMaskOffline =["deadReadout","deadPhys","almostDead","short","sporadicBurstNoise","unstableNoiseLG",
+    #                        "unstableNoiseMG","unstableNoiseHG","highNoiseHG","highNoiseMG","highNoiseLG"],
 
     # Database Record Plots (filled in first event)
-    doDatabaseNoiseVsEtaPhi     = TRUE,
-    doKnownBadChannelsVsEtaPhi  = TRUE,
-    doDBNoiseNormalized1DEnergy = FALSE,
-    doUnnormalized1DEnergy      = TRUE,
-    useLogarithmicEnergyBinning = TRUE,
+    doDatabaseNoiseVsEtaPhi     = True,
+    doKnownBadChannelsVsEtaPhi  = True,
+    doUnnormalized1DEnergy      = True,
+    useLogarithmicEnergyBinning = True,
 
     # Use WeightedEff rather than Weighted Average Merging, where appropriate:
     #  (if merging / errors are all correct, this should have no effect, hence this is a good validation tool)
-    useWeightedEffMerging = TRUE,
+    useWeightedEffMerging = True,
 
-    Sporadic_switch = tmp_sporadicSwitch,
     Threshold_EM_S0S1= 5000,
     Threshold_HECFCALEMS2S3= 15000,
-    EventNumber_thres = 10,
     NsporadicPlotLimit = 300,
     Sporadic_protection = 4000,
 
-    DoEtaLumi = FALSE,
-    DoPhiLumi = FALSE,
-
+    #DoEtaLumi = False,
+    #DoPhiLumi = False, 
+    
 # EtaPhi Cell Plots:
     
 #   These histograms will be filled* for every event in which the energy threshold (either absolute or DB noise
@@ -143,35 +99,31 @@ CaloCellMonCosmics = CaloCellVecMon(
 
 # Global Settings:
 
-    ThresholdType          = ["default", "noEth", "noEth_rndm", "medEth", "5Sigma", "hiEth", "hiEth_noVeto", "met"  ],
-    ThresholdDirection     = ["over"   , "none" , "none"      , "both"  , "both"  , "over" , "over"        , "over" ],
-    TriggersToInclude      = ["all"    , "all"  , "all"       , "all"   , "all"   , "all"  , "all"         , "met"  ],
-    TriggersToExclude      = ["none"   , "none" , "none"      ],
+    ThresholdType          = [ "noEth", "noEth_rndm", "medEth", "5Sigma", "hiEth", "hiEth_noVeto", "met"  ],
+    ThresholdDirection     = [ "none" , "none"      , "both"  , "both"  , "over" , "over"        , "over" ],
+    TriggersToInclude      = [ "all"  , "all"       , "all"   , "all"   , "all"  , "all"         , "met"  ],
+    TriggersToExclude      = [ "none" , "none"      , "none"  , "none"  , "none" , "none"        , "none" ],
 
-    DoPercentageOccupancy  = [ FALSE   , FALSE  , FALSE       , TRUE    , FALSE   , FALSE  , FALSE         , FALSE  ],
-    DoEtaPhiOccupancy      = [ FALSE   , FALSE  , FALSE       , FALSE   , TRUE    , TRUE   , TRUE          , FALSE  ],
-    DoEtaOccupancy         = [ FALSE   , FALSE  , FALSE       , TRUE    ],
-    DoPhiOccupancy         = [ FALSE   , FALSE  , FALSE       , TRUE    ],
+    DoPercentageOccupancy  = [ False  , False       , True    , False   , False  , False         , False  ],
+    DoEtaPhiOccupancy      = [ False  , False       , False   , True    , True   , True          , False  ],
+    DoEtaOccupancy         = [ False  , False       , True    , False   , False  , False         , False  ],
+    DoPhiOccupancy         = [ False  , False       , True    , False   , False  , False         , False  ],
 
-    DoEtaPhiAverageEnergy  = [ FALSE   , FALSE  , TRUE        , FALSE   , TRUE    ],
-    DoEtaPhiTotalEnergy    = [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   ],
-    DoEtaPhiEnergyRMS      = [ FALSE   , FALSE  , FALSE       ],
-    DoEtaPhiRMSvsDBnoise   = [ FALSE   , FALSE  , FALSE       ],
+    DoEtaPhiAverageEnergy  = [ False  , True        , False   , True    , False   , False        , False  ],
+    DoEtaPhiTotalEnergy    = [ False  , False       , False   , False   , False   , False        , False  ],
 
-    DoEtaPhiAverageQuality = [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   ],
-    DoEtaPhiFractionOverQth= [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   , TRUE   , TRUE          ],
-    QualityFactorThreshold = [ 4000.   ],
+    DoEtaPhiAverageQuality = [ False  , False       , False   , False   , False   , False        , False  ],
+    DoEtaPhiFractionOverQth= [ False  , False       , False   , False   , True    , True         , False  ],
+    QualityFactorThreshold = [ 4000. ]*7,
 
-    DoEtaPhiAverageTime    = [ FALSE   , FALSE  , FALSE       , FALSE   , TRUE    ],
-    DoEtaPhiFractionPastTth= [ FALSE   , FALSE  , FALSE       , FALSE   , TRUE    ],
-    TimeThreshold          = [ 4.      ],
+    DoEtaPhiAverageTime    = [ False  , False       , False   , False    , False   , False        , False  ],
+    DoEtaPhiFractionPastTth= [ False  , False       , False   , False    , False   , False        , False  ],
+    TimeThreshold          = [ 4.      ]*7,
 
-    MaskEmptyBins          = [ FALSE   , FALSE  , FALSE       , FALSE   , FALSE   , TRUE   , TRUE          , FALSE  ], #bins w/o calocell = -1  
-    DoBeamBackgroundRemoval= [ TRUE    , TRUE   , TRUE        , TRUE    , TRUE    , TRUE   , FALSE         , TRUE   ],
+    DoBeamBackgroundRemoval= [ True   , True        , True    , True    , True   , False         , True   ],
 
     # Defaults: (Can be over ridden by layer specific values) ; plots will be made for all layers with DefaultThreshold != -9999999
-    DefaultThresholdTitles= ["default" ,
-                             "no Threshold",
+    ThresholdTitleTemplates= ["no Threshold",
                              "no Threshold",
                              "|E_{cell}| > %0.f#sigma_{noise}^{database}",
                              "E_{cell} beyond %0.f#sigma_{noise}^{database}",
@@ -179,9 +131,8 @@ CaloCellMonCosmics = CaloCellVecMon(
                              "E_{cell} > %0.f MeV",
                              "E_{cell} > %0.f MeV, MET trigger"],
 
-    DefaultThresholdNames = ["default" ,"noEth","noEth"], ## if none specified, use threshold type for name
-    DefaultThresholds     = [-9999999.,-4000000.,-4000000.    , 3.      , 5.      , 500.   , 500.          , 1000.  ],
-    DefaultUseNoiseTool   = [ FALSE    , FALSE  , FALSE       , TRUE    , TRUE    , FALSE  , FALSE         , FALSE  ],
+    DefaultThresholds     = [-4000000.,-4000000.    , 3.      , 5.      , 500.   , 500.          , 1000.  ],
+    ThresholdinSigNoise   = [ False   , False       , True    , True    , False  , False         , False  ],
 
     ThresholdColumnType   = ["hiEth", "hiEth_noVeto"],
 
@@ -206,6 +157,41 @@ CaloCellMonCosmics = CaloCellVecMon(
     FCAL3_Thresh          = [ 6000. , 6000.         ],
 )
 
-ToolSvc+=CaloCellMonCosmics
-CaloMon.AthenaMonTools += [CaloCellMonCosmics]
-   
+
+#Tile monitoring:
+from CaloMonitoring.CaloMonitoringConf import TileCalCellMonTool
+TileCalCellMon=TileCalCellMonTool("TileCalCellMonCosmics",
+                            CaloNoiseTool=theCaloNoiseTool,
+                            useReadyFilterTool = False,
+                            useBeamBackgroundRemoval = False
+                            )
+
+
+if DQMonFlags.monManEnvironment == 'online':
+   LArCellMon.isOnline=True
+   LArCellMon.useLArNoisyAlg=False
+   LArCellMon.ProcessNEvents = 100
+else:
+   #Offline processing:
+   LArCellMon.useLArNoisyAlg=True
+
+   if (rec.triggerStream()=='CosmicCalo'):
+      LArCellMon.Sporadic_switch=True
+   else:
+      LArCellMon.Sporadic_switch=False
+
+   if globalflags.DataSource() == 'data': #not MC
+      LArCellMon.useBadLBTool=True
+      TileCalCellMon.useBadLBTool=True
+   else:
+      LArCellMon.useBadLBTool=False
+      TileCalCellMon.useBadLBTool=False
+      
+
+
+ToolSvc+=LArCellMon
+ToolSvc+=TileCalCellMon
+CaloMon.AthenaMonTools += [LArCellMon,TileCalCellMon]
+
+
+

Calorimeter/CaloMonitoring/src/CaloBaselineMon.cxx

@@ -31,8 +31,9 @@ using Athena::Units::GeV;
 
 CaloBaselineMon::CaloBaselineMon(const std::string& type, const std::string& name, const IInterface* parent) :
   CaloMonToolBase(type, name, parent),
+  //  m_caloMgr(nullptr),
   m_calo_id(nullptr),
-  m_bunchCrossingTool("Trig::TrigConfBunchCrossingTool/BunchCrossingTool")
+  m_bunchCrossingTool("BunchCrossingTool")
 {
   declareInterface<IMonitorToolBase>(this);
 
@@ -53,6 +54,7 @@ CaloBaselineMon::~CaloBaselineMon() {
 ////////////////////////////////////////////////////////////////////////////
 StatusCode CaloBaselineMon::initialize() {
 
+  //  ATH_MSG_WARNING("Entering CaloBaselineMon::initialize");
   StatusCode sc = StatusCode::SUCCESS;
   sc = retrieveTools();
 
@@ -99,6 +101,14 @@ StatusCode CaloBaselineMon::initialize() {
 StatusCode CaloBaselineMon::retrieveTools(){
 
   StatusCode sc = StatusCode::SUCCESS;
+//  sc = detStore()->retrieve(m_caloMgr);
+//  if (sc.isFailure()) {
+//    ATH_MSG_ERROR( "Unable to retrieve CaloIdManager from DetectorStore" );
+//    return sc;
+//  }
+//  else{
+//   ATH_MSG_INFO("CaloMgr is retrieved");
+//  }
 
 
   ATH_CHECK( detStore()->retrieve(m_calo_id) );
@@ -113,6 +123,7 @@ StatusCode CaloBaselineMon::retrieveTools(){
    ATH_MSG_INFO("CaloMgr is retrieved");
   }
     
+    //  ATH_CHECK( m_bunchCrossingTool.retrieve());
  
   return sc;
 }
@@ -165,34 +176,32 @@ void CaloBaselineMon::bookPartitionHistos(partitionHistos& partition, uint partN
   
   int lb_nbins = 3000;
 
-  std::string yAxisTitle = "< #Sigma E_{"+m_partNames[partNumber]+"} > [MeV]";
-
   if (m_bool_pedestalMon) {
-    std::string str_auxTitle = " Empty bunch - BCID > "+ std::to_string(m_pedestalMon_BCIDmin) +"BCIDs away from last train";
+    std::string str_auxTitle = " Empty BCID > "+ std::to_string(m_pedestalMon_BCIDmin) +"BCID away from last train";
     
     partition.hProf_pedestalMon_vs_EtaBCID.resize(m_nbOfEtaBins[partNumber]);
     for (uint iEta = 0; iEta < m_nbOfEtaBins[partNumber]; iEta ++){
-      hName  = "hprof1d_pedestalMon_"+m_partNames[partNumber]+"_eta"+std::to_string(iEta);
+      hName  = "hprof_pedestalMon_"+m_partNames[partNumber]+"_eta"+std::to_string(iEta);
       std::string str_eta0 = std::to_string( ((float) iEta)*m_etaBinWidth[partNumber]+m_etaMin[partNumber] );
       std::string str_eta1 = std::to_string( ((float) iEta + 1)*m_etaBinWidth[partNumber]+m_etaMin[partNumber] );
-      hTitle = str_auxTitle+ " - " + str_eta0 +" < #eta < " + str_eta1;
+      hTitle = "Pedestal baseline ( "+str_auxTitle+") - "+m_partNames[partNumber]+" - " + str_eta0 +" < eta < " + str_eta1;
       partition.hProf_pedestalMon_vs_EtaBCID[iEta] = TProfile_LW::create(hName.c_str(), hTitle.c_str(),m_BCID0_nbins,m_BCID0_min,m_BCID0_max);
       partition.hProf_pedestalMon_vs_EtaBCID[iEta]->GetXaxis()->SetTitle("BCID");
-      partition.hProf_pedestalMon_vs_EtaBCID[iEta]->GetYaxis()->SetTitle(yAxisTitle.c_str());
+      partition.hProf_pedestalMon_vs_EtaBCID[iEta]->GetYaxis()->SetTitle("");
       group.regHist(partition.hProf_pedestalMon_vs_EtaBCID[iEta]).ignore();  
     }      
     
     hName  = "hprof1d_pedestalMon"+m_partNames[partNumber]+"_AllEta";
-    hTitle = str_auxTitle;
+    hTitle = "Pedestal baseline ( "+str_auxTitle+") - "+m_partNames[partNumber];
     partition.hProf_pedestalMon_vs_Eta = TProfile_LW::create(hName.c_str(), hTitle.c_str(),m_nbOfEtaBins[partNumber],m_etaMin[partNumber],m_etaMax[partNumber]);
-    partition.hProf_pedestalMon_vs_Eta->GetXaxis()->SetTitle("#eta");
-    partition.hProf_pedestalMon_vs_Eta->GetYaxis()->SetTitle(yAxisTitle.c_str());
+    partition.hProf_pedestalMon_vs_Eta->GetXaxis()->SetTitle("Eta");
+    partition.hProf_pedestalMon_vs_Eta->GetYaxis()->SetTitle("Average over BCID");
     group.regHist(partition.hProf_pedestalMon_vs_Eta).ignore();  
     
     hName  = "hprof1d_pedestalMon_"+m_partNames[partNumber]+"_LB";
     partition.hProf_pedestalMon_vs_LB = TProfile_LW::create(hName.c_str(), hTitle.c_str(),lb_nbins,0,(float) lb_nbins);
     partition.hProf_pedestalMon_vs_LB->GetXaxis()->SetTitle("Luminosity block");
-    partition.hProf_pedestalMon_vs_LB->GetYaxis()->SetTitle(yAxisTitle.c_str());
+    partition.hProf_pedestalMon_vs_LB->GetYaxis()->SetTitle("Average over BCID and eta");
     group.regHist(partition.hProf_pedestalMon_vs_LB).ignore();  
   }
 
@@ -200,32 +209,32 @@ void CaloBaselineMon::bookPartitionHistos(partitionHistos& partition, uint partN
     int BCID_nbins = (int) m_bcidtoolMon_BCIDmax;
     float BCID_min = 0.;
     float BCID_max = m_bcidtoolMon_BCIDmax;
-    std::string str_auxTitle = "Filled bunch";
+    std::string str_auxTitle = "BCID in bunch train";
     
     partition.hProf_bcidtoolMon_vs_EtaBCID.resize(m_nbOfEtaBins[partNumber]);
     for (uint iEta = 0; iEta < m_nbOfEtaBins[partNumber]; iEta ++){
-      hName  = "hprof1d_bcidtoolMon_"+m_partNames[partNumber]+"_eta"+std::to_string(iEta);
+      hName  = "hprof_bcidtoolMon_"+m_partNames[partNumber]+"_eta"+std::to_string(iEta);
       std::string str_eta0 = std::to_string( ((float) iEta)*m_etaBinWidth[partNumber]+m_etaMin[partNumber] );
       std::string str_eta1 = std::to_string( ((float) iEta + 1)*m_etaBinWidth[partNumber]+m_etaMin[partNumber] );
-      hTitle = str_auxTitle + " - " + str_eta0 +" < #eta < " + str_eta1;
+      hTitle = "BCIDtool baseline ( "+str_auxTitle+")-"+m_partNames[partNumber]+" - " + str_eta0 +" < eta < " + str_eta1;
       partition.hProf_bcidtoolMon_vs_EtaBCID[iEta] = TProfile_LW::create(hName.c_str(), hTitle.c_str(),BCID_nbins,BCID_min,BCID_max);
       partition.hProf_bcidtoolMon_vs_EtaBCID[iEta]->GetXaxis()->SetTitle("BCID");
-      partition.hProf_bcidtoolMon_vs_EtaBCID[iEta]->GetYaxis()->SetTitle(yAxisTitle.c_str());
+      partition.hProf_bcidtoolMon_vs_EtaBCID[iEta]->GetYaxis()->SetTitle("");
       group.regHist(partition.hProf_bcidtoolMon_vs_EtaBCID[iEta]).ignore();  
     }
 
     
     hName  = "hprof1d_bcidtoolMon"+m_partNames[partNumber]+"_AllEta";
-    hTitle = str_auxTitle;
+    hTitle = "BCIDtool baseline ( "+str_auxTitle+") - "+m_partNames[partNumber];
     partition.hProf_bcidtoolMon_vs_Eta = TProfile_LW::create(hName.c_str(), hTitle.c_str(),m_nbOfEtaBins[partNumber],m_etaMin[partNumber],m_etaMax[partNumber]);
-    partition.hProf_bcidtoolMon_vs_Eta->GetXaxis()->SetTitle("#eta");
-    partition.hProf_bcidtoolMon_vs_Eta->GetYaxis()->SetTitle(yAxisTitle.c_str());
+    partition.hProf_bcidtoolMon_vs_Eta->GetXaxis()->SetTitle("Eta");
+    partition.hProf_bcidtoolMon_vs_Eta->GetYaxis()->SetTitle("Average over BCID");
     group.regHist(partition.hProf_bcidtoolMon_vs_Eta).ignore();  
 
     hName  = "hprof1d_bcidtoolMon"+m_partNames[partNumber]+"_LB";
     partition.hProf_bcidtoolMon_vs_LB = TProfile_LW::create(hName.c_str(), hTitle.c_str(),lb_nbins,0,(float) lb_nbins);
     partition.hProf_bcidtoolMon_vs_LB->GetXaxis()->SetTitle("Luminosity block");
-    partition.hProf_bcidtoolMon_vs_LB->GetYaxis()->SetTitle(yAxisTitle.c_str());
+    partition.hProf_bcidtoolMon_vs_LB->GetYaxis()->SetTitle("Average over BCID and eta");
     group.regHist(partition.hProf_bcidtoolMon_vs_LB).ignore();  
   }
 
@@ -251,7 +260,7 @@ StatusCode CaloBaselineMon::fillHistograms() {
 
   // Fill pedestalMon only when the bunch is empty and far away enough from the last train.
   if (m_bool_pedestalMon){
-    if ((not m_bunchCrossingTool->isFilled(bcid)) and (m_bunchCrossingTool->gapBeforeBunch(bcid) >= m_pedestalMon_BCIDmin*25.)) thisEvent_bool_pedestalMon = true;
+    if ((not m_bunchCrossingTool->isFilled(bcid)) and (m_bunchCrossingTool->gapAfterBunch(bcid) >= m_pedestalMon_BCIDmin*25.)) thisEvent_bool_pedestalMon = true;
   }
   // Fill bcidtoolMon only when the bunch is in a bunch train and within accepted BCID range.
   if (m_bool_bcidtoolMon){
@@ -283,15 +292,17 @@ StatusCode CaloBaselineMon::fillHistograms() {
     const CaloCell* cell = *it; 
     Identifier id = cell->ID();
     float energy = cell->energy();
-    double eta = cell->eta();
+    double eta = cell->caloDDE()->eta_raw();
 
     int partThisAlgo = 0;
     if  (m_calo_id->is_em(id)) partThisAlgo = m_partMap[0];
     if  (m_calo_id->is_hec(id)) partThisAlgo = m_partMap[1]; 
     if  (m_calo_id->is_fcal(id)) partThisAlgo = m_partMap[2]; 
 
+   
     if ((eta<m_etaMin[partThisAlgo]) or (eta>m_etaMax[partThisAlgo])) continue;
-    int etaBin = (int) (eta*m_inv_etaBinWidth[partThisAlgo]);
+    int etaBin = std::floor((eta-m_etaMin[partThisAlgo])*m_inv_etaBinWidth[partThisAlgo]);
+
     m_sum_partition_eta[partThisAlgo][etaBin] += energy;
   } // cell iter loop
 

Calorimeter/CaloMonitoring/src/CaloMonToolBase.cxx

@@ -42,7 +42,6 @@ StatusCode CaloMonToolBase::initialize() {
      m_useReadyFilterTool = false;
      return sc;
    }
-   ATH_MSG_INFO("AtlasReadyFilterTool retrieved");
   }
 
   // retrieve BadLBFilter tool 
@@ -161,7 +160,6 @@ StatusCode CaloMonToolBase::checkFilters(bool& ifPass){
       ATH_MSG_WARNING("Unable to retrieve BeamBackgroundData");
     }
     else {
-         ATH_MSG_INFO("BeamBackgroundData is retrieved");
       if( beamBackgroundData->GetNumSegment() > 0 ) {
         m_passBeamBackgroundRemoval = false;
 	ifPass = 0;

Calorimeter/CaloMonitoring/src/CaloLayer.cxx → Calorimeter/CaloMonitoring/src/LArCellBinning.cxx

-/*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
 // ***********************************************************
 //                                                            
-// CaloLayer - class to hold granularity info   
-// for layers of the Calorimeter. To be used with             
-// CaloCellVecMon class                                       
+// LArCellBinning - class to hold granularity info   
+// for layers of the LAr-Calorimeter. To be used with             
+// LArCellMonTools class                                       
 //                                                            
 // ***********************************************************                                                                                                                                                   
-
-#include <cstdio>
-#include <cstdlib>
+#include "CaloMonitoring/LArCellBinning.h"
 #include <iostream>
-
-#include "CaloMonitoring/CaloLayer.h"
-
 #include "TMath.h"
 
 
 static const double Pi = TMath::Pi();
 
 using namespace CaloMonitoring;
-using namespace std;
-
-//
-CaloLayer::CaloLayer(const char* name,Partition partition, int layerNumber, Side side) {
-
-  m_name = name;
-  
-  m_nTotEtaBins = 0;
-  m_etaBinArray = nullptr;
-  m_nTotPhiBins = 0;
-  m_phiBinArray = nullptr;
-
-  setProperties(partition, layerNumber, side);
-}
 
 // need to delete dynamically allocated arrays
-CaloLayer::~CaloLayer() {
-  delete [] m_etaBinArray;
-  delete [] m_phiBinArray;
-}
+LArCellBinning::~LArCellBinning() {
 
-// 
-void CaloLayer::setProperties(Partition partition, int layerNumber, Side side) {
-  m_partition = partition;
-  m_layerNumber = layerNumber;
-  m_side = side;
 }
 
-//
-void CaloLayer::doEtaBinning(const int nEtaRegions, double* etaBreakPts, int * nEtaBins) {
+void LArCellBinning::doEtaBinning(const int nEtaRegions, const double* etaBreakPts, const int * nEtaBins) {
   
-  //
-  m_nTotEtaBins=0;
+  unsigned nBins=0;
   for(int i=0; i<nEtaRegions; i++) {
-    m_nTotEtaBins += nEtaBins[i];
+    nBins += nEtaBins[i];
   }
 
-  //
-  const int nBins = m_nTotEtaBins;
-  m_etaBinArray = new double[nBins+1]; // to account for the high edge of the last bin
-
-  // initialize the eta bin array
-  for(int iBin=0; iBin<m_nTotEtaBins; iBin++)
-    m_etaBinArray[iBin] = 0.;
+  //m_etaBinArray = new double[nBins+1]; // to account for the high edge of the last bin
+  m_etaBinArray.resize(nBins+1,0.0);
 
+ 
   // Loop over regions and figure out size of bins in each region
   int bin=0;
   for(int iReg=0; iReg<nEtaRegions; iReg++) {
@@ -86,31 +49,33 @@ void CaloLayer::doEtaBinning(const int nEtaRegions, double* etaBreakPts, int * n
   m_etaBinArray[bin] = etaBreakPts[nEtaRegions];
 
   // check that in ascending order
-  for(int j=0; j<m_nTotEtaBins; j++) {
+  for(int j=0; j<getNTotEtaBins(); j++) {
     if(m_etaBinArray[j] >= m_etaBinArray[j+1]) {
-      cerr << "ERROR: Bin array not in correct order. Make sure breakPoints array\n"
-	   << "is in ascending order" << endl;
+      std::cerr << "ERROR: Bin array not in correct order. Make sure breakPoints array\n"
+		<< "is in ascending order" << std::endl;
     }
   }
 }
 
 // Allows for the case for multiple granularity regions in phi (only really happens
 // for the FCAL)
-void CaloLayer::doPhiBinning(const int nPhiRegions, double* phiBreakPts, int * nPhiBins) {
+void LArCellBinning::doPhiBinning(const int nPhiRegions, const double* phiBreakPts, const int * nPhiBins) {
   
-  //
-  m_nTotPhiBins=0;
+  
+  unsigned nBins=0;
   for(int i=0; i<nPhiRegions; i++) {
-    m_nTotPhiBins += nPhiBins[i];
+    nBins += nPhiBins[i];
   }
 
   //
-  const int nBins = m_nTotPhiBins+1;
-  m_phiBinArray = new double[nBins];
+  //const int nBins = m_nTotPhiBins+1;
+  // m_phiBinArray = new double[nBins];
+
+  // // initialize the phi bin array
+  // for(int iBin=0; iBin<m_nTotPhiBins+1; iBin++)
+  //   m_phiBinArray[iBin] = 0.;
 
-  // initialize the phi bin array
-  for(int iBin=0; iBin<m_nTotPhiBins+1; iBin++)
-    m_phiBinArray[iBin] = 0.;
+  m_phiBinArray.resize(nBins+1,0.0);
 
   // Loop over regions and figure out size of bins in each region
   int bin=0;
@@ -131,55 +96,42 @@ void CaloLayer::doPhiBinning(const int nPhiRegions, double* phiBreakPts, int * n
   m_phiBinArray[bin] = phiBreakPts[nPhiRegions];
 
   // check that in ascending order
-  for(int j=0; j<m_nTotPhiBins; j++) {
+  for(int j=0; j<getNTotPhiBins(); j++) {
     if(m_phiBinArray[j] >= m_phiBinArray[j+1]) {
-      cerr << "ERROR: Bin array not in correct order. Make sure breakPoints array\n"
-	   << "is in ascending order" << endl;
+      std::cerr << "ERROR: Bin array not in correct order. Make sure breakPoints array\n"
+		<< "is in ascending order" << std::endl;
     }
   }
 }
 
 // Does phi binning using the common case with only one phi granularity region
-void CaloLayer::doPhiBinning(int nPhiBins) {
+void LArCellBinning::doPhiBinning(int nPhiBins) {
   
-  //
   int nPhiBinArray[1] = {nPhiBins};
   double phiBreakPtsArray[2] = {-Pi,Pi};
 
-  //
   doPhiBinning(1, phiBreakPtsArray, nPhiBinArray);
 }
 
+LArCellBinning LArCellBinning::etaMirror() const {
+  LArCellBinning mirrored;
 
-//
-void CaloLayer::doSideCBinning(CaloLayer * lyr) {
-  
-  if(lyr == this) {
-    std::cerr << "CaloLayer - ERROR: can't do side C binning using self for " << getName()
-	      << ". Program may crash" << std::endl;
-    return;
-  }
+  //copy phi-binning:
+  mirrored.m_phiBinArray=this->m_phiBinArray;
 
-  // phi bins for side A and C are the same:
-  m_nTotPhiBins = lyr->getNTotPhiBins();
-  const int nPhiBins = m_nTotPhiBins;
-  m_phiBinArray = new double[nPhiBins+1];
-  double * sideAPhiBinArray;
-  sideAPhiBinArray = lyr->getPhiBinArray();
-  
-  for(int bin=0; bin<nPhiBins+1; bin++) {
-    m_phiBinArray[bin] = sideAPhiBinArray[bin];
+  //fill eta-binning
+  const size_t etaSize=this->m_etaBinArray.size();
+  mirrored.m_etaBinArray.resize(etaSize);
+  for (size_t i=0;i<etaSize;++i) {
+    mirrored.m_etaBinArray[i]=-1.0*m_etaBinArray[etaSize-i-1];
   }
-  // eta bin array for side C is basically the negative of the side A bin array
-  // in opposite order
-  m_nTotEtaBins = lyr->getNTotEtaBins();
-  const int nEtaBins = m_nTotEtaBins;
-  m_etaBinArray = new double[nEtaBins+1];
-  double * sideAEtaBinArray;
-  sideAEtaBinArray = lyr->getEtaBinArray();
-
-  for(int bin=0; bin<nEtaBins+1; bin++) {
-    m_etaBinArray[bin] = -sideAEtaBinArray[nEtaBins-bin];
+  
+  // check that in ascending order
+  for(int j=0; j<mirrored.getNTotEtaBins(); j++) {
+    if(mirrored.m_etaBinArray[j] >= mirrored.m_etaBinArray[j+1]) {
+      std::cerr << "ERROR: Bin array not in correct order. Make sure breakPoints array\n"
+		<< "is in ascending order" << std::endl;
+    }
   }
+  return mirrored;
 }
-

Calorimeter/CaloMonitoring/src/LArCellMonSetBinning.cxx

+#include "CaloMonitoring/LArCellMonTool.h"
+
+
+using namespace CaloMonitoring;
+
+void LArCellMonTool::setLArCellBinning() {
+
+ //EMB Pre-sampler 
+  const int embpaNEtaReg = 1;
+  double embpaEtaBreakPts[embpaNEtaReg+1]={0.,1.52};
+  int embpaEtaBins[embpaNEtaReg]={61};
+  m_binning[EMBPA].doEtaBinning(embpaNEtaReg,embpaEtaBreakPts,embpaEtaBins);
+  m_binning[EMBPA].doPhiBinning(64);
+  m_binning[EMBPC]= m_binning[EMBPA].etaMirror();
+
+  // EMB Layer 1 
+  const int emb1aNEtaReg = 1;
+  double emb1aEtaBreakPts[emb1aNEtaReg+1]={0.,1.4};
+  int emb1aEtaBins[emb1aNEtaReg]={448};
+  m_binning[EMB1A].doEtaBinning(emb1aNEtaReg,emb1aEtaBreakPts,emb1aEtaBins);
+  m_binning[EMB1A].doPhiBinning(64);
+  m_binning[EMB1C]=m_binning[EMB1A].etaMirror();
+  
+  // EMB Layer 2
+  const int emb2aNEtaReg = 1;
+  double emb2aEtaBreakPts[emb2aNEtaReg+1]={0.,1.475};
+  int emb2aEtaBins[emb2aNEtaReg]={59};
+  m_binning[EMB2A].doEtaBinning(emb2aNEtaReg,emb2aEtaBreakPts,emb2aEtaBins);
+  m_binning[EMB2A].doPhiBinning(256);
+  m_binning[EMB2C]=m_binning[EMB2A].etaMirror();
+  
+  // EMB Layer 3
+  const int emb3aNEtaReg = 2;
+  double emb3aEtaBreakPts[emb3aNEtaReg+1]={0.00,1.35,1.475};
+  int emb3aEtaBins[emb3aNEtaReg]={27,1};
+  m_binning[EMB3A].doEtaBinning(emb3aNEtaReg,emb3aEtaBreakPts,emb3aEtaBins);
+  m_binning[EMB3A].doPhiBinning(256);
+  m_binning[EMB3C]= m_binning[EMB3A].etaMirror();
+
+  // HEC Layer 0 
+  const int hec0aNEtaReg = 2;
+  double hec0aEtaBreakPts[hec0aNEtaReg+1]={1.5,2.5,3.3};
+  int hec0aEtaBins[hec0aNEtaReg]={10,4};
+  m_binning[HEC0A].doEtaBinning(hec0aNEtaReg,hec0aEtaBreakPts,hec0aEtaBins);
+  m_binning[HEC0A].doPhiBinning(64);
+  m_binning[HEC0C]=m_binning[HEC0A].etaMirror();
+  
+  // HEC Layer 1 
+  const int hec1aNEtaReg = 2;
+  double hec1aEtaBreakPts[hec1aNEtaReg+1]={1.5,2.5,3.1};
+  int hec1aEtaBins[hec1aNEtaReg]={10,3};
+  m_binning[HEC1A].doEtaBinning(hec1aNEtaReg,hec1aEtaBreakPts,hec1aEtaBins);
+  m_binning[HEC1A].doPhiBinning(64);
+  m_binning[HEC1C]=m_binning[HEC1A].etaMirror();
+  
+  // HEC Layer 2 
+  const int hec2aNEtaReg = 2;
+  double hec2aEtaBreakPts[hec2aNEtaReg+1]={1.6,2.5,3.1};
+  int hec2aEtaBins[hec2aNEtaReg]={9,3};
+  m_binning[HEC2A].doEtaBinning(hec2aNEtaReg,hec2aEtaBreakPts,hec2aEtaBins);
+  m_binning[HEC2A].doPhiBinning(64);
+  m_binning[HEC2C]=m_binning[HEC2A].etaMirror();
+
+  // HEC Layer 3 
+  const int hec3aNEtaReg = 2;
+  double hec3aEtaBreakPts[hec3aNEtaReg+1]={1.7,2.5,3.3};
+  int hec3aEtaBins[hec3aNEtaReg]={8,4};
+  m_binning[HEC3A].doEtaBinning(hec3aNEtaReg,hec3aEtaBreakPts,hec3aEtaBins);
+  m_binning[HEC3A].doPhiBinning(64);
+  m_binning[HEC3C]=m_binning[HEC3A].etaMirror();
+  
+  // EMEC Pre-sampler (Layer 0) 
+   const int emecpaNEtaReg = 1;
+  double emecpaEtaBreakPts[emecpaNEtaReg+1]={1.5,1.8};
+  int emecpaEtaBins[emecpaNEtaReg]={12};
+  m_binning[EMECPA].doEtaBinning(emecpaNEtaReg,emecpaEtaBreakPts,emecpaEtaBins);
+  m_binning[EMECPA].doPhiBinning(64);
+  m_binning[EMECPC]=m_binning[EMECPA].etaMirror();
+ 
+  // EMEC Layer 1 
+  const int emec1aNEtaReg = 7;
+  double emec1aEtaBreakPts[emec1aNEtaReg+1]={1.375,1.425,1.5,1.8,2.0,2.4,2.5,3.2};
+  int emec1aEtaBins[emec1aNEtaReg]={1,3,96,48,64,4,7};
+  m_binning[EMEC1A].doEtaBinning(emec1aNEtaReg,emec1aEtaBreakPts,emec1aEtaBins);
+  m_binning[EMEC1A].doPhiBinning(64);
+  m_binning[EMEC1C]=m_binning[EMEC1A].etaMirror();
+
+  // EMEC Layer 2 
+  const int emec2aNEtaReg = 3;
+  double emec2aEtaBreakPts[emec2aNEtaReg+1]={1.375,1.425,2.5,3.2};
+  int emec2aEtaBins[emec2aNEtaReg]={1,43,7};
+  m_binning[EMEC2A].doEtaBinning(emec2aNEtaReg,emec2aEtaBreakPts,emec2aEtaBins);
+  m_binning[EMEC2A].doPhiBinning(256);
+  m_binning[EMEC2C]=m_binning[EMEC2A].etaMirror();
+
+  // EMEC Layer 3 
+  const int emec3aNEtaReg = 1;
+  double emec3aEtaBreakPts[emec3aNEtaReg+1]={1.5,2.5};
+  int emec3aEtaBins[emec3aNEtaReg]={20};
+  m_binning[EMEC3A].doEtaBinning(emec3aNEtaReg,emec3aEtaBreakPts,emec3aEtaBins);
+  m_binning[EMEC3A].doPhiBinning(256);
+  m_binning[EMEC3C]=m_binning[EMEC3A].etaMirror();
+
+  // FCAL Layer 1  (0th layer in the code) 
+  const int fcal1aNEtaReg = 4;
+  double fcal1aEtaBreakPts[fcal1aNEtaReg+1]={3.08,3.2,3.8,4.6,4.82};
+  int fcal1aEtaBins[fcal1aNEtaReg]={3,6,4,2};
+  m_binning[FCAL1A].doEtaBinning(fcal1aNEtaReg,fcal1aEtaBreakPts,fcal1aEtaBins);
+  
+  const int fcal1aNPhiReg = 95;
+  double fcal1aPhiBreakPts[fcal1aNPhiReg+1]=
+    {-M_PI,(-250.0/256)*M_PI,(-248.0/256)*M_PI,(-243.0/256)*M_PI,(-240.0/256)*M_PI,(-234.0/256)*M_PI,
+     (-230.0/256)*M_PI,(-225.0/256)*M_PI,(-219.0/256)*M_PI,(-195.0/256)*M_PI,(-190.0/256)*M_PI,(-186.0/256)*M_PI,
+     (-183.0/256)*M_PI,(-178.0/256)*M_PI,(-175.0/256)*M_PI,(-173.0/256)*M_PI,(-167.0/256)*M_PI,(-161.0/256)*M_PI,
+     (-159.0/256)*M_PI,(-156.0/256)*M_PI,(-151.0/256)*M_PI,(-148.0/256)*M_PI,(-146.0/256)*M_PI,(-141.0/256)*M_PI,
+     (-139.0/256)*M_PI,(-135.0/256)*M_PI,(-132.0/256)*M_PI,(-120.0/256)*M_PI,(-117.0/256)*M_PI,(-114.0/256)*M_PI,
+     (-110.0/256)*M_PI,(-105.0/256)*M_PI,(-97.0/256)*M_PI,(-94.0/256)*M_PI,(-86.0/256)*M_PI,(-78.0/256)*M_PI,
+     (-63.0/256)*M_PI,(-60.0/256)*M_PI,(-56.0/256)*M_PI,(-46.0/256)*M_PI,(-44.0/256)*M_PI,(-41.0/256)*M_PI,
+     (-32.0/256)*M_PI,(-28.0/256)*M_PI,(-22.0/256)*M_PI,(-10.0/256)*M_PI,(-7.0/256)*M_PI,(-3.0/256)*M_PI,
+     (6.0/256)*M_PI,(8.0/256)*M_PI,(13.0/256)*M_PI,(16.0/256)*M_PI,(22.0/256)*M_PI,(26.0/256)*M_PI,(31.0/256)*M_PI,
+     (37.0/256)*M_PI,(61.0/256)*M_PI,(66.0/256)*M_PI,(70.0/256)*M_PI,(73.0/256)*M_PI,(78.0/256)*M_PI,(81.0/256)*M_PI,
+     (83.0/256)*M_PI,(89.0/256)*M_PI,(95.0/256)*M_PI,(97.0/256)*M_PI,(100.0/256)*M_PI,(105.0/256)*M_PI,
+     (108.0/256)*M_PI,(110.0/256)*M_PI,(115.0/256)*M_PI,(117.0/256)*M_PI,(121.0/256)*M_PI,(124.0/256)*M_PI,
+     (136.0/256)*M_PI,(139.0/256)*M_PI,(142.0/256)*M_PI,(146.0/256)*M_PI,(151.0/256)*M_PI,(159.0/256)*M_PI,
+     (162.0/256)*M_PI,(170.0/256)*M_PI,(178.0/256)*M_PI,(193.0/256)*M_PI,(196.0/256)*M_PI,(200.0/256)*M_PI,
+     (210.0/256)*M_PI,(212.0/256)*M_PI,(215.0/256)*M_PI,(224.0/256)*M_PI,(228.0/256)*M_PI,(234.0/256)*M_PI,
+     (246.0/256)*M_PI,(249.0/256)*M_PI,(253.0/256)*M_PI,M_PI};
+  int fcal1aPhiBins[fcal1aNPhiReg+1] =
+    {2,1,1,1,1,1,1,2,6,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,3,1,1,2,1,2,1,2,4,3,1,1,2,1,1,3,1,2,2,1,2,3,
+     1,1,1,1,1,1,2,6,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,3,1,1,2,1,2,1,2,4,3,1,1,2,1,1,3,1,2,2,1,2,1};
+  m_binning[FCAL1A].doPhiBinning(fcal1aNPhiReg,fcal1aPhiBreakPts,fcal1aPhiBins);
+  m_binning[FCAL1C]=m_binning[FCAL1A].etaMirror();
+  
+  // FCAL Layer 2  (1st layer in the code);
+  const int fcal2aNEtaReg = 15;
+  double fcal2aEtaBreakPts[fcal2aNEtaReg+1]=
+    {3.192,3.1987,3.206,3.22,3.26,3.34,3.37,3.39,3.52,3.57,3.835,4.1,4.365,4.5,4.65,4.81};
+  int fcal2aEtaBins[fcal2aNEtaReg]={1,1,1,2,2,1,1,3,1,4,2,1,1,1,1};
+  m_binning[FCAL2A].doEtaBinning(fcal2aNEtaReg,fcal2aEtaBreakPts,fcal2aEtaBins);
+  
+  const int fcal2aNPhiReg = 32;
+  double fcal2aPhiBreakPts[fcal2aNPhiReg+1]=
+    {-M_PI,(-62.0/64)*M_PI,(-59.0/64)*M_PI,(-55.0/64)*M_PI,(-52.0/64)*M_PI,(-50.0/64)*M_PI,(-48.0/64)*M_PI,
+     (-45.0/64)*M_PI,(-41.0/64)*M_PI,(-38.0/64)*M_PI,(-22.0/64)*M_PI,(-18.0/64)*M_PI,(-12.0/64)*M_PI,
+     (-8.0/64)*M_PI,(-5.0/64)*M_PI,(-1.0/64)*M_PI,0,(2.0/64)*M_PI,(5.0/64)*M_PI,(9.0/64)*M_PI,(12.0/64)*M_PI,
+     (14.0/64)*M_PI,(16.0/64)*M_PI,(19.0/64)*M_PI,(23.0/64)*M_PI,(26.0/64)*M_PI,(42.0/64)*M_PI,(46.0/64)*M_PI,
+     (52.0/64)*M_PI,(56.0/64)*M_PI,(59.0/64)*M_PI,(63.0/64)*M_PI,M_PI};
+  int fcal2aPhiBins[fcal2aNPhiReg+1] = 
+    {1,1,1,1,1,1,1,1,1,8,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,8,1,3,1,1,1,1};
+  m_binning[FCAL2A].doPhiBinning(fcal2aNPhiReg,fcal2aPhiBreakPts,fcal2aPhiBins);
+  m_binning[FCAL2C]=m_binning[FCAL2A].etaMirror();
+
+  // FCAL Layer 3  (2nd layer in the code) 
+  const int fcal3aNEtaReg = 5;
+  double fcal3aEtaBreakPts[fcal3aNEtaReg+1]={3.27,3.43,3.7,3.91,4.33,4.75};
+  int fcal3aEtaBins[fcal3aNEtaReg]={2,2,1,1,2};
+  m_binning[FCAL3A].doEtaBinning(fcal3aNEtaReg,fcal3aEtaBreakPts,fcal3aEtaBins);
+  
+  const int fcal3aNPhiReg = 22;
+  double fcal3aPhiBreakPts[fcal3aNPhiReg+1]=
+    {-M_PI,(-40.0/64)*M_PI,(-39.0/64)*M_PI,(-35.0/64)*M_PI,(-29.0/64)*M_PI,(-24.0/64)*M_PI,(-22.0/64)*M_PI,
+     (-16.0/64)*M_PI,(-11.0/64)*M_PI,(-9.0/64)*M_PI,(-6.0/64)*M_PI,0,(24.0/64)*M_PI,(25.0/64)*M_PI,
+     (29.0/64)*M_PI,(35.0/64)*M_PI,(40.0/64)*M_PI,(42.0/64)*M_PI,(48.0/64)*M_PI,(53.0/64)*M_PI,(55.0/64)*M_PI,
+     (58.0/64)*M_PI,M_PI};
+  int fcal3aPhiBins[fcal3aNPhiReg+1] = {10,1,1,4,2,1,2,2,1,1,2,10,1,1,4,2,1,2,2,1,1,2};
+  m_binning[FCAL3A].doPhiBinning(fcal3aNPhiReg,fcal3aPhiBreakPts,fcal3aPhiBins);
+  m_binning[FCAL3C]=m_binning[FCAL3A].etaMirror();
+  return;
+}

Calorimeter/CaloMonitoring/src/TileCalCellMonTool.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// NAME:     TileCalCellMonTool.cxx
+#include "CaloMonitoring/TileCalCellMonTool.h"
+
+
+#include "CaloIdentifier/TileID.h"
+
+#include "AthenaMonitoring/DQBadLBFilterTool.h"
+#include "AthenaMonitoring/DQAtlasReadyFilterTool.h"
+
+#include "CaloEvent/CaloCellContainer.h"
+#include "AthenaKernel/Units.h"
+
+#include "TProfile2D.h"
+#include "TProfile.h"
+#include "TH2F.h"
+#include "TH1F.h"
+
+#include <cassert>
+
+using Athena::Units::GeV;
+
+////////////////////////////////////////////
+TileCalCellMonTool::TileCalCellMonTool(const std::string& type, const std::string& name,const IInterface* parent) 
+  :CaloMonToolBase(type, name, parent),
+   m_useElectronicNoiseOnly(false),
+   m_useTwoGaus(true),
+   m_noiseTool("CaloNoiseTool"),
+   m_tile_id(nullptr),
+   m_calo_id(nullptr){    
+  declareInterface<IMonitorToolBase>(this);
+
+  // CaloCellContainer name 
+  declareProperty("CaloCellContainer", m_cellContainerName="AllCalo","SG key of the input cell container");
+
+  // tools 
+  declareProperty("useElectronicNoiseOnly",m_useElectronicNoiseOnly=false,"Consider only electronic noise and ignore pile-up contributiuon)");
+  declareProperty("useTwoGaus", m_useTwoGaus=true,"Use double-gaussian noise description for Tile-cells");
+  declareProperty("CaloNoiseTool",m_noiseTool,"Tool Handle for noise Tool");
+
+  // min energy for tilecal cells 
+  declareProperty("energyThreshold",m_tileThreshold=300.); //Threshold in GeV
+
+}
+
+
+
+TileCalCellMonTool::~TileCalCellMonTool() {
+
+}
+
+////////////////////////////////////////////
+StatusCode TileCalCellMonTool::initialize() {
+
+  ATH_MSG_INFO("TileCalCellMonTool::initialize() start");
+
+  ATH_CHECK( detStore()->retrieve(m_tile_id) );
+
+  //Calonoise tool
+  ATH_CHECK(m_noiseTool.retrieve());
+
+
+  //Choose noise type
+  if (m_useElectronicNoiseOnly) 
+    m_noiseType = ICalorimeterNoiseTool::ELECTRONICNOISE;
+  else
+    m_noiseType=ICalorimeterNoiseTool::TOTALNOISE; 
+
+  initParam();
+
+ 
+  ATH_CHECK( ManagedMonitorToolBase::initialize() );
+  ATH_CHECK( CaloMonToolBase::initialize() );
+
+  ATH_MSG_INFO("TileCalCellMonTool::initialize() is done!");
+  return StatusCode::SUCCESS;
+}
+
+
+void TileCalCellMonTool::initParam(){
+ 
+  m_b_Ncells.reserve(3);
+  m_b_Ncells[0]=250;
+  m_b_Ncells[1]=0;
+  m_b_Ncells[2]=500;
+  
+  m_b_CellsE.reserve(3);
+  m_b_CellsE[0]=50;
+  m_b_CellsE[1]=0.;
+  m_b_CellsE[2]=20.;
+    
+  m_b_CellsEta.reserve(3);
+  m_b_CellsEta[0]=100;
+  m_b_CellsEta[1]=-5.0;
+  m_b_CellsEta[2]=5.0;
+  
+  m_b_CellsEtaTile.reserve(3);
+  m_b_CellsEtaTile[0]=17;
+  m_b_CellsEtaTile[1]=-1.7;
+  m_b_CellsEtaTile[2]=1.7;
+ 
+  m_b_CellsPhi.reserve(3);
+  m_b_CellsPhi[0]=64;
+  m_b_CellsPhi[1]=-M_PI;
+  m_b_CellsPhi[2]=M_PI;
+  
+    
+  m_b_CellsEtaPhi.reserve(6);
+  m_b_CellsEtaPhi[0]=17;
+  m_b_CellsEtaPhi[1]=-1.7;
+  m_b_CellsEtaPhi[2]=1.7;
+  m_b_CellsEtaPhi[3]=64;
+  m_b_CellsEtaPhi[4]=-M_PI;
+  m_b_CellsEtaPhi[5]=M_PI;
+    
+    
+  m_b_CellsModule.reserve(3);
+  m_b_CellsModule[0]=70;
+  m_b_CellsModule[1]=0.0;
+  m_b_CellsModule[2]=70;
+    
+  m_b_CellsTower.reserve(3);
+  m_b_CellsTower[0]=18;
+  m_b_CellsTower[1]=0.0;
+  m_b_CellsTower[2]=18;
+  
+}
+
+StatusCode TileCalCellMonTool::bookHistograms() {
+
+  MonGroup tileGroup(this,m_tilePath,run);
+
+  m_h_Ncells    = new TH1F("CellsXN","Number of tile cells",(int)m_b_Ncells[0],m_b_Ncells[1], m_b_Ncells[2]);
+  m_h_Ncells->GetXaxis()->SetTitle("Number" );
+  m_h_Ncells->GetYaxis()->SetTitle("Events");
+  tileGroup.regHist(  m_h_Ncells  ).ignore();
+
+  m_h_CellsE    = new TH1F("CellsXE","Energy of tile cells",(int)m_b_CellsE[0],m_b_CellsE[1], m_b_CellsE[2]);
+  m_h_CellsE->GetXaxis()->SetTitle("Cell Energy [GeV]");
+  m_h_CellsE->GetYaxis()->SetTitle("Events");
+  tileGroup.regHist(  m_h_CellsE  ).ignore();
+
+  m_h_CellsNoiseE    = new TH1F("CellsNoiseTile","Energy/Noise(DB) of TileCal",200, -10., 10.);
+  m_h_CellsNoiseE->GetXaxis()->SetTitle("Cell Energy / sigma (DB)");
+  m_h_CellsNoiseE->GetYaxis()->SetTitle("Events");
+  tileGroup.regHist(  m_h_CellsNoiseE  ).ignore();
+ 
+  m_h_CellsEta    = new TProfile("CellsXEta","Tile cell energy vs Eta",(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2]);
+  m_h_CellsEta->GetXaxis()->SetTitle("Eta");
+  m_h_CellsEta->GetYaxis()->SetTitle("Mean energy [GeV]");
+  tileGroup.regHist(  m_h_CellsEta  ).ignore();
+  
+
+  m_h_CellsEtaPhi    = new TH2F("CellsXEtaVSPhi","Nr TileCal cells above threshold",(int)m_b_CellsEtaPhi[0],m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
+                                (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
+  m_h_CellsEtaPhi->GetXaxis()->SetTitle("Eta");
+  m_h_CellsEtaPhi->GetYaxis()->SetTitle("Phi [rad]");
+  m_h_CellsEtaPhi->GetXaxis()->SetNdivisions(530); 
+  m_h_CellsEtaPhi->GetYaxis()->SetNdivisions(530);
+  tileGroup.regHist(  m_h_CellsEtaPhi   ).ignore();
+
+
+  m_h_CellsPhi    = new TProfile("CellsXPhi","Tile cell energy vs Phi",(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2]);
+  m_h_CellsPhi->GetXaxis()->SetTitle("Phi");
+  m_h_CellsPhi->GetYaxis()->SetTitle("Mean energy [GeV]");
+  tileGroup.regHist(  m_h_CellsPhi   ).ignore();
+
+  m_h_CellsModuleS1    = new TProfile("CellsXModuleS1","Sampling Nr 1",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
+  m_h_CellsModuleS1->GetXaxis()->SetTitle("Module");
+  m_h_CellsModuleS1->GetYaxis()->SetTitle("Mean cell energy [GeV]");
+  tileGroup.regHist(  m_h_CellsModuleS1   ).ignore();
+
+  m_h_CellsModuleS2    = new TProfile("CellsXModuleS2","Sampling Nr 2",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
+  m_h_CellsModuleS2->GetXaxis()->SetTitle("Module");
+  m_h_CellsModuleS2->GetYaxis()->SetTitle("Mean cell energy [GeV]");
+  tileGroup.regHist(  m_h_CellsModuleS2   ).ignore();
+
+  m_h_CellsModuleS3    = new TProfile("CellsXModuleS3","Sampling Nr 3",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
+  m_h_CellsModuleS3->GetXaxis()->SetTitle("Module");
+  m_h_CellsModuleS3->GetYaxis()->SetTitle("Mean cell energy [GeV]");
+  tileGroup.regHist(  m_h_CellsModuleS3   ).ignore();
+
+
+  m_h_CellsModuleS4    = new TProfile("CellsXModuleS4","Sampling Nr 4",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
+  m_h_CellsModuleS4->GetXaxis()->SetTitle("Module");
+  m_h_CellsModuleS4->GetYaxis()->SetTitle("Mean cell energy [GeV]");
+  tileGroup.regHist(  m_h_CellsModuleS4   ).ignore();
+
+  m_h_CellsTower    = new TProfile("CellsXTower","Towers",(int)m_b_CellsTower[0],m_b_CellsTower[1], m_b_CellsTower[2]);
+  m_h_CellsTower->GetXaxis()->SetTitle("Towers");
+  m_h_CellsTower->GetYaxis()->SetTitle("Mean cell energy [GeV]");
+  tileGroup.regHist(  m_h_CellsTower   ).ignore();
+
+
+  // tilecal
+  m_h_CellsNoiseEta    = new TProfile("CellsNoiseXEta","Tile cell sigma(DB) vs Eta",(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2]);
+  m_h_CellsNoiseEta->GetXaxis()->SetTitle("Eta");
+  m_h_CellsNoiseEta->GetYaxis()->SetTitle("Mean cell noise (DB) [MeV]");
+  tileGroup.regHist(  m_h_CellsNoiseEta  ).ignore();
+
+  m_h_CellsNoisePhi    = new TProfile("CellsNoiseXPhi","Tile cell sigma(DB) vs Phi",(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2]);
+  m_h_CellsNoisePhi->GetXaxis()->SetTitle("Phi");
+  m_h_CellsNoisePhi->GetYaxis()->SetTitle("Mean cell noise (DB) [MeV]");
+  tileGroup.regHist(  m_h_CellsNoisePhi   ).ignore();
+
+  m_h_CellsNoiseEtaPhi    = new TH2F("CellsNoiseXEtaVSPhi","Nr of TileCells with E.gt.4 sigma(DB)",(int)m_b_CellsEtaPhi[0],m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
+                                     (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
+  m_h_CellsNoiseEtaPhi->GetXaxis()->SetTitle("Eta");
+  m_h_CellsNoiseEtaPhi->GetYaxis()->SetTitle("Phi [rad]");
+  m_h_CellsNoiseEtaPhi->GetXaxis()->SetNdivisions(530);
+  m_h_CellsNoiseEtaPhi->GetYaxis()->SetNdivisions(530);
+  tileGroup.regHist(  m_h_CellsNoiseEtaPhi   ).ignore();
+
+
+  m_h_CellsNoiseEtaPhiA    = new TH2F("CellsNoiseXEtaVSPhiAcells","Nr of Tile cells-A with E.gt.4 sigma(DB)",(int)(2*m_b_CellsEtaPhi[0]),m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
+				      (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
+  m_h_CellsNoiseEtaPhiA->GetXaxis()->SetTitle("Eta");
+  m_h_CellsNoiseEtaPhiA->GetYaxis()->SetTitle("Phi [rad]");
+  m_h_CellsNoiseEtaPhiA->GetXaxis()->SetNdivisions(530);
+  m_h_CellsNoiseEtaPhiA->GetYaxis()->SetNdivisions(530);
+  tileGroup.regHist(  m_h_CellsNoiseEtaPhiA   ).ignore();
+
+
+  m_h_CellsNoiseEtaPhiBC    = new TH2F("CellsNoiseXEtaVSPhiBCcells","Nr of TileCells-BC with E.gt.4 sigma(DB)",(int)(2*m_b_CellsEtaPhi[0]),m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
+                                     (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
+  m_h_CellsNoiseEtaPhiBC->GetXaxis()->SetTitle("Eta");
+  m_h_CellsNoiseEtaPhiBC->GetYaxis()->SetTitle("Phi [rad]");
+  m_h_CellsNoiseEtaPhiBC->GetXaxis()->SetNdivisions(530);
+  m_h_CellsNoiseEtaPhiBC->GetYaxis()->SetNdivisions(530);
+  tileGroup.regHist(  m_h_CellsNoiseEtaPhiBC   ).ignore();
+
+
+  m_h_CellsNoiseEtaPhiD    = new TH2F("CellsNoiseXEtaVSPhiDcells","Nr of TileCells-D with E.gt.4 sigma(DB)",(int)m_b_CellsEtaPhi[0],m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
+                                     (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
+  m_h_CellsNoiseEtaPhiD->GetXaxis()->SetTitle("Eta");
+  m_h_CellsNoiseEtaPhiD->GetYaxis()->SetTitle("Phi [rad]");
+  m_h_CellsNoiseEtaPhiD->GetXaxis()->SetNdivisions(530);
+  m_h_CellsNoiseEtaPhiD->GetYaxis()->SetNdivisions(530);
+  tileGroup.regHist(  m_h_CellsNoiseEtaPhiD   ).ignore();
+
+  // cell E vs Eta and Phi. Errors show RMS (not error on the mean) 
+  m_h_CellsRMSEta    = new TProfile("CellsRMSXEta","Tile cell energy with RMS errors for Eta",(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2],"s");
+  m_h_CellsRMSEta->GetXaxis()->SetTitle("Eta");
+  m_h_CellsRMSEta->GetYaxis()->SetTitle("Mean cell energy+RMS [GeV]");
+  tileGroup.regHist(  m_h_CellsRMSEta  ).ignore();
+
+  m_h_CellsRMSPhi    = new TProfile("CellsRMSXPhi","Tile cell energy with RMS errors vs Phi",(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2],"s");
+  m_h_CellsRMSPhi->GetXaxis()->SetTitle("Phi");
+  m_h_CellsRMSPhi->GetYaxis()->SetTitle("Mean cell energy+RMS [GeV]");
+  tileGroup.regHist(  m_h_CellsRMSPhi   ).ignore();
+
+
+  char name[256];
+  char title[256];
+  sprintf(name,"%s_%s",(char*)m_h_CellsRMSEta->GetName(),"divNoiseDB");
+  sprintf(title,"%s - %s",(char*)m_h_CellsRMSEta->GetTitle(),"divNoiseDB");
+  m_h_CellsRMSdivDBnoiseEta = new TH1F(name,title,(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2]);
+  m_h_CellsRMSdivDBnoiseEta->SetNameTitle(name,title);
+  m_h_CellsRMSdivDBnoiseEta ->GetXaxis()->SetTitle("Eta");
+  m_h_CellsRMSdivDBnoiseEta ->GetYaxis()->SetTitle("Energy cell RMS / Cell noise (DB)");
+  tileGroup.regHist(  m_h_CellsRMSdivDBnoiseEta  ).ignore();
+
+  sprintf(name,"%s_%s",(char*)m_h_CellsRMSPhi->GetName(),"divNoiseDB");
+  sprintf(title,"%s - %s",(char*)m_h_CellsRMSPhi->GetTitle(),"divNoiseDB");
+  m_h_CellsRMSdivDBnoisePhi = new TH1F(name,title,(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2]);
+  m_h_CellsRMSdivDBnoisePhi->SetNameTitle(name,title);
+  m_h_CellsRMSdivDBnoisePhi ->GetXaxis()->SetTitle("Phi");
+  m_h_CellsRMSdivDBnoisePhi ->GetYaxis()->SetTitle("Energy cell RMS / Cell noise (DB)");
+  tileGroup.regHist(  m_h_CellsRMSdivDBnoisePhi  ).ignore();
+
+  m_h_CellsNoiseHash    = new TH1F("CellsXNoiseXHash","Number of 4 sigma seeds per hash",5184,-0.5, 5183.5);
+  m_h_CellsNoiseHash->GetXaxis()->SetTitle("HashId" );
+  m_h_CellsNoiseHash->GetYaxis()->SetTitle("Events");
+  tileGroup.regHist(  m_h_CellsNoiseHash  ).ignore();
+
+  //    ATH_MSG_INFO("end of bookTileHists()");
+
+
+  MonGroup summaryGroup(this,m_tilePath+"/Summary",run);
+  ATH_CHECK(bookBaseHists(&summaryGroup)); //from base class
+  return StatusCode::SUCCESS;
+}
+ 
+////////////////////////////////////////////////////////////////////////////
+StatusCode TileCalCellMonTool::fillHistograms(){  
+
+//  ATH_MSG_INFO("TileCalCellMonTool::fillHistograms() starts");
+  StatusCode sc = StatusCode::SUCCESS;
+
+  bool ifPass = 1;
+  sc = checkFilters(ifPass);
+  if(sc.isFailure() || !ifPass) return StatusCode::SUCCESS;
+
+
+  //=====================
+  // CaloCell info
+  //============================
+
+  const CaloCellContainer* cellCont = nullptr;
+  sc=evtStore()->retrieve(cellCont, m_cellContainerName);
+  if( sc.isFailure()  ||  !cellCont ) {
+    ATH_MSG_WARNING("No CaloCell container found in TDS"); 
+    return sc;
+  }  
+
+
+  CaloCellContainer::const_iterator it = cellCont->beginConstCalo(CaloCell_ID::TILE);
+  CaloCellContainer::const_iterator it_e = cellCont->endConstCalo(CaloCell_ID::TILE);
+  // loop over cells -------------
+  unsigned ncells=0;
+  for ( ; it!=it_e;++it) { 
+    // cell info
+    const CaloCell* cell = *it; 
+    Identifier id = cell->ID();
+    IdentifierHash hash = m_tile_id->cell_hash(id);
+    long sample=m_tile_id->sample(id);
+    long module=m_tile_id->module(id);
+    long tower=m_tile_id->tower(id);
+    int side=m_tile_id->side(id); 
+    float cellen = cell->energy();
+    float cellenGeV=cellen/GeV;
+    double eta = cell->eta();
+    double phi = cell->phi();
+    bool   badc=cell->badcell();
+    float cellnoisedb = 0.;
+
+
+    if (m_useTwoGaus==false)
+      cellnoisedb = m_noiseTool->getNoise(cell,m_noiseType);
+    else
+      cellnoisedb = m_noiseTool->getEffectiveSigma(cell,ICalorimeterNoiseTool::MAXSYMMETRYHANDLING,m_noiseType);
+
+    double rs=999;
+    if (std::isfinite(cellnoisedb) && cellnoisedb > 0 &&  cellen != 0 && badc == false) rs= cellen / cellnoisedb;
+
+    if (sample < 3) { // Sample E not relevant for topoclusters
+      if (badc == false && rs != 999 ) m_h_CellsNoiseE->Fill( rs );
+      if (fabs(rs)>4.0 && badc == false && rs != 999 ) {
+	m_h_CellsNoiseEtaPhi->Fill( eta, phi);
+	m_h_CellsNoiseHash->Fill(hash);
+	if (sample ==0 ) m_h_CellsNoiseEtaPhiA->Fill(  eta, phi  );
+	else if (sample ==1 ) m_h_CellsNoiseEtaPhiBC->Fill(  eta, phi );
+	else  m_h_CellsNoiseEtaPhiD->Fill(  eta, phi  );
+
+	ATH_MSG_DEBUG( "TileCalCellMonTool: Cell rs=" << rs << " e=" << cellen << " eta=" << eta << " phi="<< phi  );
+	ATH_MSG_DEBUG( "TileCalCellMonTool: hash=" << hash << " module= " << module+1 << " sample=" << sample
+		       << " tower=" << side*tower );
+      }// end of if (fabs(rs)>4.0 && badc == false && rs != 999 )
+
+      if ( badc == false) {
+	m_h_CellsNoiseEta->Fill(  eta, cellnoisedb, 1.0  );
+	m_h_CellsNoisePhi->Fill(  phi, cellnoisedb, 1.0  );
+	m_h_CellsRMSEta->Fill(  eta, cellenGeV, 1.0  );
+	m_h_CellsRMSPhi->Fill(  phi, cellenGeV, 1.0  );
+      }
+    } // end of if (sample < 3)
+
+    if (cellen > m_tileThreshold) {
+      ncells++;
+      m_h_CellsE->Fill(   cellenGeV  );
+      m_h_CellsEta->Fill(  eta, cellenGeV, 1.0  );
+      m_h_CellsPhi->Fill(  phi, cellenGeV, 1.0  );
+      if (sample ==0 ) m_h_CellsModuleS1->Fill(  module+1, cellenGeV  );
+      if (sample ==1 ) m_h_CellsModuleS2->Fill(  module+1, cellenGeV  );
+      if (sample ==2 ) m_h_CellsModuleS3->Fill(  module+1, cellenGeV  );
+      if (sample ==3 ) m_h_CellsModuleS4->Fill(  module+1, cellenGeV  );
+      m_h_CellsTower->Fill(  tower+1, cellenGeV  );
+      m_h_CellsEtaPhi->Fill( eta, phi );
+    } //end if cell energy above threshold  
+  } // end of it loop 
+  m_h_Ncells->Fill( (float) ncells ); // count TileCal cells above threshold
+  
+  return StatusCode::SUCCESS;
+}
+
+StatusCode TileCalCellMonTool::procHistograms() {
+  getRMSdevNoise(m_h_CellsRMSEta,m_h_CellsNoiseEta,m_h_CellsRMSdivDBnoiseEta);
+  getRMSdevNoise(m_h_CellsRMSPhi,m_h_CellsNoisePhi,m_h_CellsRMSdivDBnoisePhi);
+  return StatusCode::SUCCESS;
+}
+
+////////////////////////////////////////////////////////////
+// helpers for process histograms 
+
+
+/* The aim of this function is calculate RMS/NoiseDB histogram from 2 profile
+ *  histograms. 
+ */ 
+void TileCalCellMonTool::getRMSdevNoise(TProfile *t1, TProfile *t2, TH1F *t3) { 
+  // t1 histogram with RMS as errors
+  // t2 histogram with noise DB
+  // resulting histogram 
+
+  //Check if the histograms are actually defined, if not, return:
+  if( (!t1) || (!t2) || (!t3) ) {
+    return;
+  }
+
+  int nb=t1->GetNbinsX();
+  for(int ix=1;ix<nb+1;ix++){
+    Double_t ierr1=(t1->GetBinError(ix))*1000; // convert to MeV 
+    Double_t ent = t1->GetBinEntries(ix);
+    Double_t ierr2=t2->GetBinError(ix);
+    Double_t ienn2=t2->GetBinContent(ix);
+    double Rat=0.0;
+    if (ienn2>0) Rat=ierr1/ienn2; // ratio: RMS/noiseDB  
+    double er1=0;
+    if (ent>0) er1=ierr1/sqrt(ent); // error on RMS 
+    double er2=0;
+    if (ienn2>0) er2=ierr2/ienn2;
+    double Err=Rat*sqrt( (er1*er1) + (er2*er2) );
+    t3->SetBinContent(ix,Rat);
+    t3->SetBinError(ix,Err);
+  }
+  t3->SetEntries( nb );
+  t3->SetStats(0);
+}
+ 

Calorimeter/CaloMonitoring/src/components/CaloMonitoring_entries.cxx

-#include "CaloMonitoring/CaloCellVecMon.h"
+#include "GaudiKernel/DeclareFactoryEntries.h"
+
+#include "CaloMonitoring/LArCellMonTool.h"
+#include "CaloMonitoring/TileCalCellMonTool.h"
 #include "CaloMonitoring/CaloClusterVecMon.h"
-#include "CaloMonitoring/CaloBaselineMon.h"
 #include "CaloMonitoring/CaloTowerVecMon.h"
-#include "GaudiKernel/DeclareFactoryEntries.h"
 #include "CaloMonitoring/CaloTransverseBalanceVecMon.h"
-DECLARE_TOOL_FACTORY(CaloCellVecMon)
+#include "CaloMonitoring/CaloBaselineMon.h"
+
+DECLARE_TOOL_FACTORY(TileCalCellMonTool)
+DECLARE_TOOL_FACTORY(LArCellMonTool)
 DECLARE_TOOL_FACTORY(CaloClusterVecMon)
-DECLARE_TOOL_FACTORY(CaloBaselineMon)
 DECLARE_TOOL_FACTORY(CaloTowerVecMon)
 DECLARE_TOOL_FACTORY(CaloTransverseBalanceVecMon)
+DECLARE_TOOL_FACTORY(CaloBaselineMon)
 
-DECLARE_FACTORY_ENTRIES(CaloMonitoring) {
-  DECLARE_ALGTOOL(CaloCellVecMon)
-  DECLARE_ALGTOOL(CaloClusterVecMon)
-  DECLARE_ALGTOOL(CaloBaselineMon)
-  DECLARE_ALGTOOL(CaloTowerVecMon)
-  DECLARE_ALGTOOL(CaloTransverseBalanceVecMon)
-}

Control/AthenaServices/src/MetaDataSvc.cxx

@@ -393,6 +393,7 @@ StatusCode MetaDataSvc::addProxyToInputMetaDataStore(const std::string& tokenStr
             m_incSvc->removeListener(cfSvc.get(), IncidentType::BeginInputFile);
             m_incSvc->removeListener(cfSvc.get(), IncidentType::EndInputFile);
             m_incSvc->removeListener(cfSvc.get(), IncidentType::EndRun);
+            m_incSvc->removeListener(cfSvc.get(), "MetaDataStop");
             m_incSvc->removeListener(cfSvc.get(), "StoreCleared");
             cfSvc.release().ignore();
          }

DataQuality/DataQualityConfigurations/config/HLT/HLTglobal/collisions_run.config

@@ -56,62 +56,56 @@ dir HLT {
        output = HLT/TRHLT
        
        hist ConfigConsistency_HLT {
-##	 regex = 1
-##	 algorithm = HLT_PassInput
          algorithm = HLT_Histogram_Empty
-##       algorithm = HLT_Histogram_Not_Empty&GatherData
-##	 reference = CentrallyManagedReferences
          description = All bins should be empty. If any bin is filled, inform the Trigger ONLINE Expert IMMEDIATELY. 
        }
 
        hist HLTResultHLT { 
-##	 regex = 1
-##	 algorithm = HLT_PassInput
 	 algorithm = HLT_Histogram_Not_Empty&GatherData
-##	 reference = CentrallyManagedReferences
        }
 
        hist L1Events { 
          algorithm = HLT_Histogram_Not_Empty&GatherData
-##	 reference = CentrallyManagedReferences
        }
 
 		
        dir AllChains {
  	output = HLT/TRHLT/AllChains
-        hist HLT.*P[ST] {
+        hist HLT_AllChainsPS {
+	  regex = 1
+          algorithm = HLT_Histogram_Not_Empty&GatherData
+	}
+        hist HLT_AllChainsPT {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist HLT_AllChainsRAW {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist AllChainsRoIs {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
           description = Histogram should not be empty. If it is, contact the Trigger Offline Expert on-call. 
 	}
        }
 
        dir Electrons {
  	output = HLT/TRHLT/Electrons
-        hist HLT.*P[ST] {
+        hist HLT_ElectronsPS {
+	  regex = 1
+          algorithm = HLT_Histogram_Not_Empty&GatherData
+	}
+        hist HLT_ElectronsPT {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist HLT_ElectronsRAW {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist ElectronsRoIs {
 	  regex = 1
-##	  algorithm = HLT_PassInput
 	  algorithm = HLT_Histogram_Not_Empty&GatherData
           description = Histogram should not be empty. If it is, contact the Trigger Offline Expert and the Egamma Expert on-call. 
 	}
@@ -120,19 +114,20 @@ dir HLT {
        dir Gamma {
  	output = HLT/TRHLT/Gamma
         
-	hist HLT.*P[ST] {
+	hist HLT_GammaPS {
+	  regex = 1
+          algorithm = HLT_Histogram_Not_Empty&GatherData
+	}
+	hist HLT_GammaPT {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist HLT_GammaRAW {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist GammaRoIs {
 	  regex = 1
-##	  algorithm = HLT_PassInput
 	  algorithm = HLT_Histogram_Not_Empty&GatherData
           description = Histogram should not be empty. If it is, contact the Trigger Offline Expert and the Egamma Expert on-call. 
 	}
@@ -140,20 +135,21 @@ dir HLT {
 
        dir Jets {
  	output = HLT/TRHLT/Jets
-        hist HLT.*P[ST] {
+        hist HLT_JetsPS {
+	  regex = 1
+          algorithm = HLT_Histogram_Not_Empty&GatherData
+	}
+        hist HLT_JetsPT {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist HLT_JetsRAW {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 ##	hist JetsRoIs {
 ##	  regex = 1
 ##          algorithm = HLT_Histogram_Not_Empty&GatherData
-####	  algorithm = HLT_PassInput
 ##          description = Histogram should not be empty. If it is, contact the Trigger Offline Expert and the Jet/MET Expert on-call. 
 ##	}
        }
@@ -176,15 +172,17 @@ dir HLT {
 
        dir MissingET {
  	output = HLT/TRHLT/MissingET
-        hist HLT.*P[ST] {
+        hist HLT_MissingETPT {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
+##        hist HLT_MissingETPS { ##Histo broken, known issue, masked for now.
+##	  regex = 1
+##          algorithm = HLT_Histogram_Not_Empty&GatherData
+##	}
 	hist HLT_MissingETRAW {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 ##	hist MissingETRoIs {
 ##	  regex = 1
@@ -195,19 +193,20 @@ dir HLT {
        dir Muons {
  	output = HLT/TRHLT/Muons
 
-	hist HLT.*P[ST] {
+	hist HLT_MuonsPS {
+	  regex = 1
+          algorithm = HLT_Histogram_Not_Empty&GatherData
+	}
+	hist HLT_MuonsPT {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist HLT_MuonsRAW {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist MuonsRoIs {
 	  regex = 1
-##	  algorithm = HLT_PassInput
 	  algorithm = HLT_Histogram_Not_Empty&GatherData
           description = Histogram should not be empty. If it is, contact the Trigger Offline Expert and the Muon Expert on-call. 
 	}
@@ -215,20 +214,21 @@ dir HLT {
 
        dir Taus {
  	output = HLT/TRHLT/Taus
-        hist HLT.*P[ST] {
+        hist HLT_TausPS {
+	  regex = 1
+          algorithm = HLT_Histogram_Not_Empty&GatherData
+	}
+        hist HLT_TausPT {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist HLT_TausRAW {
 	  regex = 1
           algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
 	}
 	hist TausRoIs {
 	  regex = 1
 	  algorithm = HLT_Histogram_Not_Empty&GatherData
-##	  algorithm = HLT_PassInput
           description = Histogram should not be empty. If it is, contact the Trigger Offline Expert and the Tau Expert on-call. 
 	}
        }
@@ -253,9 +253,6 @@ algorithm HLT_Histogram_Not_Empty&GatherData {
 
 algorithm HLT_Histogram_Not_Empty_with_Ref&GatherData {
   name = HLT_Histogram_Not_Empty&GatherData
-  #reference = HLT_local_reference
-  #reference = CentrallyManagedReferences
-  #reference = CentrallyManagedReferences_Trigger 
   reference = stream=physics_Main:CentrallyManagedReferences_TriggerMain;CentrallyManagedReferences_Trigger
 }