TRTNoise Class Reference

Simulation of noise hits in the TRT. More...

#include <TRTNoise.h>

Inheritance diagram for TRTNoise:

Collaboration diagram for TRTNoise:

Public Member Functions
	TRTNoise (const TRTDigSettings *, const InDetDD::TRT_DetectorManager *, CLHEP::HepRandomEngine *noiseRndmEngine, CLHEP::HepRandomEngine *elecNoiseRndmEngine, CLHEP::HepRandomEngine *elecProcRndmEngine, CLHEP::HepRandomEngine *elecNoiseResetRndmEngine, TRTDigCondBase *digcond, TRTElectronicsProcessing *ep, TRTElectronicsNoise *electronicsnoise, const TRT_ID *trt_id, int UseGasMix, ToolHandle< ITRT_StrawStatusSummaryTool > sumTool)
	Constructor.
void	appendPureNoiseToProperDigits (std::vector< TRTDigit > &digitVect, const std::set< int > &sim_hitids, CLHEP::HepRandomEngine *noiseRndmEngine)
	Append noise digits to list of digits from proper hits.
void	appendCrossTalkNoiseToProperDigits (std::vector< TRTDigit > &digitVect, const std::set< Identifier > &simhitsIdentifiers, const ServiceHandle< ITRT_StrawNeighbourSvc > &m_TRTStrawNeighbourSvc, CLHEP::HepRandomEngine *noiseRndmEngine)
	~TRTNoise ()
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Static Public Member Functions
static void	sortDigits (std::vector< TRTDigit > &digitVect)

Private Member Functions
void	InitThresholdsAndNoiseAmplitudes_and_ProduceNoiseDigitPool (CLHEP::HepRandomEngine *noiseRndmEngine, CLHEP::HepRandomEngine *elecNoiseRndmEngine, CLHEP::HepRandomEngine *elecProcRndmEngine)
	Initialize thresholds and noise amplitudes.
void	ProduceNoiseDigitPool (const std::vector< float > &lowthresholds, const std::vector< float > &noiseamps, const std::vector< int > &strawType, CLHEP::HepRandomEngine *noiseRndmEngine, CLHEP::HepRandomEngine *elecNoiseRndmEngine, CLHEP::HepRandomEngine *elecProcRndmEngine)
	Produce pool of pure noise digits (for simulation of noise in unhit straws) and store them in m_digitPool.
double	simulateNoiseFrequency (const unsigned int &totalNumberOfTests, const double &electronicsNoiseAmplitude, double lowthreshold=-1.0)
Identifier	getStrawIdentifier (int hitID)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static float	useLookupTable (const float &x, const std::vector< float > &y_given_x, const float &min_x, const float &max_x)
	Return y value corresponding to input x value from LUT.
static void	makeInvertedLookupTable (const std::vector< float > &y_given_x, const float &min_x, const float &max_x, std::vector< float > &x_given_y, float &min_y, float &max_y)
	Invert look-up-table: Go from tabulated y values vs.
static void	evolve_LT2AmpVsNL_to_include_LTfluct (std::vector< float > &nl_given_lt2na, const float &min_lt2na, const float &max_lt2na, const float relativeLTFluct, float &new_min_lt2na, float &new_max_lt2na, const unsigned int &number_new_bins)
	Refined noise treatment by allowing for event-by-event fluctuations in the low threshold settings.

Private Attributes
const TRTDigSettings *	m_settings {}
const InDetDD::TRT_DetectorManager *	m_detmgr {}
TRTDigCondBase *	m_pDigConditions {}
TRTElectronicsProcessing *	m_pElectronicsProcessing {}
TRTElectronicsNoise *	m_pElectronicsNoise {}
CLHEP::HepRandomEngine *	m_noise_randengine {}
const TRT_ID *	m_id_helper
unsigned int	m_digitPoolLength
	Length of noise digit pool m_digitPool.
unsigned int	m_digitPoolLength_nextaccessindex
	Pointer into noise digit pool m_digitPool.
std::vector< unsigned int >	m_digitPool
	Pool of noise digits for noise in unhit straws.
int	m_UseGasMix {}
ToolHandle< ITRT_StrawStatusSummaryTool >	m_sumTool
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Simulation of noise hits in the TRT.

For method, please see Thomas Kittelmanns thesis

Definition at line 39 of file TRTNoise.h.

Constructor & Destructor Documentation

TRTNoise()

TRTNoise::TRTNoise	(	const TRTDigSettings *	digset,
		const InDetDD::TRT_DetectorManager *	detmgr,
		CLHEP::HepRandomEngine *	noiseRndmEngine,
		CLHEP::HepRandomEngine *	elecNoiseRndmEngine,
		CLHEP::HepRandomEngine *	elecProcRndmEngine,
		CLHEP::HepRandomEngine *	elecNoiseResetRndmEngine,
		TRTDigCondBase *	digcond,
		TRTElectronicsProcessing *	ep,
		TRTElectronicsNoise *	electronicsnoise,
		const TRT_ID *	trt_id,
		int	UseGasMix,
		ToolHandle< ITRT_StrawStatusSummaryTool >	sumTool )

