TileInfo.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TILECONDITIONS_TILEINFO_H
#define TILECONDITIONS_TILEINFO_H
//****************************************************************************
// Filename : TileInfo.h
// Author   : F. Merritt, Z. Wu
// Date     : May, 2002
//
// :DESCRIPTION:
//     This is the first step toward creating an interface to Tile Conditions
// Database. TileInfo should be used to return any detector-dependent
// constants or information regarding the Tile Calorimeter.
//
// HISTORY:
// Jul 2007: Major clearup and reorganization, including COOL DB access (NGO)
// 10th Oct 06: add comments on Covariance matrix addition ( F Spano')
// 08May02: Add NchannelsPerCell to return # channels belonging to each cell.
//***************************************************************************
 
#include "TileConditions/TilePulseShapes.h"
#include "TileConditions/TileWienerFilterWeights.h"
#include "TileConditions/TileCablingSvc.h"
#include "Identifier/Identifier.h"
#include "CaloIdentifier/CaloGain.h"
#include "TileIdentifier/TileRawChannelUnit.h"
#include "TileIdentifier/TileFragHash.h"
#include "AthenaKernel/CLASS_DEF.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include <vector>
#include <map>
#include <stdint.h>
#include "TMatrixD.h"
 
class TileID;
class TileTBID;
class TileHWID;
class HWIdentifier;
class TileInfoLoader;
class TileCablingService;
class IdContext;
class TileCalibDrawerFlt;
 
 
class TileInfo {
  friend class TileInfoLoader;
 
 public:
 
  typedef std::vector<const TileCalibDrawerFlt*> DrawerVecFlt;
 
  TileInfo();
  ~TileInfo();
 
 
  //==================================================================
  //==
  //== Accessor methods for simple constants
  //==
  //==================================================================

  int NchannelsPerCell(const Identifier& cell_id) const
    { return m_tileID->is_tile_gapscin(cell_id) ? 1:2; }

  int ADCmax() const {return m_ADCmax;}
  int ADCmaskValue() const {return m_ADCmaskValue;}
  int NdigitSamples() const {return m_nSamples;}
  int ItrigSample() const {return m_iTrigSample;}
 
  //==================================================================
  //==
  //== Accessor methods for pedestal noise and thresholds
  //==
  //==================================================================
 

  bool TileNoise() const {return m_tileNoise;}
  bool TileCoherNoise() const {return m_tileCoherNoise;}
  bool TileZeroSuppress() const {return m_tileZeroSuppress;}

  const TMatrixD * DecoCovariance(int ros, int drawer, int hilo) const;

  double ThresholdRawChannel(int /* gain */) const {return m_thresholdRawChannel;}

  double ThresholdDigits(int /* gain */) const {return m_thresholdDigits;}
 
 
  //==================================================================
  //==
  //== Accessor methods for TTL1 parameters
  //==
  //==================================================================

  double TTL1Calib(const Identifier& /* tt_id */) const { return m_ttL1Calib; }
  double MuRcvCalib(const Identifier& /* channel_id */) const { return m_MuRcvCalib; }
  double MuL1Calib(const Identifier& /* tt_id */) const { return m_muL1Calib; }
  double MBTSL1Calib(const Identifier& /* tt_id */) const { return m_mbtsL1Calib; }

  double TTL1NoiseSigma(const Identifier& /* tt_id */) const { return m_ttL1NoiseSigma; }
  double MuRcvNoiseSigma(const Identifier& /* channel_id */) const { return m_MuRcvNoiseSigma; }
  double MuL1NoiseSigma(const Identifier& /* tt_id */) const { return m_muL1NoiseSigma; }
  double MBTSL1NoiseSigma(const Identifier& /* tt_id */) const { return m_mbtsL1NoiseSigma; }

  double TTL1Thresh(const Identifier& /* tt_id */) const { return m_ttL1Thresh; }
  double MuRcvThresh(const Identifier& /* channel_id */) const { return m_MuRcvThresh; }
  double MuL1Thresh(const Identifier& /* tt_id */) const { return m_muL1Thresh; }
  double MBTSL1Thresh(const Identifier& /* tt_id */) const { return m_mbtsL1Thresh; }

