TRTElectronicsProcessing.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRT_DIGITIZATION_TRTELECTRONICSPROCESSING_H
#define TRT_DIGITIZATION_TRTELECTRONICSPROCESSING_H
 
#include "AthenaBaseComps/AthMessaging.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "CLHEP/Random/RandomEngine.h"
 
#include <atomic>
#include <vector>
 
class TRTDigSettings;
class TRTDigit;
class TRTElectronicsNoise;

class TRTElectronicsProcessing : public AthMessaging {
public:
  TRTElectronicsProcessing( const TRTDigSettings* digset,
                            TRTElectronicsNoise * electronicsnoise );
  ~TRTElectronicsProcessing();

  class Deposit {
  public:
    Deposit(const double& e, const double& t): m_energy(e), m_time(t) {}
 
    double energy() const { return m_energy; } 
    double time() const { return m_time; }     
 
 
  private:
    double m_energy;  
    double m_time;    
  };

  void ProcessDeposits( const std::vector<Deposit>&,
                        const int& hitID,
                        TRTDigit& outdigit,
                        double lowthreshold,
                        const double& noiseamplitude,
                        int strawGasType,
                        CLHEP::HepRandomEngine* rndmEngine,
                        CLHEP::HepRandomEngine* elecNoiseRndmEngine,
                        double highthreshold = -1.0
                        );
 
  double getHighThreshold ( int hitID, int strawGasType );
  void LTt0Shift          ( int hitID, int strawGasType );
  void HTt0Shift          ( int hitID );
 
private:
  //NB copy-constructor and assignment operator declared, but not defined.
  TRTElectronicsProcessing(const TRTElectronicsProcessing&);
  TRTElectronicsProcessing& operator= (const TRTElectronicsProcessing&);
 
  //--- Initialization methods

  void Initialize();

  void TabulateSignalShape();
 
  //---

  void SignalShaping(int strawGasType);

  void DiscriminatorResponse(const double& lowthreshold,
                             const double& highthreshold);

  unsigned EncodeDigit() const;
 
  const TRTDigSettings* m_settings;
 
  TRTElectronicsNoise * m_pElectronicsNoise;
 
  double m_timeInterval = 0.0;       
 
  int m_totalNumberOfBins = 0;     
  int m_numberOfPreZeroBins = 0;   
  int m_numberOfPostZeroBins = 0;  
 
  double m_binWidth = 0.0;   
 
  int m_minDiscriminatorWidthInBinWidths = 0; 
  int m_discriminatorSettlingTimeInBinWidths = 0; 
  int m_discriminatorDeadTimeInBinWidths = 0;     
  int m_minWidthMinusSettlingTimeInBinWidths = 0; 
 
  // 0:Xe,1:Kr,2:Ar
  double m_lowThresholdBar[3]{};
  double m_lowThresholdEC[3]{};
  std::vector<double> m_lowThresholdSignalShape[3];
  std::vector<double> m_highThresholdSignalShape[3];
 
  // unsigned int m_maskA;   /**< mask - ever used? */
  // unsigned int m_maskB;   /**< mask - ever used? */
  // unsigned int m_maskC;   /**< mask - ever used? */
  // unsigned int m_maskHT;  /**< mask - ever used? */
 
  // Deposit energy in timed bins before shaping.
  double* m_energyDistribution = nullptr;
 
  // LT and HT signals after shaping
  std::vector<double> m_lowThresholdSignal;
  std::vector<double> m_highThresholdSignal;
 
  // LT and HT discriminated signals (bits).
  int* m_lowThresholdDiscriminator = nullptr;  
  int* m_highThresholdDiscriminator = nullptr; 
 
  mutable std::atomic<bool> m_first{true};
};
 
#endif