dd/d9a/TileInfo_8h_source.html

/*

  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