TRTDigCondBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRT_DIGITIZATION_TRTDIGCONDBASE_H
#define TRT_DIGITIZATION_TRTDIGCONDBASE_H
 
#include "AthenaBaseComps/AthMessaging.h"
#include "CxxUtils/checker_macros.h"
#include "TRT_ConditionsServices/ITRT_StrawStatusSummaryTool.h" // added by Sasha for Argon
 
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
 
 
#include <atomic>
#include <map>
#include <mutex>
 
class TRT_ID;
class Identifier;
 
namespace CLHEP{
  class HepRandomEngine;
}
 
namespace InDetDD {
  class TRT_DetectorManager;
}
class TRTDigSettings;
class TRTDigCondBase : public AthMessaging {
 
public:

  TRTDigCondBase( const TRTDigSettings*,
                  const InDetDD::TRT_DetectorManager*,
                  const TRT_ID*,
                  int UseGasMix,
                  ToolHandle<ITRT_StrawStatusSummaryTool> sumTool
                  );

  virtual ~TRTDigCondBase() {};

  void initialize(CLHEP::HepRandomEngine* rndmEngine);

  float strawAverageNoiseLevel() const;         //[first time slow, else fast]

  unsigned int totalNumberOfActiveStraws() const; //[fast]

  void getStrawData( const int& hitID,
                     double& lowthreshold,
                     double& noiseamplitude ) const;
 
  //--- For noise in unhit straws:

  void resetGetNextNoisyStraw();

  bool getNextNoisyStraw( CLHEP::HepRandomEngine*, int& hitID, float& noiselevel );
 
 
  //Crosstalk noise
  bool crossTalkNoise( CLHEP::HepRandomEngine* ) const;
  bool crossTalkNoiseOtherEnd( CLHEP::HepRandomEngine* ) const;
 
  //--- For looping over all straws (only to be used at initialization):

  void resetGetNextStraw();

  bool getNextStraw( int& hitID, float& noiselevel, float& noiseamp );

  void setRefinedStrawParameters( int hitID,
                                  double lowthreshold,
                                  double noiseamplitude );
 
protected:

  virtual void setStrawStateInfo(Identifier& TRT_Identifier,
                                 double strawlength,
                                 double& noiselevel,
                                 double& relative_noiseamplitude,
                                 CLHEP::HepRandomEngine *rndmEngine) = 0;
 
protected:
  const TRTDigSettings* m_settings{};
  const InDetDD::TRT_DetectorManager* m_detmgr{};
  const TRT_ID* m_id_helper{};
 
private:
  struct StrawState {
    float noiselevel{};     
    float noiseamplitude{}; 
    float lowthreshold{};   
  };
 
  //--- Data maps:

  // StrawState is struct with members:
  // 1) noiselevel      - the same for Xenon/Argon straws
  // 2) noiseamplitude  - the same for Xenon/Argon straws
  // 3) lowthreshold    - different for Xenon and Argon straws
  // for more info see info for setStrawStateInfo function, 28 lines above!
 
  std::map<int,StrawState> m_hitid_to_StrawState;  //<--------- 7MB!!!!
 
  //--- iterators:

  std::map<int,StrawState>::const_iterator m_it_hitid_to_StrawState{};
  std::map<int,StrawState>::const_iterator m_it_hitid_to_StrawState_End{};
  mutable std::map<int,StrawState>::const_iterator m_it_hitid_to_StrawState_Last ATLAS_THREAD_SAFE {}; // Guarded by m_mutex
  mutable std::mutex m_mutex;
 
  mutable std::atomic<float> m_averageNoiseLevel{}; 
  double m_crosstalk_noiselevel{};
  double m_crosstalk_noiselevel_other_end{};
 
  //---  For iterating through all of the straw hitids:
  std::map<int,StrawState>::iterator m_all_it_hitid_to_StrawState{};
  std::map<int,StrawState>::iterator m_all_it_hitid_to_StrawState_previous{};
 
protected:
  int m_UseGasMix{};
  ToolHandle<ITRT_StrawStatusSummaryTool> m_sumTool; // added by Sasha for Argon
 
};

 
//___________________________________________________________________________
inline void TRTDigCondBase::getStrawData( const int& hitID,
                                          double& lowthreshold,
                                          double& noiseamplitude ) const {
  //fixme: do we actually benefit from this caching?
  std::lock_guard<std::mutex> lock(m_mutex);
  if (m_it_hitid_to_StrawState_Last->first != hitID)
    m_it_hitid_to_StrawState_Last = m_hitid_to_StrawState.find(hitID);
 
  lowthreshold   = m_it_hitid_to_StrawState_Last->second.lowthreshold;
  noiseamplitude = m_it_hitid_to_StrawState_Last->second.noiseamplitude;
}
 
//___________________________________________________________________________
inline unsigned int TRTDigCondBase::totalNumberOfActiveStraws() const {
  return m_hitid_to_StrawState.size();
}
 
//___________________________________________________________________________
inline void TRTDigCondBase::resetGetNextStraw() {
  m_all_it_hitid_to_StrawState = m_hitid_to_StrawState.begin() ;
}
 
//___________________________________________________________________________
inline bool TRTDigCondBase::getNextStraw( int& hitID,
                                          float& noiselevel,
                                          float& noiseamp ) {
  m_all_it_hitid_to_StrawState_previous = m_all_it_hitid_to_StrawState;
  if ( ++m_all_it_hitid_to_StrawState == m_it_hitid_to_StrawState_End) {
    hitID      = 0;
    noiselevel = 0.;
    return false;
  } else {
    hitID      = m_all_it_hitid_to_StrawState->first;
    noiselevel = m_all_it_hitid_to_StrawState->second.noiselevel;
    noiseamp   = m_all_it_hitid_to_StrawState->second.noiseamplitude;
    return true;
  };
}
 
//___________________________________________________________________________
inline void TRTDigCondBase::setRefinedStrawParameters( int hitID,
                                                       double lowthreshold,
                                                       double noiseamplitude ) {
  //we might have the iterator cached already (fixme... nah)
  if (hitID == m_all_it_hitid_to_StrawState_previous->first) {
    m_all_it_hitid_to_StrawState_previous->second.lowthreshold = lowthreshold;
    m_all_it_hitid_to_StrawState_previous->second.noiseamplitude =
      noiseamplitude;
  } else {
    m_all_it_hitid_to_StrawState_previous = m_hitid_to_StrawState.find(hitID);
    m_hitid_to_StrawState.find(hitID)->second.lowthreshold = lowthreshold;
    m_hitid_to_StrawState.find(hitID)->second.noiseamplitude = noiseamplitude;
  };
}
 
#endif