CaloNoise.h

Go to the documentation of this file.

//Dear emacs, this is -*-c++-*-
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOCONDITIONS_CALONOISE_H
#define CALOCONDITIONS_CALONOISE_H
 
#include <boost/multi_array.hpp>
#include "CaloIdentifier/CaloCell_ID.h"
#include "CaloCondBlobObjs/CaloCondUtils.h" 
#include "CaloCondBlobObjs/CaloCondBlobFlt.h"
#include "Identifier/HWIdentifier.h"
#include <memory>
 
          
class CaloNoise {
 
 public:
 
  enum NOISETYPE{ELEC=0,
         PILEUP,
         TOTAL};
 
  CaloNoise() =delete;
 
  ~CaloNoise();

  CaloNoise(const size_t nLArCells, const size_t nLArGains, const size_t nTileCells, const size_t nTileGains,
        const CaloCell_Base_ID* caloCellId, const NOISETYPE noisetype);

  float getNoise(const IdentifierHash h, const int gain) const {
    if (h<m_tileHashOffset) {
      return m_larNoise[gain][h];
    }
    else {
      const unsigned int dbGain = CaloCondUtils::getDbCaloGain(gain);
      return m_tileNoise[dbGain][h-m_tileHashOffset];
    }
  }
  
  float getNoise(const Identifier id, const int gain) const {
    IdentifierHash h=m_caloCellId->calo_cell_hash(id);
    return getNoise(h,gain);
  }
 

  float getNoise(const HWIdentifier /*hwid*/, const int /*gain*/) const = delete;
 
 
  float getEffectiveSigma(const Identifier id, const int gain, const float energy) const {
    IdentifierHash h=m_caloCellId->calo_cell_hash(id);
    return getEffectiveSigma(h,gain,energy);
  }
  
 
  float getEffectiveSigma(const IdentifierHash h, const int gain, const float energy) const {
    if (h<m_tileHashOffset) {
      return m_larNoise[gain][h];
    }
    else {
      return getTileEffSigma(h-m_tileHashOffset,gain,energy);
    }
  }

  boost::multi_array<float, 2>& larStorage() {return m_larNoise;}
  boost::multi_array<float, 2>& tileStorage() {return m_tileNoise;}

  const boost::multi_array<float, 2>& larStorage() const {return m_larNoise;}
  const boost::multi_array<float, 2>& tileStorage() const {return m_tileNoise;}
 
  
  void setTileBlob(std::unique_ptr<const CaloCondBlobFlt> flt, const float lumi);
 
  //Those are needed for the GPU data conversions.
  
  const CaloCondBlobFlt * getTileBlob() const { return m_tileBlob.get(); }
 
  float getLumi() const { return m_lumi; }
 
  NOISETYPE getNoiseType() const { return m_noiseType; }
 
 private:
  float calcSig(const IdentifierHash tilehash, const int gain, const float energy) const;
  float getTileEffSigma(const IdentifierHash subHash, const int gain, const float e) const;
 
  const CaloCell_Base_ID* m_caloCellId;
 
  //Flat structure, choosen based on profiling done by Scott in Nov 2013
  boost::multi_array<float, 2> m_larNoise;
  boost::multi_array<float, 2> m_tileNoise;
  unsigned m_tileHashOffset;
 
 
  //For double-gaussian noise:
  std::unique_ptr<const CaloCondBlobFlt> m_tileBlob; 
  float m_lumi=0;
  NOISETYPE m_noiseType=TOTAL;
};
 
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF( CaloNoise , 16721262 , 1 )
#include "AthenaKernel/CondCont.h"
CONDCONT_MIXED_DEF(CaloNoise, 51500196);
#endif