Constructor.

Definition at line 36 of file TRTNoise.cxx.

: AthMessaging("TRTNoise"),
  m_settings(digset),
  m_detmgr(detmgr),
  m_pDigConditions(digcond),
  m_pElectronicsProcessing(ep),
  m_pElectronicsNoise(electronicsnoise),
  m_id_helper(trt_id),
  m_digitPoolLength(5000),
  m_digitPoolLength_nextaccessindex(0),
  m_UseGasMix(UseGasMix),
  m_sumTool(std::move(sumTool))
{
  InitThresholdsAndNoiseAmplitudes_and_ProduceNoiseDigitPool(noiseRndmEngine,elecNoiseRndmEngine,elecProcRndmEngine);
  if ( m_settings->noiseInSimhits() ) m_pElectronicsNoise->reinitElectronicsNoise( 1000, elecNoiseResetRndmEngine );
}

~TRTNoise()

TRTNoise::~TRTNoise ( )

default

Member Function Documentation

appendCrossTalkNoiseToProperDigits()

void TRTNoise::appendCrossTalkNoiseToProperDigits	(	std::vector< TRTDigit > &	digitVect,
		const std::set< Identifier > &	simhitsIdentifiers,
		const ServiceHandle< ITRT_StrawNeighbourSvc > &	m_TRTStrawNeighbourSvc,
		CLHEP::HepRandomEngine *	noiseRndmEngine )

Definition at line 356 of file TRTNoise.cxx.

                                                                                         {
 
  //id helper:
  const TRTHitIdHelper* hitid_helper = TRTHitIdHelper::GetHelper();
 
  std::vector<Identifier> IdsFromChip;
  std::vector<Identifier> CrossTalkIds;
  std::vector<Identifier> CrossTalkIdsOtherEnd;
  std::set<Identifier>::const_iterator simhitsIdentifiers_end = simhitsIdentifiers.end();
  std::set<Identifier>::const_iterator simhitsIdentifiers_begin = simhitsIdentifiers.begin();
  std::set<Identifier>::iterator simhitsIdentifiersIter;
 
  for (simhitsIdentifiersIter=simhitsIdentifiers_begin; simhitsIdentifiersIter!=simhitsIdentifiers_end; ++simhitsIdentifiersIter) {
 
    TRTStrawNeighbourSvc->getStrawsFromChip(*simhitsIdentifiersIter,IdsFromChip);
    CrossTalkIds.assign(IdsFromChip.begin(),IdsFromChip.end());
 
    //for barrel only - treated exactly equally as id's on the right end
    if (!(abs(m_id_helper->barrel_ec(IdsFromChip[0]))==1)) { continue; }
 
    Identifier otherEndID = m_id_helper->straw_id((-1)*m_id_helper->barrel_ec(*simhitsIdentifiersIter),
                                                  m_id_helper->phi_module(*simhitsIdentifiersIter),
                                                  m_id_helper->layer_or_wheel(*simhitsIdentifiersIter),
                                                  m_id_helper->straw_layer(*simhitsIdentifiersIter),
                                                  m_id_helper->straw(*simhitsIdentifiersIter));
    if (otherEndID.get_compact()) { CrossTalkIdsOtherEnd.push_back(otherEndID); }
 
    for (auto & CrossTalkId : CrossTalkIds) {
 
      if ( simhitsIdentifiers.find(CrossTalkId) == simhitsIdentifiers_end )  {
        if (m_pDigConditions->crossTalkNoise(noiseRndmEngine)==1 ) {
          const int ndigit(m_digitPool[CLHEP::RandFlat::shootInt(noiseRndmEngine,
                                                                 m_digitPoolLength)]);
          int barrel_endcap, isneg;
          switch ( m_id_helper->barrel_ec(CrossTalkId) ) {
          case -1:  barrel_endcap = 0; isneg = 0; break;
          case  1:  barrel_endcap = 0; isneg = 1; break;
          default:
            ATH_MSG_WARNING("TRTDigitization::TRTNoise - identifier problems - skipping detector element!!");
            continue;
          }
          const int ringwheel(m_id_helper->layer_or_wheel(CrossTalkId));
          const int phisector(m_id_helper->phi_module(CrossTalkId));
          const int layer    (m_id_helper->straw_layer(CrossTalkId));
          const int straw    (m_id_helper->straw(CrossTalkId));
 
          //built hit id
          int hitid = hitid_helper->buildHitId( barrel_endcap, isneg, ringwheel, phisector,layer, straw);
          //add to digit vector
          digitVect.emplace_back(hitid,ndigit);
        }
      }
    }
 
    for (auto & i : CrossTalkIdsOtherEnd) {
      if ( simhitsIdentifiers.find(i) == simhitsIdentifiers_end )  {
        if (m_pDigConditions->crossTalkNoiseOtherEnd(noiseRndmEngine)==1 ) {
 
          const int ndigit(m_digitPool[CLHEP::RandFlat::shootInt(noiseRndmEngine,m_digitPoolLength)]);
 
          int barrel_endcap, isneg;
          switch ( m_id_helper->barrel_ec(i) ) {
          case -1:  barrel_endcap = 0; isneg = 0; break;
          case  1:  barrel_endcap = 0; isneg = 1; break;
          default:
            ATH_MSG_WARNING("TRTDigitization::TRTNoise - identifier problems - skipping detector element!!");
            continue;
          }
 
          const int ringwheel(m_id_helper->layer_or_wheel(i));
          const int phisector(m_id_helper->phi_module(i));
          const int layer    (m_id_helper->straw_layer(i));
          const int straw    (m_id_helper->straw(i));
 
          //built hit id
          int hitid = hitid_helper->buildHitId( barrel_endcap, isneg, ringwheel, phisector,layer, straw);
          //add to digit vector
          digitVect.emplace_back(hitid,ndigit);
        }
      }
    }
 
    IdsFromChip.resize(0);
    CrossTalkIdsOtherEnd.resize(0);
    CrossTalkIds.resize(0);
  }
}

