TRTProcessingOfStraw.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRT_DIGITIZATION_TRTPROCESSINGOFSTRAW_H
#define TRT_DIGITIZATION_TRTPROCESSINGOFSTRAW_H
 
#include "AthenaBaseComps/AthMessaging.h"
 
//Hit classes
#include "HitManagement/TimedHitCollection.h"
 
#include "InDetIdentifier/TRT_ID.h"
 
#include "InDetSimEvent/TRTUncompressedHit.h"

// MagField cache
#include "MagFieldElements/AtlasFieldCache.h"
 
#include "TRT_ConditionsServices/ITRT_CalDbTool.h"
 
#include "TRTElectronicsProcessing.h"
 
#include "GeoPrimitives/GeoPrimitives.h"
 
#include "CLHEP/Random/RandomEngine.h"
#include "AtlasCLHEP_RandomGenerators/RandBinomialFixedP.h"
 
#include <memory>
#include <vector>
 
class TRTDigit;
class TRTTimeCorrection;
class TRTNoise;
class TRTDigCondBase;
 
class TRTUncompressedHit;
class ITRT_PAITool;
class ITRT_SimDriftTimeTool;
 
namespace InDetDD {
  class TRT_DetectorManager;
  class TRT_DetElementContainer;
}
 
class TRTDigSettings;
class GenData;

class TRTProcessingOfStraw : public AthMessaging {
public:
  TRTProcessingOfStraw( const TRTDigSettings*,
                        const InDetDD::TRT_DetectorManager*,
                        ITRT_PAITool*,
                        ITRT_SimDriftTimeTool*,
                        TRTElectronicsProcessing * ep,
                        TRTNoise * noise,
                        TRTDigCondBase* digcond,
                        const TRT_ID*,
                        ITRT_PAITool* = nullptr,
                        ITRT_PAITool* = nullptr,
                        const ITRT_CalDbTool* = nullptr);
  ~TRTProcessingOfStraw();
 
  typedef TimedHitCollection<TRTUncompressedHit>::const_iterator
  hitCollConstIter;

  void ProcessStraw (MagField::AtlasFieldCache& fieldCache,
             const InDetDD::TRT_DetElementContainer* detElements,
                     hitCollConstIter i,
             hitCollConstIter e,
             TRTDigit& outdigit,
             bool & m_alreadyPrintedPDGcodeWarning,
             double m_cosmicEventPhase, //const ComTime* m_ComTime,
                     int strawGasType,
                     bool emulationArflag,
                     bool emulationKrflag,
                     CLHEP::HepRandomEngine* rndmEngine,
                     CLHEP::HepRandomEngine* elecProcRndmEngine,
                     CLHEP::HepRandomEngine* elecNoiseRndmEngine,
                     CLHEP::HepRandomEngine* paiRndmEngine );
 
private:
 
  //NB copy-constructor and assignment operator declared, but not defined.
  TRTProcessingOfStraw(const TRTProcessingOfStraw&);
  TRTProcessingOfStraw& operator= (const TRTProcessingOfStraw&);

  void Initialize(const ITRT_CalDbTool *);
 
  const TRTDigSettings* m_settings;
  const InDetDD::TRT_DetectorManager* m_detmgr;
  ITRT_PAITool* m_pPAItoolXe;
  ITRT_PAITool* m_pPAItoolAr;
  ITRT_PAITool* m_pPAItoolKr;
  ITRT_SimDriftTimeTool* m_pSimDriftTimeTool;

  bool m_timeCorrection = false;
 
  double m_signalPropagationSpeed = 0.0;
  double m_attenuationLength = 0.0;
 
  bool m_useAttenuation = false;
  bool m_useMagneticFieldMap = false;
 
  double m_maxCrossingTime = 0.0;
  double m_minCrossingTime = 0.0;
  double m_shiftOfZeroPoint = 0.0;
 
  double m_innerRadiusOfStraw = 0.0;
  double m_outerRadiusOfWire = 0.0;
 
  double m_solenoidFieldStrength = 0.0;
 
 
  TRTTimeCorrection*        m_pTimeCorrection;
  TRTElectronicsProcessing* m_pElectronicsProcessing;
  TRTNoise*                 m_pNoise;
  TRTDigCondBase*           m_pDigConditions;
 
  std::unique_ptr<GenData> m_genData;

  class cluster {
  public:
    cluster(double e, double t, double x, double y, double z) :
      energy(e), time(t), xpos(x), ypos(y), zpos(z) {};
    double energy;
    double time;
    double xpos;
    double ypos;
    double zpos;
  };
 
  std::vector<cluster> m_clusterlist;
  std::vector<TRTElectronicsProcessing::Deposit> m_depositList;

  void addClustersFromStep ( double scaledKineticEnergy,
                             double particleCharge,
                             double timeOfHit,
                             double prex,
                             double prey,
                             double prez,
                             double postx,
                             double posty,
                             double postz,
                             std::vector<cluster>& clusterlist,
                             int strawGasType,
                             CLHEP::HepRandomEngine* rndmEngine,
                             CLHEP::HepRandomEngine* paiRndmEngine);
  void ClustersToDeposits (MagField::AtlasFieldCache& fieldCache, int hitID,
               const std::vector<cluster>& clusters,
               std::vector<TRTElectronicsProcessing::Deposit>& deposits,
               const Amg::Vector3D& TRThitGlobalPos,
                           double m_cosmicEventPhase, // const ComTime* m_ComTime
                           int strawGasType,
                           CLHEP::HepRandomEngine* rndmEngine);
 
  double setClusterZ(double cluster_z_in, bool isLong, bool isShort, bool isEC) const;
 
  std::vector<double> m_drifttimes;     // electron drift times
  std::vector<double> m_expattenuation; // tabulation of exp()
  unsigned int  m_maxelectrons = 0U;         // maximum number of them (minmum is 100 for the Gaussian approx to be ok);
 
  bool m_alreadywarnedagainstpdg0;
 
  Amg::Vector3D getGlobalPosition( int hitID
                   , const TimedHitPtr<TRTUncompressedHit> *theHit
                   , const InDetDD::TRT_DetElementContainer* detElements);
 
  std::unique_ptr<CLHEP::RandBinomialFixedP> m_randBinomialXe{};
  std::unique_ptr<CLHEP::RandBinomialFixedP> m_randBinomialKr{};
  std::unique_ptr<CLHEP::RandBinomialFixedP> m_randBinomialAr{};
 
protected:
  const TRT_ID* m_id_helper;
 
};
 
#endif