TileCellNoiseFilter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TILERECUTILS_TILECELLNOISEFILTER_H
#define TILERECUTILS_TILECELLNOISEFILTER_H
 
// Tile includes
#include "TileConditions/ITileBadChanTool.h"
#include "TileConditions/TileEMScale.h"
#include "TileConditions/TileSampleNoise.h"
 
// Calo includes
#include "CaloIdentifier/CaloCell_ID.h"
#include "CaloInterface/ICaloCellMakerTool.h"
#include "CaloConditions/CaloNoise.h"
 
// Atlas includes
#include "AthenaBaseComps/AthAlgTool.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
 
 
// forward declarations
class TileID;
class TileHWID;
class TileCell;
class CaloCellContainer;
 
class TileCellNoiseFilter: public extends<AthAlgTool, ICaloCellMakerTool> {
 
  public:
 
    TileCellNoiseFilter(const std::string& type, const std::string& name,
        const IInterface* parent);
 
    virtual ~TileCellNoiseFilter() {};
 
    static const InterfaceID& interfaceID();
 
    StatusCode initialize() override;
    StatusCode finalize() override;
 
    virtual StatusCode process (CaloCellContainer* cellcoll,
                                const EventContext& ctx) const override;
 
  private:
 
    static const int s_maxPartition = 4; // LBA,LBC,EBA,EBC
    static const int s_maxDrawer = 64;   // # of drawers per partition
    static const int s_maxMOB = 4;       // # of motherboards per drawer
    static const int s_maxChannel = 12;  // # of channels per motherboard
 
    typedef float cmdata_t[s_maxPartition][s_maxDrawer][s_maxMOB];
 
    // set common-mode subtructed energy
    void setCMSEnergy(const TileEMScale* emScale, const cmdata_t& commonMode, TileCell *cell) const;
 
    // calculate common-mode for all the motherboards
    int calcCM(const CaloNoise* caloNoise, const TileSampleNoise* sampleNoise, const TileEMScale* emScale,
               const CaloCellContainer *cellcoll, cmdata_t& commonMode) const;
 
    // derive a value of common-mode shift
    float getCMShift(const cmdata_t& commonMode,
                     int partition, int drawer, int channel) const
    {
      return commonMode[partition][drawer][channel / s_maxChannel];
    }
 
    const TileID* m_tileID{nullptr};   
    const TileHWID* m_tileHWID{nullptr}; 
 
    SG::ReadCondHandleKey<TileEMScale> m_emScaleKey{this,
        "TileEMScale", "TileEMScale", "Input Tile EMS calibration constants"};
 
    SG::ReadCondHandleKey<TileSampleNoise> m_sampleNoiseKey{this,
        "TileSampleNoise", "TileSampleNoise", "Input Tile sample noise"};
 
    SG::ReadCondHandleKey<CaloNoise> m_caloNoiseKey{this, "CaloNoise",
                                                    "",
                                                    "CaloNoise object to read, or null to use the DB directly"};
 
    ToolHandle<ITileBadChanTool> m_tileBadChanTool{this,
        "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"};
 
    // properties
    float m_truncationThresholdOnAbsEinSigma;
    float m_minimumNumberOfTruncatedChannels;
    bool m_useTwoGaussNoise;
 
    static const CaloCell_ID::SUBCALO s_caloIndex = CaloCell_ID::TILE;
 
    float m_maxNoiseSigma;
 
};
 
#endif // TILERECUTILS_TILECELLNOISEFILTER_H