appendPureNoiseToProperDigits()

void TRTNoise::appendPureNoiseToProperDigits	(	std::vector< TRTDigit > &	digitVect,
		const std::set< int > &	sim_hitids,
		CLHEP::HepRandomEngine *	noiseRndmEngine )

Append noise digits to list of digits from proper hits.

We are here dealing with unhit straws and noise digits are added from a pool of cached digits (m_digitPool).

Parameters

digitVect	vector of digits this event. At input, contains digits from hits. At output, noise digits have been added.
sim_hitids	list of IDs of hit straws. This to make sure we do not add noise digit to already hit straw.

Definition at line 333 of file TRTNoise.cxx.

{
 
  const std::set<int>::const_iterator sim_hitids_end(sim_hitids.end());
 
  m_pDigConditions->resetGetNextNoisyStraw();
  int hitid;
  float noiselevel;
 
  while (m_pDigConditions->getNextNoisyStraw(noiseRndmEngine,hitid,noiselevel) ) {
    //returned noiselevel not used for anything right now (fixme?).
    // If this strawID does not have a sim_hit, add a pure noise digit
    if ( sim_hitids.find(hitid) == sim_hitids_end ) {
      const int ndigit(m_digitPool[CLHEP::RandFlat::shootInt(noiseRndmEngine,m_digitPoolLength)]);
      digitVect.emplace_back(hitid,ndigit);
    }
  };
 
  digitVect.pop_back(); }

evolve_LT2AmpVsNL_to_include_LTfluct()

void TRTNoise::evolve_LT2AmpVsNL_to_include_LTfluct ( std::vector< float > & nl_given_lt2na, const float & min_lt2na, const float & max_lt2na, const float relativeLTFluct, float & new_min_lt2na, float & new_max_lt2na, const unsigned int & number_new_bins )

staticprivate

Refined noise treatment by allowing for event-by-event fluctuations in the low threshold settings.

This is done by smearing of a LUT giving noise fractions as function of LT/NA values (see TK thesis).

What this method effectively does, is to smear the x-axis in a LUT with a Gaussian with a given relative width.

Parameters

nl_given_lt2na	The (inverted) LUT of noise level vs. LT/NA values (input and output)
min_lt2na	lower LT/NA value (input)
max_lt2na	higher LT/NA value (input)
relativeLTfluct	relative event-by-event fluctuations in low threshold level (input)
new_min_lt2na	lower LT/NA value after smearing (output)
new_max_lt2na	higher LT/NA value after smearing (output)
number_new_bins	LUT is expanded to this number of bins (input)

Definition at line 539 of file TRTNoise.cxx.

{
  //RelativeLTfluct should be less than 0.2.
 
  //  unsigned int n = nl_given_lt2na.size();
  std::vector<float> new_nl_given_lt2na(number_new_bins);
  constexpr double reciprocalSqrt2Pi = M_2_SQRTPI * 0.5 * M_SQRT1_2;//cmath definitions
  new_min_lt2na = min_lt2na;
  new_max_lt2na = relativeLTFluct < 0.4 ? max_lt2na/(1.0-2.0*relativeLTFluct) : 5*max_lt2na;
 
  for (unsigned int i = 0; i<number_new_bins;++i) {
    const float new_lt2naval(new_min_lt2na + (new_max_lt2na-new_min_lt2na)*static_cast<float>(i)/(number_new_bins-1));
    float sigma = new_lt2naval*relativeLTFluct;
    if ( sigma <= 0 ) {
      if (sigma<0) { sigma *= -1.0; }
      else { sigma = 1.0e-8; }
    }
    const float lowerintrange(new_lt2naval - 5.0*sigma);
    float upperintrange(new_lt2naval + 5.0*sigma);
    if (upperintrange>max_lt2na) {
      upperintrange = max_lt2na; //Since the NL is zero above anyway
    }
    const double du((upperintrange-lowerintrange)/100.0);
    double sum(0.);
    const double minusoneover2sigmasq(- 1.0 / (2.0*sigma*sigma));
 
    for (double u(lowerintrange); u < upperintrange; u += du) {
      sum += useLookupTable(u,nl_given_lt2na,min_lt2na,max_lt2na) *
        exp(minusoneover2sigmasq * (u-new_lt2naval) * (u-new_lt2naval));
    }
    sum *= du*reciprocalSqrt2Pi /sigma;
    new_nl_given_lt2na[i] = sum;
  };
 
  nl_given_lt2na.resize(number_new_bins);
  copy(new_nl_given_lt2na.begin(),
       new_nl_given_lt2na.end(),
       nl_given_lt2na.begin());
}