  double TTL1Ped(const Identifier& /* tt_id */) const { return m_ttL1Ped; }
  double MuRcvPed(const Identifier& /* channel_id */) const { return m_MuRcvPed; }
  double MuL1Ped(const Identifier& /* tt_id */) const { return m_muL1Ped; }
  double MBTSL1Ped(const Identifier& /* tt_id */) const { return m_mbtsL1Ped; }

  double TTL1Max(const Identifier& /* tt_id */) const { return m_ttL1Max; }
  double MuRcvMax(const Identifier& /* channel_id */) const { return m_MuRcvMax; }
  double MuL1Max(const Identifier& /* tt_id */) const { return m_muL1Max; }
  double MBTSL1Max(const Identifier& /* tt_id */) const { return m_mbtsL1Max; }

  double TTL1CosmicsCalib(const Identifier& /* tt_id */) const { return (m_ttL1Calib * m_ttL1CosmicsGain); }
  double TTL1CosmicsNoiseSigma(const Identifier& /* tt_id */) const { return (m_ttL1NoiseSigma * m_ttL1CosmicsGain); }
  double TTL1CosmicsGain(const Identifier& /* tt_id */) const { return m_ttL1CosmicsGain; }
  double TTL1CosmicsThresh(const Identifier& /* tt_id */) const { return m_ttL1CosmicsThresh; }
  double TTL1CosmicsPed(const Identifier& /* tt_id */) const { return (m_ttL1Ped * m_ttL1CosmicsGain); }
 
  //==================================================================
  //==
  //== Accessor methods for shaping functions and paramters
  //==
  //==================================================================

  const std::vector<double>& digitsShapeHi() const {return m_digitsShapeHi;}
  const std::vector<double>& digitsShapeLo() const {return m_digitsShapeLo;}

  const std::vector<double>& digitsDerivativeHi() const {return m_digitsDerivativeHi;}
  const std::vector<double>& digitsDerivativeLo() const {return m_digitsDerivativeLo;}

  const std::vector<double>& digitsFullShapeHi() const {return m_digitsFullShapeHi;}
  const std::vector<double>& digitsFullShapeLo() const {return m_digitsFullShapeLo;}

  int digitsNBinsHi() const {return m_digitsNBinsHi;}
  int digitsNBinsLo() const {return m_digitsNBinsLo;}

  int digitsTime0BinHi() const {return m_digitsTime0BinHi;}
  int digitsTime0BinLo() const {return m_digitsTime0BinLo;}

  int digitsBinsPerXHi() const {return m_digitsBinsPerXHi;}
  int digitsBinsPerXLo() const {return m_digitsBinsPerXLo;}

  const std::vector<double>& ttl1Shape() const {return m_TTL1Shape;}
  const std::vector<double>& MuRcvShape() const {return m_MuRcvShape;}
  const std::vector<double>& MuL1Shape() const {return m_MuL1Shape;}

  const std::vector<double>& ttl1FullShape() const {return m_TTL1FullShape;}
  const std::vector<double>& MuRcvFullShape() const {return m_MuRcvFullShape;}
  const std::vector<double>& MuL1FullShape() const {return m_MuL1FullShape;}

  int ttl1NBins() const {return m_TTL1NBins;}
  int MuRcvNBins() const {return m_MuRcvNBins;}
  int MuL1NBins() const {return m_MuL1NBins;}

  int ttl1Time0Bin() const {return m_TTL1Time0Bin;}
  int MuRcvTime0Bin() const {return m_MuRcvTime0Bin;}
  int MuL1Time0Bin() const {return m_MuL1Time0Bin;}

  int ttl1BinsPerX() const {return m_TTL1BinsPerX;}
  int MuRcvBinsPerX() const {return m_MuRcvBinsPerX;}
  int MuL1BinsPerX() const {return m_MuL1BinsPerX;}

  void ttl1Shape(const int nsamp, const int itrig, const double phase,
         std::vector<double> &ttl1shape) const;
 
  void muRcvShape(const int nsamp, const int itrig, const double phase,
                 std::vector<double> &murcvshape) const;
 
 
  //==================================================================
  //==
  //== Accessor methods for external structures
  //==
  //==================================================================

  const TilePulseShapesStruct * getPulseShapes() const {return m_pulseShapes->TilePSstruct();}