getStrawIdentifier()

Identifier TRTNoise::getStrawIdentifier ( int hitID )

private

Definition at line 585 of file TRTNoise.cxx.

{
  Identifier IdStraw;
  Identifier IdLayer;
 
  const int mask(0x0000001F);
  const int word_shift(5);
  int trtID, ringID, moduleID, layerID, strawID;
  int wheelID, planeID, sectorID;
 
  const InDetDD::TRT_BarrelElement *barrelElement;
  const InDetDD::TRT_EndcapElement *endcapElement;
 
  if ( !(hitID & 0x00200000) ) {      // barrel
    strawID   = hitID & mask;
    hitID   >>= word_shift;
    layerID   = hitID & mask;
    hitID   >>= word_shift;
    moduleID  = hitID & mask;
    hitID   >>= word_shift;
    ringID    = hitID & mask;
    trtID     = hitID >> word_shift;
 
    barrelElement = m_detmgr->getBarrelElement(trtID, ringID, moduleID, layerID);
    if ( barrelElement ) {
      IdLayer = barrelElement->identify();
      IdStraw = m_id_helper->straw_id(IdLayer, strawID);
    } else {
      ATH_MSG_ERROR("Could not find detector element for barrel identifier with "
                    << "(ipos,iring,imod,ilayer,istraw) = ("
                    << trtID << ", " << ringID << ", " << moduleID << ", "
                    << layerID << ", " << strawID << ")");
    }
  } else {                           // endcap
    strawID   = hitID & mask;
    hitID   >>= word_shift;
    planeID   = hitID & mask;
    hitID   >>= word_shift;
    sectorID  = hitID & mask;
    hitID   >>= word_shift;
    wheelID   = hitID & mask;
    trtID     = hitID >> word_shift;
 
    // change trtID (which is 2/3 for endcaps) to use 0/1 in getEndcapElement
    if (trtID == 3) { trtID = 0; }
    else            { trtID = 1; }
 
    endcapElement = m_detmgr->getEndcapElement(trtID, wheelID, planeID, sectorID);
 
    if ( endcapElement ) {
      IdLayer = endcapElement->identify();
      IdStraw = m_id_helper->straw_id(IdLayer, strawID);
    } else {
      ATH_MSG_ERROR("Could not find detector element for endcap identifier with "
                    << "(ipos,iwheel,isector,iplane,istraw) = ("
                    << trtID << ", " << wheelID << ", " << sectorID << ", "
                    << planeID << ", " << strawID << ")");
      ATH_MSG_ERROR("If this happens very rarely, don't be alarmed "
                    "(it is a Geant4 'feature')");
      ATH_MSG_ERROR("If it happens a lot, you probably have misconfigured geometry "
                    "in the sim. job.");
    }
 
  }
 
  return IdStraw;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

InitThresholdsAndNoiseAmplitudes_and_ProduceNoiseDigitPool()

void TRTNoise::InitThresholdsAndNoiseAmplitudes_and_ProduceNoiseDigitPool ( CLHEP::HepRandomEngine * noiseRndmEngine, CLHEP::HepRandomEngine * elecNoiseRndmEngine, CLHEP::HepRandomEngine * elecProcRndmEngine )

private

Initialize thresholds and noise amplitudes.

This is the main initialization method for the noise treatment.
Strategy:

• First we create a lookup table so that we can, based on the noiselevel_i (i=straw_id), calculate for each straw: (LT/NA)_i (NA=Noise Amplitude).
• We also know for each straw their relative noise amplitude, r_i.
• C.f. Thomas Kittelmanns thesis, one finds that the lowthreshold and noise amplitude for each straw is given by the formulas:
  LT_i = (LT/NA)_i * r_i * k and NA_i = r_i * k, with k = < LT_i > / <(LT/NA)_i * r_i>

Steps:

1. Create lookup table for mapping: noiselevel to LT/NA
2. Find constant: k=< LT_i > / <(LT/NA)_i * r_i>
3. Calculate and set actual values of LT_i and NA_i for each straw.
4. Call method ProduceNoiseDigitPool to produce pool of pure noise digits

Loop through all non-dead straws (there are no dead straws since 2009!):

Definition at line 69 of file TRTNoise.cxx.

                                                                                                                    {

  //Strategy:                                                        //
  //                                                                 //
  //First we create a lookup table so that we can, based on the      //
  //noiselevel_i (i=straw_id), calculate for each straw: (LT/NA)_i   //
  //(NA=Noise Amplitude).                                            //
  //                                                                 //
  //We also know for each straw their relative noise amplitude, r_i. //
  //                                                                 //
  //C.f. the noise note, one finds that the lowthreshold and noise   //
  //amplitude for each straw is given by the formulas:               //
  //                                                                 //
  // LT_i = (LT/NA)_i * r_i * k   and   NA_i = r_i * k               //
  //                                                                 //
  // with k = <LT_i>/<(LT/NA)_i * r_i>                               //
  //                                                                 //
  // So now we first figure out the value of k, and afterwards we go //
  // through the straws and set LT_i and NA_i.                       //
 

  // Step 1 - create lookup table for mapping: noiselevel -> LT/NA //
  // According to Anatoli, the noise shaping function is not very different for Argon and Xenon(and Krypton).
  std::vector<float> maxLTOverNoiseAmp;
  m_pElectronicsNoise->getSamplesOfMaxLTOverNoiseAmp(maxLTOverNoiseAmp,10000,elecNoiseRndmEngine);
 
  std::stable_sort( maxLTOverNoiseAmp.begin(), maxLTOverNoiseAmp.end() );
  reverse(          maxLTOverNoiseAmp.begin(), maxLTOverNoiseAmp.end() );
 
  // If we have LT event-event fluctuations, we need to include that effect in the curve
 
  double relfluct = m_settings->relativeLowThresholdFluctuation();
 
  if ( relfluct > 0. ) {
    std::vector<float> nl_given_LT2Amp;
    float min_lt2amp, max_lt2amp;
    makeInvertedLookupTable( maxLTOverNoiseAmp, 0., 1.,
                             nl_given_LT2Amp, min_lt2amp, max_lt2amp);
    float new_min_lt2amp, new_max_lt2amp;
    evolve_LT2AmpVsNL_to_include_LTfluct( nl_given_LT2Amp,
                                          min_lt2amp, max_lt2amp,
                                          relfluct,
                                          new_min_lt2amp, new_max_lt2amp,
                                          static_cast<unsigned int>(0.1*nl_given_LT2Amp.size()));
    float min_nl,max_nl;  //Sanity check could be that ~0 and ~1 are returned.
    makeInvertedLookupTable( nl_given_LT2Amp,new_min_lt2amp, new_max_lt2amp, maxLTOverNoiseAmp,min_nl,max_nl);
  }

  // Step 2 - figure out constant, k = <LT_i> / <(LT/NA)_i * r_i>  //
 
  //Figure out <(LT/NA)_i * r_i>:
 
  unsigned long nstrawsBa_Xe(0), nstrawsEC_Xe(0);
  unsigned long nstrawsBa_Kr(0), nstrawsEC_Kr(0);
  unsigned long nstrawsBa_Ar(0), nstrawsEC_Ar(0);
  double sumBa_Xe(0.), sumEC_Xe(0.);
  double sumBa_Kr(0.), sumEC_Kr(0.);
  double sumBa_Ar(0.), sumEC_Ar(0.);
  int hitid(0);
  float noiselevel(0.), noiseamp(0.);
 
  m_pDigConditions->resetGetNextStraw();

  while ( m_pDigConditions->getNextStraw(hitid, noiselevel, noiseamp) ) {
 
    const bool isBarrel(!(hitid & 0x00200000));
    const int statusHT =  m_sumTool->getStatusHT(getStrawIdentifier(hitid), Gaudi::Hive::currentContext());
    const int strawGasType = TRTDigiHelper::StrawGasType(statusHT,m_UseGasMix, &msg());
    float lt = useLookupTable(noiselevel, maxLTOverNoiseAmp, 0., 1.) * noiseamp;
 
    if (strawGasType==0) {
      if ( isBarrel ) { ++nstrawsBa_Xe; sumBa_Xe += lt; }
      else            { ++nstrawsEC_Xe; sumEC_Xe += lt; }
    }
    else if (strawGasType==1) {
      if ( isBarrel ) { ++nstrawsBa_Kr; sumBa_Kr += lt; }
      else            { ++nstrawsEC_Kr; sumEC_Kr += lt; }
    }
    else if (strawGasType==2) {
      if ( isBarrel ) { ++nstrawsBa_Ar; sumBa_Ar += lt; }
      else            { ++nstrawsEC_Ar; sumEC_Ar += lt; }
    }
 
  }; // end "Loop through all non-dead straws"
 
  //This gives us k right away:
  double kBa_Xe(0.), kEC_Xe(0.);
  double kBa_Kr(0.), kEC_Kr(0.);
  double kBa_Ar(0.), kEC_Ar(0.);
  if (sumBa_Xe !=0.) kBa_Xe = m_settings->lowThresholdBar(0) * (nstrawsBa_Xe/sumBa_Xe);
  if (sumBa_Kr !=0.) kBa_Kr = m_settings->lowThresholdBar(1) * (nstrawsBa_Kr/sumBa_Kr);
  if (sumBa_Ar !=0.) kBa_Ar = m_settings->lowThresholdBar(2) * (nstrawsBa_Ar/sumBa_Ar);
  if (sumEC_Xe !=0.) kEC_Xe = m_settings->lowThresholdEC(0)  * (nstrawsEC_Xe/sumEC_Xe);
  if (sumEC_Kr !=0.) kEC_Kr = m_settings->lowThresholdEC(1)  * (nstrawsEC_Kr/sumEC_Kr);
  if (sumEC_Ar !=0.) kEC_Ar = m_settings->lowThresholdEC(2)  * (nstrawsEC_Ar/sumEC_Ar);

  // Step 3 - Calculate and set actual LT_i and NA_i               //
 
  std::vector<float> actual_LTs, actual_noiseamps;
  std::vector<int> strawTypes;
  if ( m_settings->noiseInUnhitStraws() ) {
    int nstraws = m_pDigConditions->totalNumberOfActiveStraws();
    actual_LTs.reserve(nstraws);
    actual_noiseamps.reserve(nstraws);
  };
 
  float actualLT, actualNA;
 
  m_pDigConditions->resetGetNextStraw();
 
  double sumLT_Ar(0.), sumLTsq_Ar(0.), sumNA_Ar(0.), sumNAsq_Ar(0.);
  double sumLT_Xe(0.), sumLTsq_Xe(0.), sumNA_Xe(0.), sumNAsq_Xe(0.);
  double sumLT_Kr(0.), sumLTsq_Kr(0.), sumNA_Kr(0.), sumNAsq_Kr(0.);
 
  while ( m_pDigConditions->getNextStraw( hitid, noiselevel, noiseamp) ) {
 
    const int statusHT =  m_sumTool->getStatusHT(getStrawIdentifier(hitid), Gaudi::Hive::currentContext());
    const int strawGasType = TRTDigiHelper::StrawGasType(statusHT,m_UseGasMix, &msg());
 
    const bool isBarrel(!(hitid & 0x00200000));
    if      (strawGasType==0) { actualNA = noiseamp*( isBarrel ? kBa_Xe : kEC_Xe ); }
    else if (strawGasType==1) { actualNA = noiseamp*( isBarrel ? kBa_Kr : kEC_Kr ); }
    else if (strawGasType==2) { actualNA = noiseamp*( isBarrel ? kBa_Ar : kEC_Ar ); }
    else                      { actualNA = 0.0; } // should never happen
 
    actualLT = useLookupTable(noiselevel, maxLTOverNoiseAmp, 0., 1.)*actualNA;
 
    if      (strawGasType==0) {
      sumNA_Xe += actualNA; sumNAsq_Xe += actualNA*actualNA;
      sumLT_Xe += actualLT; sumLTsq_Xe += actualLT*actualLT;
    }
    else if (strawGasType==1) {
      sumNA_Kr += actualNA; sumNAsq_Kr += actualNA*actualNA;
      sumLT_Kr += actualLT; sumLTsq_Kr += actualLT*actualLT;
    }
    else if (strawGasType==2) {
      sumNA_Ar += actualNA; sumNAsq_Ar += actualNA*actualNA;
      sumLT_Ar += actualLT; sumLTsq_Ar += actualLT*actualLT;
    }
 
    m_pDigConditions->setRefinedStrawParameters( hitid, actualLT, actualNA );
 
    if ( m_settings->noiseInUnhitStraws() ) {
      actual_LTs.push_back(actualLT);
      actual_noiseamps.push_back(actualNA);
      strawTypes.push_back(strawGasType);
    }
 
  };
 
 
  if (msgLvl(MSG::INFO)) {
 
    unsigned long nstraws_Kr = nstrawsBa_Kr + nstrawsEC_Kr;
    unsigned long nstraws_Xe = nstrawsBa_Xe + nstrawsEC_Xe;
    unsigned long nstraws_Ar = nstrawsBa_Ar + nstrawsEC_Ar;
 
    if (nstraws_Xe) {
      ATH_MSG_INFO("Xe Average LT is " << sumLT_Xe/nstraws_Xe/CLHEP::eV << " eV, with an RMS of "
                   << sqrt((sumLTsq_Xe/nstraws_Xe)-(sumLT_Xe/nstraws_Xe)*(sumLT_Xe/nstraws_Xe))/CLHEP::eV << " eV");
      ATH_MSG_INFO("Xe Average NA is " << sumNA_Xe/nstraws_Xe/CLHEP::eV << " eV, with an RMS of "
                   << sqrt((sumNAsq_Xe/nstraws_Xe)-(sumNA_Xe/nstraws_Xe)*(sumNA_Xe/nstraws_Xe))/CLHEP::eV << " eV");
    }
    if (nstraws_Kr) {
      ATH_MSG_INFO("Kr Average LT is " << sumLT_Kr/nstraws_Kr/CLHEP::eV << " eV, with an RMS of "
                   << sqrt((sumLTsq_Kr/nstraws_Kr)-(sumLT_Kr/nstraws_Kr)*(sumLT_Kr/nstraws_Kr))/CLHEP::eV << " eV");
      ATH_MSG_INFO("Kr Average NA is " << sumNA_Kr/nstraws_Kr/CLHEP::eV << " eV, with an RMS of "
                   << sqrt((sumNAsq_Kr/nstraws_Kr)-(sumNA_Kr/nstraws_Kr)*(sumNA_Kr/nstraws_Kr))/CLHEP::eV << " eV");
    }
    if (nstraws_Ar) {
      ATH_MSG_INFO("Ar Average LT is " << sumLT_Ar/nstraws_Ar/CLHEP::eV << " eV, with an RMS of "
                   << sqrt((sumLTsq_Ar/nstraws_Ar)-(sumLT_Ar/nstraws_Ar)*(sumLT_Ar/nstraws_Ar))/CLHEP::eV << " eV");
      ATH_MSG_INFO("Ar Average NA is " << sumNA_Ar/nstraws_Ar/CLHEP::eV << " eV, with an RMS of "
                   << sqrt((sumNAsq_Ar/nstraws_Ar)-(sumNA_Ar/nstraws_Ar)*(sumNA_Ar/nstraws_Ar))/CLHEP::eV << " eV");
    }
 
  }

  // Step 4 - Produce pool of pure noise digits                    //
  if ( m_settings->noiseInUnhitStraws() ) {
    ProduceNoiseDigitPool( actual_LTs, actual_noiseamps, strawTypes, noiseRndmEngine, elecNoiseRndmEngine, elecProcRndmEngine );
  }
 
  }

makeInvertedLookupTable()

void TRTNoise::makeInvertedLookupTable ( const std::vector< float > & y_given_x, const float & min_x, const float & max_x, std::vector< float > & x_given_y, float & min_y, float & max_y )

staticprivate

Invert look-up-table: Go from tabulated y values vs.

equidistantly spaced x values to tabulated x values vs. equidistantly spaced y values.

Parameters

y_given_x	y given x (input)
min_x	lower x value (input)
max_x	higher x value (input)
x_given_y	x given y (output)
min_y	lower y value (output)
max_y	higher y value (output)

Definition at line 485 of file TRTNoise.cxx.

                                                        {
 
  //Only works well when y_given_x.size() is large.
  //
  //Also assumes that y_given_x is homogeneous.
 
  //Figure out if rising or falling, and y limits:
  bool rising;
 
  if ( y_given_x.front() < y_given_x.back() ) {
    //NB: All use-cases have so far been on rising=false lookuptables
    rising = true;
    min_y = y_given_x.front();
    max_y = y_given_x.back();
  } else {
    rising = false;
    min_y = y_given_x.back();
    max_y = y_given_x.front();
  };
 
  const unsigned int n(y_given_x.size());
  if ( x_given_y.size() != n ) {
    x_given_y.resize(n);
  }
 
  //Fill new array:
  const float step_y((max_y-min_y)/(n-1));
  const float step_x((max_x-min_x)/(n-1));
 
  unsigned int searchindex = rising ? 0 : n-1;
  float yval;
  x_given_y.front() = rising ? min_x : max_x;
  for (unsigned int i = 1; i < n-1; ++i) {
    yval = min_y + i*step_y;
    if (rising) {
      // increase index in old array until we come to the index
      //   with a appropriate yval
      while ( y_given_x[searchindex] < yval ) { ++searchindex; };
      x_given_y[i] = min_x + searchindex*step_x;
    } else {
      while ( y_given_x[searchindex]<yval ) { --searchindex; };
      x_given_y[i] = min_x + searchindex*step_x;
    }
  };
  x_given_y.back() = rising ? max_x : min_x;
 
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

ProduceNoiseDigitPool()

void TRTNoise::ProduceNoiseDigitPool ( const std::vector< float > & lowthresholds, const std::vector< float > & noiseamps, const std::vector< int > & strawType, CLHEP::HepRandomEngine * noiseRndmEngine, CLHEP::HepRandomEngine * elecNoiseRndmEngine, CLHEP::HepRandomEngine * elecProcRndmEngine )

private

Produce pool of pure noise digits (for simulation of noise in unhit straws) and store them in m_digitPool.

The procedure uses TRTElectronicsProcessing::ProcessDeposits(), but with no input deposits. This way, we get the noise contribution only. The noise signals are thus originating from the cached vectors TRTElectronicsNoise::m_cachedFastNoiseAfterSignalShaping[] and TRTElectronicsNoise::m_cachedSlowNoiseAfterSignalShaping[]

Parameters

lowthresholds	low threshold settings, all straws
noiseamp	noise amplitudes, all straws

Definition at line 268 of file TRTNoise.cxx.

                                                                                {
 
  unsigned int nstraw = lowthresholds.size();
  unsigned int istraw;
 
  m_digitPool.resize( m_digitPoolLength );
 
  std::vector<TRTElectronicsProcessing::Deposit> deposits;
  int dummyhitid(0);
  TRTDigit digit;
  unsigned int nokdigits(0);
  unsigned int ntries(0);
 
  while ( nokdigits < m_digitPoolLength ) {
 
    // Once and a while, create new vectors of shaped electronics noise.
    // These are used as inputs to TRTElectronicsProcessing::ProcessDeposits
    // to create noise digits
    if ( ntries%400==0 ) {
      m_pElectronicsNoise->reinitElectronicsNoise(200, elecNoiseRndmEngine);
    }
    // Initialize stuff (is that necessary)?
    digit = TRTDigit();
    deposits.clear();
 
    // Choose straw to simulate
    istraw = CLHEP::RandFlat::shootInt(noiseRndmEngine, nstraw );
 
    // Process deposits this straw. Since there are no deposits, only noise will contrinute
    m_pElectronicsProcessing->ProcessDeposits( deposits,
                                               dummyhitid,
                                               digit,
                                               lowthresholds.at(istraw),
                                               noiseamps.at(istraw),
                                               strawType.at(istraw),
                                               elecProcRndmEngine,
                                               elecNoiseRndmEngine
                                               );
 
    // If this process produced a digit, store in pool
    if ( digit.GetDigit() ) {
      m_digitPool[nokdigits++] = digit.GetDigit();
    }
    ntries++;
  };
 
  if (msgLvl(MSG::VERBOSE)) {
    if(0==ntries) {
      ATH_MSG_FATAL("ntries==0 this should not be possible!");
      throw std::exception();
    }
    ATH_MSG_VERBOSE("Produced noise digit pool of size " << m_digitPool.size()
                    << " (efficiency was " << static_cast<double>(m_digitPool.size())/ntries << ")");
  }
 
  m_digitPoolLength_nextaccessindex = 0;
 
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

simulateNoiseFrequency()

double TRTNoise::simulateNoiseFrequency ( const unsigned int & totalNumberOfTests, const double & electronicsNoiseAmplitude, double lowthreshold = -1.0 )

private

sortDigits()

void TRTNoise::sortDigits ( std::vector< TRTDigit > & digitVect )

static

Definition at line 447 of file TRTNoise.cxx.

{
  std::stable_sort(digitVect.begin(), digitVect.end(), TRTDigitSorterObject);
}

useLookupTable()

float TRTNoise::useLookupTable ( const float & x, const std::vector< float > & y_given_x, const float & min_x, const float & max_x )

staticprivate

Return y value corresponding to input x value from LUT.

Returns

y: Output y value

Parameters

x	Input x value
y_given_x	Look-up-table: gives y values for uniformly distributed x values
min_x	lowest tabulated x value
max_x	highest tabulated x value

Definition at line 453 of file TRTNoise.cxx.

                                                    {
 
  double       bin_withfrac;
  unsigned int lower_index;
  double       fraction_into_bin;
 
  // Assumes that y_given_x is homogeneous (and not entirely flat)
 
  // Low x-value, return first y-value
  if ( x < min_x ) {
    return y_given_x.front();
  }
 
  // Which bin?
  bin_withfrac = (x-min_x)*(y_given_x.size()-1)/(max_x-min_x);
  lower_index = static_cast<unsigned int>(bin_withfrac);
 
  // High x-value, return last y-value
  if ( lower_index >= y_given_x.size()-1 ) {
    return y_given_x.back();
  }
 
  // Normal case: return weighted sum of two neighbouring bin values
  fraction_into_bin = bin_withfrac - lower_index;
  return (1.-fraction_into_bin) * y_given_x[lower_index] + fraction_into_bin * y_given_x[lower_index+1];
 
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_detmgr

const InDetDD::TRT_DetectorManager* TRTNoise::m_detmgr {}

private

Definition at line 86 of file TRTNoise.h.

{};

m_digitPool

std::vector<unsigned int> TRTNoise::m_digitPool

private

Pool of noise digits for noise in unhit straws.

Definition at line 145 of file TRTNoise.h.

m_digitPoolLength

unsigned int TRTNoise::m_digitPoolLength

private

Length of noise digit pool m_digitPool.

Definition at line 141 of file TRTNoise.h.

m_digitPoolLength_nextaccessindex

unsigned int TRTNoise::m_digitPoolLength_nextaccessindex

private

Pointer into noise digit pool m_digitPool.

Definition at line 143 of file TRTNoise.h.

m_id_helper

const TRT_ID* TRTNoise::m_id_helper

private

Definition at line 139 of file TRTNoise.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_noise_randengine

CLHEP::HepRandomEngine* TRTNoise::m_noise_randengine {}

private

Definition at line 91 of file TRTNoise.h.

{};

m_pDigConditions

TRTDigCondBase* TRTNoise::m_pDigConditions {}

private

Definition at line 88 of file TRTNoise.h.

{};

m_pElectronicsNoise

TRTElectronicsNoise* TRTNoise::m_pElectronicsNoise {}

private

Definition at line 90 of file TRTNoise.h.

{};

m_pElectronicsProcessing

TRTElectronicsProcessing* TRTNoise::m_pElectronicsProcessing {}

private

Definition at line 89 of file TRTNoise.h.

{};

m_settings

const TRTDigSettings* TRTNoise::m_settings {}

private

Definition at line 85 of file TRTNoise.h.

{};

m_sumTool

ToolHandle<ITRT_StrawStatusSummaryTool> TRTNoise::m_sumTool

private

Definition at line 210 of file TRTNoise.h.

m_UseGasMix

int TRTNoise::m_UseGasMix {}

private

Definition at line 209 of file TRTNoise.h.

{};

---

The documentation for this class was generated from the following files:

• TRTNoise.h
• TRTNoise.cxx