  const TileWienerFilterWeightsStruct * getWienerFilterWeights() const {return m_WienerFilterWeights->TileWFstruct();}
 
  //==================================================================
  //==
  //== Temporary backwards compatible functions
  //==
  //==================================================================

  double BeamElemHitCalib(const Identifier& /* pmt_id */) const {return 1.;}

  double BeamElemChannelCalib(const HWIdentifier& /* channel_id */) const {return 1.;}

  double ttl1Phase(const int /* posneg */, const int /* ieta */, const int /* iphi */) const {return 0.;}

  float getNoiseScaleFactor(void) const;
 
 private:

  StatusCode initialize();

  IMessageSvc* msgSvc() const;
 
  const TileID*             m_tileID;
  const TileHWID*           m_tileHWID;
  const TileTBID*           m_tileTBID;
  const TileCablingService* m_cabling;
  const IdContext*          m_channel_context;
  const IdContext*          m_drawer_context;
 
  int    m_ADCmax;
  int    m_ADCmaskValue;
  int    m_nSamples;
  int    m_iTrigSample;

 
  double m_noiseScaleFactor[4];
  int m_noiseScaleIndex;
 
  bool   m_tileNoise;
  bool   m_tileCoherNoise;
  bool   m_tileZeroSuppress;
  double m_thresholdRawChannel;
  double m_thresholdDigits;
 
  double m_ttL1Calib;
  double m_ttL1NoiseSigma;
  double m_ttL1Thresh;
  double m_ttL1Ped;
  double m_ttL1Max;
 
  double m_MuRcvCalib;
  double m_MuRcvNoiseSigma;
  double m_MuRcvThresh;
  double m_MuRcvPed;
  double m_MuRcvMax;
 
  double m_muL1Calib;
  double m_muL1NoiseSigma;
  double m_muL1Thresh;
  double m_muL1Ped;
  double m_muL1Max;
 
  double m_mbtsL1Calib;
  double m_mbtsL1NoiseSigma;
  double m_mbtsL1Thresh;
  double m_mbtsL1Ped;
  double m_mbtsL1Max;
 
  double m_ttL1CosmicsGain;
  double m_ttL1CosmicsThresh;
 
  std::vector<double> m_digitsShapeHi;
  std::vector<double> m_digitsDerivativeHi;
  std::vector<double> m_digitsShapeLo;
  std::vector<double> m_digitsDerivativeLo;
  std::vector<double> m_digitsFullShapeHi;
  std::vector<double> m_digitsFullShapeLo;
  int m_digitsNBinsHi;
  int m_digitsNBinsLo;
  int m_digitsTime0BinHi;
  int m_digitsTime0BinLo;
  int m_digitsBinsPerXHi;
  int m_digitsBinsPerXLo;
 
  std::vector<double> m_TTL1Shape;
  std::vector<double> m_TTL1FullShape;
  int m_TTL1NBins;
  int m_TTL1Time0Bin;
  int m_TTL1BinsPerX;
 
  std::vector<double> m_MuRcvShape;
  std::vector<double> m_MuRcvFullShape;
  int m_MuRcvNBins;
  int m_MuRcvTime0Bin;
  int m_MuRcvBinsPerX;
 
  std::vector<double> m_MuL1Shape;
  std::vector<double> m_MuL1FullShape;
  int m_MuL1NBins;
  int m_MuL1Time0Bin;
  int m_MuL1BinsPerX;
 
  TilePulseShapes *m_pulseShapes;
 
  TileWienerFilterWeights *m_WienerFilterWeights;
 
  double m_emscaleTB[32];
  double m_mev2adcTB[32];
 
  ServiceHandle<TileCablingSvc>       m_tileCablingSvc;
 
  // Three dimensional vector of the
  // decomposed covariance matrices (partition x module x gain)
  //
  std::vector <std::vector <std::vector <TMatrixD *> > > m_decoCovaria;
 
};
 
 
CLASS_DEF (TileInfo, 2910, 0)
 
 
// inlines
inline
float TileInfo::getNoiseScaleFactor(void) const {
  return m_noiseScaleFactor[m_noiseScaleIndex];
}
 
#endif  //TILECONDITIONS_TILEINFO_H