CscCalibTool Class Reference

#include <CscCalibTool.h>

Inheritance diagram for CscCalibTool:

Collaboration diagram for CscCalibTool:

Public Member Functions
	CscCalibTool (const std::string &, const std::string &, const IInterface *)
virtual	~CscCalibTool ()=default
virtual StatusCode	initialize () override final
virtual int	femtoCoulombToADCCount (uint32_t stripHashId, const double femtoCoulombs) const override final
	given a charge on the CSC strip, convert that to ADC counts this is needed in the digitization for example where it is the charges on the strips that are simulated first and converter to AOD samples in a subsequent step.
virtual int	numberOfElectronsToADCCount (uint32_t stripHashId, const int numberOfElecEquiv) const override final
	Here the charge on the CSC strip is given in number of equivalent electrons; conversion to ADC counts.
virtual double	adcCountToFemtoCoulomb (const float adcCounts, const float slope) const override final
	given one CSC ADC sample value, convert that to charge in femtoCoulomb
virtual double	adcCountToFemtoCoulomb (uint32_t stripHashId, const float adcCounts) const override final
virtual double	adcCountToNumberOfElectrons (const float adcValue, const float slope) const override final
	given one CSC ADC sample value, convert that to charge in number of equivalent electrons
virtual double	adcCountToNumberOfElectrons (uint32_t stripHashId, const float adcValue) const override final
virtual bool	adcToCharge (const std::vector< uint16_t > &samples, uint32_t stripHashId, std::vector< float > &charges) const override final
	Conversion of ADC value to charge - Here the charges is returned in numbers of equivalent electrons.
virtual bool	findCharge (const float samplingTime, const unsigned int samplingPhase, const std::vector< float > &samples, double &charge, double &time) const override final
	Given sampling values for a CSC strip, find the corresponding charge by fitting the time samples.
virtual double	stripNoise (uint32_t stripHashId, const bool convert=true) const override final
	return the noise(sigma) on the readout strip in ADC counts or Number of Electrons number of electrons by default: convert=true
virtual double	stripRMS (uint32_t stripHashId, const bool convert=true) const override final
	return the RMS on the readout strip in ADC counts or Number of Electrons number of electrons by default: convert=true
virtual double	stripF001 (uint32_t stripHashId, const bool convert=true) const override final
	return the F001 on the readout strip in ADC counts or Number of Electrons number of electrons by default: convert=true
virtual double	stripPedestal (uint32_t stripHashId, const bool convert=true) const override final
	return the pedestal on the readout strip in ADC counts or Number of Electrons
virtual bool	isGood (uint32_t stripHashId) const override final
	return the status of this strip, good channel, dead channel, noisy channel - it will return true for strip that working fine, false is returned for dead/noisy channels
virtual int	stripStatusBit (uint32_t stripHashId) const override final
	return status bit
virtual bool	stripT0phase (uint32_t stripHashId) const override final
	return T0phase related to 5 ASM.
virtual double	stripT0base (uint32_t stripHashId) const override final
	return T0base related to 5 ASM.
virtual double	func (const double x, const float slope) const override final
	these function used in the AOD <-> conversion; may not be needed once we integrate the calibration service
virtual double	func_prime (const double x, const float slope) const override final
virtual double	signal (const double z) const override final
virtual double	signal_amplitude (const double driftTime, const double samplingTime) const override final
virtual double	getZ0 () const override final
	ROOT version of bipolar function.
virtual double	getSamplingTime () const override final
virtual double	getTimeOffset () const override final
virtual double	getSignalWidth () const override final
virtual double	getNumberOfIntegration () const override final
virtual double	getNumberOfIntegration2 () const override final
virtual std::pair< double, double >	addBipfunc (const double driftTime0, const double stripCharge0, const double driftTime1, const double stripCharge1) const override final
virtual std::vector< float >	getSamplesFromBipolarFunc (const double driftTime0, const double stripCharge0) const override final
virtual double	getLatency () const override final

Public Attributes
std::atomic_int	m_messageCnt_t0base {}
std::atomic_int	m_messageCnt_t0phase {}

Protected Attributes
SG::ReadCondHandleKey< CscCondDbData >	m_readKey {this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"}
bool	m_readFromDatabase
bool	m_slopeFromDatabase
float	m_slope
float	m_noise
float	m_pedestal
double	m_integrationNumber
	ROOT version of bipolar function.
double	m_integrationNumber2
double	m_samplingTime
double	m_signalWidth
double	m_timeOffset
double	m_latency
unsigned int	m_nSamples
bool	m_onlineHLT
bool	m_use2Samples

Private Member Functions
float	getPSlope (uint32_t stripHashId) const

Detailed Description

Definition at line 36 of file CscCalibTool.h.

Constructor & Destructor Documentation

CscCalibTool()

CscCalibTool::CscCalibTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 11 of file CscCalibTool.cxx.

  : base_class(t,n,p)
{
  declareProperty( "Slope", m_slope = 0.19 );
  declareProperty( "Noise", m_noise = 3.5 );
  declareProperty( "Pedestal", m_pedestal = 2048.0 );
  declareProperty( "ReadFromDatabase", m_readFromDatabase = true);
  declareProperty( "integrationNumber", m_integrationNumber = 12.0);
  declareProperty( "integrationNumber2", m_integrationNumber2 = 11.66);
  declareProperty( "samplingTime", m_samplingTime = 50. ); //ns
  declareProperty( "signalWidth", m_signalWidth = 14.40922); // 50/3.47ns
  declareProperty( "SlopeFromDatabase", m_slopeFromDatabase=false);
  declareProperty( "timeOffset", m_timeOffset = 46.825 );
 
  declareProperty( "IsOnline"  , m_onlineHLT = true); // This will be fed from jO
 
  // new latency starting from 2010...
  declareProperty( "Latency", m_latency = 100 ); // ns.....
  declareProperty( "NSamples", m_nSamples = 4); // number of samples
 
  declareProperty( "Use2Samples", m_use2Samples = false); // force 2 sample
}

~CscCalibTool()

virtual CscCalibTool::~CscCalibTool ( )

virtualdefault

Member Function Documentation

adcCountToFemtoCoulomb() [1/2]

double CscCalibTool::adcCountToFemtoCoulomb ( const float adcCounts, const float slope ) const

finaloverridevirtual

given one CSC ADC sample value, convert that to charge in femtoCoulomb

Definition at line 332 of file CscCalibTool.cxx.

{
 
  double charge = adc * slope;
  ATH_MSG_VERBOSE ( "Using CscCalibTool::adcCountToFemtoCoulomb - adc = " 
                  << adc << " charge(fC) = " << charge );
  return charge;
} 

adcCountToFemtoCoulomb() [2/2]

double CscCalibTool::adcCountToFemtoCoulomb ( uint32_t stripHashId, const float adcCounts ) const

finaloverridevirtual

the strip hash id will be used to access the data base

subtract the pedestal

Definition at line 502 of file CscCalibTool.cxx.

{
  ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );


  float pedestal = m_pedestal;
  float slope    = getPSlope(stripHashId);
 
  if ( m_readFromDatabase ) {
    SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
    const CscCondDbData* readCdo{*readHandle};
    if(!readCdo->readChannelPed(stripHashId, pedestal).isSuccess()){
      ATH_MSG_DEBUG ( " failed to access CSC conditions database - pedestal - " 
                      << "strip hash id = " << stripHashId );
      pedestal = m_pedestal;
    }
  }
  ATH_MSG_VERBOSE ( "Pedestal is " << pedestal << " For strip hash id " << stripHashId );
  
  // allowed negative adc values for bipolar fit
  float adc = adcValue-pedestal;
  return this->adcCountToFemtoCoulomb( adc, slope );
  
}

adcCountToNumberOfElectrons() [1/2]

double CscCalibTool::adcCountToNumberOfElectrons ( const float adcValue, const float slope ) const

finaloverridevirtual

given one CSC ADC sample value, convert that to charge in number of equivalent electrons

conversion from ADC value to number of equivalent electrons

Definition at line 138 of file CscCalibTool.cxx.

{
  double conversionFactor = 1.602e-4;  // 1 ee in femtoCoulomb
  double femtoCoulombs = this->adcCountToFemtoCoulomb(adcValue, slope);
  return (femtoCoulombs/conversionFactor);
}

adcCountToNumberOfElectrons() [2/2]

double CscCalibTool::adcCountToNumberOfElectrons ( uint32_t stripHashId, const float adcValue ) const

finaloverridevirtual

the strip hash id will be used to access the data base

subtract the pedestal

Definition at line 529 of file CscCalibTool.cxx.

{
  ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );


  float pedestal = m_pedestal;
  float slope    = getPSlope(stripHashId);
  if ( m_readFromDatabase ) {
     SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
     const CscCondDbData* readCdo{*readHandle};
     if(!readCdo->readChannelPed(stripHashId, pedestal).isSuccess()){
       ATH_MSG_DEBUG ( "failed to access CSC Conditions database - pedestal - " 
                       << "strip hash id = " << stripHashId );
       pedestal = m_pedestal;
     }
  }
  ATH_MSG_VERBOSE ( "Pedestal is " << pedestal << " For strip hash id " << stripHashId );
 
  // allowed negative adc values for bipolar fit
  float adc = adcValue-pedestal;
  return this->adcCountToNumberOfElectrons( adc, slope );
}

adcToCharge()

bool CscCalibTool::adcToCharge ( const std::vector< uint16_t > & samples, uint32_t stripHashId, std::vector< float > & charges ) const

finaloverridevirtual

Conversion of ADC value to charge - Here the charges is returned in numbers of equivalent electrons.

subtract the pedestal

Definition at line 554 of file CscCalibTool.cxx.

                                                                {
   ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );
 
   charges.clear();

   float pedestal = m_pedestal;
   float slope    = getPSlope(stripHashId);
   if ( m_readFromDatabase ) {
      SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
      const CscCondDbData* readCdo{*readHandle};
      if(!readCdo->readChannelPed(stripHashId, pedestal).isSuccess()){
        ATH_MSG_DEBUG ( "failed to access CSC Conditions database - pedestal - " 
                        << "strip hash id = " << stripHashId );
        pedestal = m_pedestal; 
      }     
   } 
   ATH_MSG_VERBOSE ( "Pedestal is " << pedestal << " For strip hash id " << stripHashId );
 
   unsigned max = samples.size();
   if ( max == 0 ) return false;
   for (unsigned int i=0; i<max; i++) {
     //     if ( samples[i] > pedestal ) {
     float adc = samples[i]-pedestal;
     float charge = static_cast<float> ( this->adcCountToNumberOfElectrons( adc, slope ) );
     charges.push_back( charge );
        // } else charges.push_back( 0.0 );
   }
   return true;
}

addBipfunc()

std::pair< double, double > CscCalibTool::addBipfunc ( const double driftTime0, const double stripCharge0, const double driftTime1, const double stripCharge1 ) const

finaloverridevirtual

Definition at line 643 of file CscCalibTool.cxx.

                                                                                       {
  
  std::pair<double,double> result;
  // To get a nomalization constant...
  result.first =driftTime0;
  result.second = stripCharge0;
 
  if ( (stripCharge0==0.0 && stripCharge1==0.0)||
       (stripCharge0>0.0 && stripCharge1==0.0))
    return result;
 
  if (stripCharge0==0.0 && stripCharge1>0.0) {
    result.first =driftTime1;
    result.second = stripCharge1;
    return result;
  }
  
  std::unique_ptr<TF1> addedfunc = std::make_unique<TF1>("addedfunc", dualbipfunc, 0, 500, 10, 1, TF1::EAddToList::kNo);
  addedfunc->SetParameters(stripCharge0, driftTime0,
                             m_integrationNumber,m_integrationNumber2,m_signalWidth,
                             stripCharge1, driftTime1,
                             m_integrationNumber,m_integrationNumber2,m_signalWidth);
  result.second =addedfunc->GetMaximum(); // ==>stripCharges of added bipolars
  float tmax =addedfunc->GetX(result.second);
  result.first = tmax - getZ0()*m_signalWidth;
 
  if (stripCharge0>0.0 && stripCharge1>0.0) return result;
 
  float bipmin = addedfunc->GetMinimum(); // ==>stripCharges of added bipolars
  float tmin = addedfunc->GetX(bipmin);
  if (tmin<tmax) {
    result.first = tmin-getZ0()*m_signalWidth;
    result.second = bipmin;
  }
  
  //  To check out conversion is correct...
  ATH_MSG_VERBOSE ( "(" << driftTime0 << ":" << int(stripCharge0) << ")"
                    << "+(" << driftTime1 << ":" << int(stripCharge1) << ")"
                    << " ==> " << result.first << ":" << int(result.second)
                    << " e-  which was " << int(stripCharge0+stripCharge1) );
 
 
  
  return result;
}

femtoCoulombToADCCount()

int CscCalibTool::femtoCoulombToADCCount ( uint32_t stripHashId, const double femtoCoulombs ) const

finaloverridevirtual

given a charge on the CSC strip, convert that to ADC counts this is needed in the digitization for example where it is the charges on the strips that are simulated first and converter to AOD samples in a subsequent step.

Definition at line 126 of file CscCalibTool.cxx.

{
 
  //ATH_MSG_VERBOSE ( "Using CscCalibTool::femtoCoulombToADCCount" );
 
  float slope = getPSlope(stripHashId);
  
  int adcValue = int ( func(femtoCoulombs,slope) );
  return adcValue;
}

findCharge()

bool CscCalibTool::findCharge ( const float samplingTime, const unsigned int samplingPhase, const std::vector< float > & samples, double & charge, double & time ) const

finaloverridevirtual

Given sampling values for a CSC strip, find the corresponding charge by fitting the time samples.

By default, a parabolic fit is done. The charge and the time are returned. The time is calculated with respect to the time of the first sample.

find the maximum

all the samples are zeros

now the parabolic interpolation

a==0: 3 points on a line, no parabola possible

a>0: convex parabola isn't useful for peak finding

if the time offset is out of range

successful interpolation

Find the peaking time: this is no longer assuming a 4-time sample system The peaking time is the time of the largest sample. This is corrected by the timeOffset interpolation, which should range from -0.5 to 0.5.

Todo

find out if a larger range can be used, such as +-1.0

Multiply by sampling time to convert to nanoseconds. Finally subtract 25ns if the sampling phase is 1.

Definition at line 364 of file CscCalibTool.cxx.

                                                                                                    {
  
  time = 0.0;
  charge = 0.0;
 
  int numberOfSamplings = samples.size();
  // no samples given
  if (numberOfSamplings==0) return false;
  
  // MS: The case of only 2 samples:
  if ((numberOfSamplings==2) || m_use2Samples) { // no parabola possible
    int i = numberOfSamplings/2-1;
    charge = 0.5*(samples[i]+samples[i+1]); // 1+2 for 4 samples, 0+1 for 2
 
    double asym = 0.;
    if (std::abs(samples[i]+samples[i+1])>0.0001)  asym = (samples[i+1]-samples[i])/(samples[i]+samples[i+1]);
    /********************* No charge correction now.
    // charge correction:
    double chargecor = 77.85 + 1.415*asym - 44.97*asym*asym; // in percent
    charge = charge / chargecor * 100.0;
    *******************/
 
    // time = i+0.5; // midpoint beween the 2 samples: no interpolation
    // time *= samplingTime;
    time = 76 + 47.85*asym + 6.629*asym*asym; // in ns, for 50ns sampling
    if ( samplingPhase == 1 ) time -= 25;
    return true;
  }

  float max = -4096000;
  int maxIndex = -1;
 
  if ( numberOfSamplings >10) { // for x5 data
    maxIndex = 2;
    max = samples[maxIndex];
  }
  
  for (int i=0; i<numberOfSamplings; i++) {
    if ( numberOfSamplings >10 && (i<2 || i>6) ) continue; // for x5 data
    if (samples[i] > max) { 
      max = samples[i];
      maxIndex = i;
    } 
  }
  
  //  if (max == -4096000) return false; //not possible
  

  
  double a, b, c;
 
  int midIndex = maxIndex;
  if (maxIndex == 0) { // peaks on the first sample
    a = samples[maxIndex];
    b = samples[maxIndex+1];
    c = samples[maxIndex+2];
    midIndex +=1; 
  } else if (maxIndex == numberOfSamplings-1) { // last sample but it won't happen if third and 4th samples are same...
    a = samples[maxIndex-2];
    b = samples[maxIndex-1];
    c = samples[maxIndex];
    midIndex -=1;
  } else { // normal case
    a = samples[maxIndex-1];
    b = samples[maxIndex];
    c = samples[maxIndex+1];
  } 
 
  //#D!!!!! Need to carefully check the case of 250 * 23898.136 * 28535.650 * 33587.949 * 33587.949 *
  
  double aa = 0.5*(c+a-2*b); // p2 (coeff for x^2)
  double bb = 0.5*(c-a);
 
  
  if ( aa >= 0 ) { 
    time = midIndex;
    time *= samplingTime;
    if ( samplingPhase == 1 ) time -= 25; // works for both 20MHz and 40MHz
    //    time =0.0;
    charge = max;
 
    if (maxIndex ==0 || maxIndex ==1)
      time -= 1000;
    else if (maxIndex ==2 || maxIndex ==3)
      time += 1000;
 
    ATH_MSG_VERBOSE("WP aa is positive");
    return false;
  }
  
  double timeOffset = -0.5*bb/aa;
 
  ATH_MSG_VERBOSE("WP " << timeOffset);  
  if ( ( maxIndex == 0 && timeOffset < -2.0 )
       || ( maxIndex == 3 && timeOffset > 2.0) ) {
    time = midIndex;
    time *= samplingTime;
    if ( samplingPhase == 1 ) time -= 25; // works for both 20MHz and 40MHz
    //    time =0.0;
    charge = max;
 
    if (maxIndex ==0 || maxIndex ==1)
      time -= 1000;
    else if (maxIndex ==2 || maxIndex ==3)
      time += 1000;
 
    ATH_MSG_VERBOSE("time is out of range");
    
    return true;
  }

  charge = aa*timeOffset*timeOffset + bb*timeOffset + b;
  time = timeOffset;
  
  time += midIndex;
  time *= samplingTime;
  if ( samplingPhase == 1 ) time -= 25;
  
  return true;
}

func()

double CscCalibTool::func ( const double x, const float slope ) const

finaloverridevirtual

these function used in the AOD <-> conversion; may not be needed once we integrate the calibration service

Definition at line 341 of file CscCalibTool.cxx.

{
  int val = 0;
  if ( slope != 0 ) val = int ( (x / slope) + 0.5);
  //  else
  //    ATH_MSG_WARNING ( "CscCalibTool::femtoCoulombToADC - slope = 0" );
  //  if ( val < 0 ) {
  //    ATH_MSG_WARNING ( "CscCalibTool::femtoCoulombToADC - ADC cannot be < 0 - " << val );
  //val = 0;
  //  }
  
  return (1.0*val);
}

func_prime()

double CscCalibTool::func_prime ( const double x, const float slope ) const

finaloverridevirtual

Definition at line 355 of file CscCalibTool.cxx.

{
  double val = slope;
  if ( slope == 0.0 )
    ATH_MSG_WARNING ( "CscCalibTool - slope = 0 for x = " << x );
  return val;
}

getLatency()

double CscCalibTool::getLatency ( ) const

finaloverridevirtual

Definition at line 693 of file CscCalibTool.cxx.

{return m_latency;}

getNumberOfIntegration()

double CscCalibTool::getNumberOfIntegration ( ) const

finaloverridevirtual

Definition at line 696 of file CscCalibTool.cxx.

{return m_integrationNumber;}

getNumberOfIntegration2()

double CscCalibTool::getNumberOfIntegration2 ( ) const

finaloverridevirtual

Definition at line 697 of file CscCalibTool.cxx.

{return m_integrationNumber2;}

getPSlope()

float CscCalibTool::getPSlope ( uint32_t stripHashId ) const

private

Definition at line 92 of file CscCalibTool.cxx.

                                                        {
 
  
  float slope = m_slope;
  if ( m_readFromDatabase && m_slopeFromDatabase ) {
    SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
    const CscCondDbData* readCdo{*readHandle};
    if(!readCdo->readChannelPSlope(stripHashId, slope).isSuccess()){
      ATH_MSG_WARNING ( " failed to access CSC conditions database - slope - " 
                        << "strip hash id = " << stripHashId );
    }
  }
  ATH_MSG_DEBUG ( "The slope is " << slope << " for strip hash = " << stripHashId );
 
  return slope;
 
}

getSamplesFromBipolarFunc()

std::vector< float > CscCalibTool::getSamplesFromBipolarFunc ( const double driftTime0, const double stripCharge0 ) const

finaloverridevirtual

Definition at line 617 of file CscCalibTool.cxx.

                                                                                                                 {
  
  std::vector<float> result;
  if ( stripCharge0==0.0 ) {
    result.push_back(0.0);
    result.push_back(0.0);
    result.push_back(0.0);
    result.push_back(0.0);
    return result;
  }
 
  std::unique_ptr<TF1> bipolarFunc = std::make_unique<TF1>("bipolarFunc", bipfunc, -500, 500, 5, 1, TF1::EAddToList::kNo);
  bipolarFunc->SetParameters(stripCharge0, driftTime0,
                               m_integrationNumber,m_integrationNumber2,m_signalWidth);
 
 
  for (unsigned int i=0; i<m_nSamples; ++i) {
 
    float sampleCharge = bipolarFunc->Eval(m_latency + i*m_samplingTime);
    result.push_back( sampleCharge );
 
  }
  return result;
}

getSamplingTime()

double CscCalibTool::getSamplingTime ( ) const

finaloverridevirtual

Definition at line 692 of file CscCalibTool.cxx.

{return m_samplingTime;}

getSignalWidth()

double CscCalibTool::getSignalWidth ( ) const

finaloverridevirtual

Definition at line 695 of file CscCalibTool.cxx.

{return m_signalWidth;}

getTimeOffset()

double CscCalibTool::getTimeOffset ( ) const

finaloverridevirtual

Definition at line 694 of file CscCalibTool.cxx.

{return m_timeOffset;}

getZ0()

double CscCalibTool::getZ0 ( ) const

finaloverridevirtual

ROOT version of bipolar function.

Definition at line 591 of file CscCalibTool.cxx.

                                {
  double sum = m_integrationNumber+m_integrationNumber2;
  double z0 = 0.5*( (sum+2)
                    -std::sqrt(std::pow(sum+2,2)
                          -4*m_integrationNumber*(m_integrationNumber2+1))
                    );
  return z0;
}

initialize()

StatusCode CscCalibTool::initialize ( )

finaloverridevirtual

Definition at line 63 of file CscCalibTool.cxx.

                                    {
 
  ATH_MSG_DEBUG ( "Initializing Initializing CscCalibTool");
 
  ATH_MSG_DEBUG ( "Default slope (if DB is not available)    =" << m_slope );
  ATH_MSG_DEBUG ( "Default noise (if DB is not available)    =" << m_noise );
  ATH_MSG_DEBUG ( "Default pedestal (if DB is not available) =" << m_pedestal );
  ATH_MSG_DEBUG ( "Calib Constants are from DB ?             =" << m_readFromDatabase );
  ATH_MSG_DEBUG ( "Slope Constants are from DB ?             =" << m_slopeFromDatabase );
  ATH_MSG_DEBUG ( "Bipolar function integrationNumber(N_1)   =" << m_integrationNumber);
  ATH_MSG_DEBUG ( "Bipolar function integrationNumber(N_2)   =" << m_integrationNumber2);
  ATH_MSG_DEBUG ( "SamplingTime                              =" << m_samplingTime);
  ATH_MSG_DEBUG ( "Signalwidth                               =" << m_signalWidth);
  ATH_MSG_DEBUG ( "timeOffset  (digitization)                =" << m_timeOffset);
  ATH_MSG_DEBUG ( "Is OnlineAccess (HLT) ??                  =" << m_onlineHLT);
  ATH_MSG_DEBUG ( "Force the use of the 2 sample charge?     =" << m_use2Samples);
 
  if (m_onlineHLT) {
    ATH_MSG_DEBUG( "T0BaseFolder and T0PhaseFolder are not loaded!!! HLT COOLDB does not have it!!");
  }
 
  ATH_CHECK(m_readKey.initialize()); 
 
  m_messageCnt_t0base=0;
  m_messageCnt_t0phase=0;
 
  return StatusCode::SUCCESS;
}

isGood()

bool CscCalibTool::isGood ( uint32_t stripHashId ) const

finaloverridevirtual

return the status of this strip, good channel, dead channel, noisy channel - it will return true for strip that working fine, false is returned for dead/noisy channels

return the status of this strip, good channel, dead channel, noisy channel -
it will return true for strip that working fine, false is returned for dead/noisy channels

Definition at line 254 of file CscCalibTool.cxx.

{
  
  ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );
  
  unsigned int status = stripStatusBit(stripHashId);
  bool is_good = !( (status & 0x1) || ((status >> 1) & 0x1) ); // test for hot/dead channel
  return is_good;
}

numberOfElectronsToADCCount()

int CscCalibTool::numberOfElectronsToADCCount ( uint32_t stripHashId, const int numberOfElecEquiv ) const

finaloverridevirtual

Here the charge on the CSC strip is given in number of equivalent electrons; conversion to ADC counts.

Definition at line 112 of file CscCalibTool.cxx.

{
 
  //ATH_MSG_VERBOSE ( "Using CscCalibTool::numberOfElectronsToADCCount" );
 
  double conversionFactor = 1.602e-4;  // 1 ee in femtoCoulomb
  double femtoCoulombs    = conversionFactor*numberOfElecEquiv;
 
  float slope = getPSlope(stripHashId);
  
  int adcValue = int ( func(femtoCoulombs,slope) );
  return adcValue;
}

signal()

double CscCalibTool::signal ( const double z ) const

finaloverridevirtual

Definition at line 600 of file CscCalibTool.cxx.

                                                 {
  double amplitude = (1.0 - z / (1 + m_integrationNumber2))
    * std::pow(z, 1.0 * m_integrationNumber)
    * std::exp(-z);
  return amplitude;
}

signal_amplitude()

double CscCalibTool::signal_amplitude ( const double driftTime, const double samplingTime ) const

finaloverridevirtual

Definition at line 607 of file CscCalibTool.cxx.

                                                                                            {
  double z0 = getZ0();
  double norm = signal(z0);
  if (samplingTime <= driftTime) return 0.;
  Double_t z = (samplingTime-driftTime)/m_signalWidth;
  return signal(z)/norm;
}

stripF001()

double CscCalibTool::stripF001 ( uint32_t stripHashId, const bool convert = true ) const

finaloverridevirtual

return the F001 on the readout strip in ADC counts or Number of Electrons number of electrons by default: convert=true

return the F001 on the readout strip in ADC count or Number of Electrons

ADC counts initialized with m_noise...

Definition at line 201 of file CscCalibTool.cxx.

{
  ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );
 
  float f001 = m_noise+m_pedestal;  
  if ( m_readFromDatabase ) {
    SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
    const CscCondDbData* readCdo{*readHandle};
    if(!readCdo->readChannelF001(stripHashId, f001).isSuccess()){
      ATH_MSG_DEBUG ( " failed to access CSC conditions database - f001 - " 
                      << "strip hash id = " << stripHashId );
      f001 = 3.251*m_noise+m_pedestal;
    } 
  } 
  
  ATH_MSG_VERBOSE ( "The F001 is " << f001 << " for strip hash = " << stripHashId ); 
 
  if ( convert ) {
    float slope = getPSlope(stripHashId);
    return this->adcCountToNumberOfElectrons( f001, slope );
  }  else {
    return f001;
  }
}

stripNoise()

double CscCalibTool::stripNoise ( uint32_t stripHashId, const bool convert = true ) const

finaloverridevirtual

return the noise(sigma) on the readout strip in ADC counts or Number of Electrons number of electrons by default: convert=true

return the noise on the readout strip in ADC count or Number of Electrons

ADC counts

Definition at line 146 of file CscCalibTool.cxx.

{
  ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );
 
  float noise = m_noise;  
  if ( m_readFromDatabase ) {
    SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
    const CscCondDbData* readCdo{*readHandle};
    if(!readCdo->readChannelNoise(stripHashId, noise).isSuccess()){
      ATH_MSG_DEBUG ( " failed to access CSC conditions database - noise - " 
                      << "strip hash id = " << stripHashId );
      noise = m_noise;
    } 
  } 
  
  ATH_MSG_VERBOSE ( "The noise is " << noise << " for strip hash = " << stripHashId ); 
 
  if ( convert ) {
    float slope = getPSlope(stripHashId);
    return this->adcCountToNumberOfElectrons( noise, slope );
  }  else {
    return noise;
  }
}

stripPedestal()

double CscCalibTool::stripPedestal ( uint32_t stripHashId, const bool convert = true ) const

finaloverridevirtual

return the pedestal on the readout strip in ADC counts or Number of Electrons

return the pedestal on the readout strip in ADC counts or number of electrons

• number of electrons by default: convert=true

Definition at line 227 of file CscCalibTool.cxx.

{
  ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );
 
  float pedestal = m_pedestal;
  if ( m_readFromDatabase ) {
    SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
    const CscCondDbData* readCdo{*readHandle};
    if(!readCdo->readChannelPed(stripHashId, pedestal).isSuccess()){
      ATH_MSG_DEBUG ( " failed to access CSC conditions database - pedestal - " 
                      << "strip hash id = " << stripHashId );
      pedestal = m_pedestal;
    }
  }
  ATH_MSG_VERBOSE ( "The pedestal is " << pedestal << " for strip hash = " << stripHashId );
  
  if ( convert ) {
    float slope = getPSlope(stripHashId);
    return this->adcCountToNumberOfElectrons( pedestal, slope );
  }  else {
    return pedestal;
  }
}

stripRMS()

double CscCalibTool::stripRMS ( uint32_t stripHashId, const bool convert = true ) const

finaloverridevirtual

return the RMS on the readout strip in ADC counts or Number of Electrons number of electrons by default: convert=true

return the rms on the readout strip in ADC count or Number of Electrons

ADC counts initialized with m_noise...

Definition at line 173 of file CscCalibTool.cxx.

{
  ATH_MSG_VERBOSE ( "The strip hash id is " <<  stripHashId );
 
  float rms = m_noise;  
  if ( m_readFromDatabase ) {
    SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
    const CscCondDbData* readCdo{*readHandle};
    if(!readCdo->readChannelRMS(stripHashId, rms).isSuccess()){
      ATH_MSG_DEBUG ( " failed to access CSC conditions database - rms - " 
                      << "strip hash id = " << stripHashId );
      rms = m_noise;
    } 
  } 
  
  ATH_MSG_VERBOSE ( "The RMS is " << rms << " for strip hash = " << stripHashId ); 
 
  if ( convert ) {
    float slope = getPSlope(stripHashId);
    return this->adcCountToNumberOfElectrons( rms, slope );
  }  else {
    return rms;
  }
  
}

stripStatusBit()

int CscCalibTool::stripStatusBit ( uint32_t stripHashId ) const

finaloverridevirtual

return status bit

Definition at line 265 of file CscCalibTool.cxx.

                                                              {
 
  int status = 0; 
  if ( m_readFromDatabase ) {
    SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
    const CscCondDbData* readCdo{*readHandle};
    if(!readCdo->readChannelStatus(stripHashId, status).isSuccess())
      ATH_MSG_WARNING ( " failed to access CSC conditions database - status - "
                        << "strip hash id = " << stripHashId );
    else
      ATH_MSG_VERBOSE("The status word is " << std::hex << status << 
                      " for strip hash = " << std::dec << stripHashId);
  }
  return status;
}

stripT0base()

double CscCalibTool::stripT0base ( uint32_t stripHashId ) const

finaloverridevirtual

return T0base related to 5 ASM.

For convenience, we use stripHashId to get it

Definition at line 307 of file CscCalibTool.cxx.

                                                              {
 
  float t0base = 0.0;
  if (! m_onlineHLT ) {
    if ( m_readFromDatabase ) {
      SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
      const CscCondDbData* readCdo{*readHandle};
      if(!readCdo->readChannelT0Base(stripHashId, t0base).isSuccess()){
        
        if (m_messageCnt_t0base < 3) {
          ATH_MSG_WARNING ( " failed to access CSC conditions database - t0base - "
                            << "strip hash id = " << stripHashId );
          ATH_MSG_WARNING ( " This WARNING Message can be temporarily until COOL DB is filled");
          ++m_messageCnt_t0base;
        }
      } else {
        ATH_MSG_VERBOSE ( "The t0base is " << t0base << " for stripHashId " << stripHashId );
      }
    }
  }
  return t0base;
}

stripT0phase()

bool CscCalibTool::stripT0phase ( uint32_t stripHashId ) const

finaloverridevirtual

return T0phase related to 5 ASM.

For convenience, we use stripHashId to get it

Definition at line 283 of file CscCalibTool.cxx.

                                                             {
 
  bool t0phase = 0;
 
  if (! m_onlineHLT ) {
    if ( m_readFromDatabase ) {
      SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
      const CscCondDbData* readCdo{*readHandle};
      if(!readCdo->readChannelT0Phase(stripHashId, t0phase).isSuccess()){
        if (m_messageCnt_t0phase < 3) {
          ATH_MSG_WARNING ( " failed to access CSC conditions database - t0phase - "
                            << "strip hash id = " << stripHashId );
          ATH_MSG_WARNING ( " This WARNING Message can be temporarily until COOL DB is filled");
          ++m_messageCnt_t0phase;
        }
      } else {
        ATH_MSG_VERBOSE ( "The t0phase is " << t0phase << " for stripHashId " << stripHashId );
      }
    }
  }
  return t0phase;
}

Member Data Documentation

m_integrationNumber

double CscCalibTool::m_integrationNumber

protected

ROOT version of bipolar function.

Definition at line 159 of file CscCalibTool.h.

m_integrationNumber2

double CscCalibTool::m_integrationNumber2

protected

Definition at line 160 of file CscCalibTool.h.

m_latency

double CscCalibTool::m_latency

protected

Definition at line 166 of file CscCalibTool.h.

m_messageCnt_t0base

std::atomic_int CscCalibTool::m_messageCnt_t0base {}

mutable

Definition at line 131 of file CscCalibTool.h.

{};

m_messageCnt_t0phase

std::atomic_int CscCalibTool::m_messageCnt_t0phase {}

mutable

Definition at line 132 of file CscCalibTool.h.

{};

m_noise

float CscCalibTool::m_noise

protected

Definition at line 152 of file CscCalibTool.h.

m_nSamples

unsigned int CscCalibTool::m_nSamples

protected

Definition at line 168 of file CscCalibTool.h.

m_onlineHLT

bool CscCalibTool::m_onlineHLT

protected

Definition at line 170 of file CscCalibTool.h.

m_pedestal

float CscCalibTool::m_pedestal

protected

Definition at line 153 of file CscCalibTool.h.

m_readFromDatabase

bool CscCalibTool::m_readFromDatabase

protected

Definition at line 148 of file CscCalibTool.h.

m_readKey

SG::ReadCondHandleKey<CscCondDbData> CscCalibTool::m_readKey {this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"}

protected

Definition at line 146 of file CscCalibTool.h.

{this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"};   

m_samplingTime

double CscCalibTool::m_samplingTime

protected

Definition at line 162 of file CscCalibTool.h.

m_signalWidth

double CscCalibTool::m_signalWidth

protected

Definition at line 163 of file CscCalibTool.h.

m_slope

float CscCalibTool::m_slope

protected

Definition at line 151 of file CscCalibTool.h.

m_slopeFromDatabase

bool CscCalibTool::m_slopeFromDatabase

protected

Definition at line 149 of file CscCalibTool.h.

m_timeOffset

double CscCalibTool::m_timeOffset

protected

Definition at line 164 of file CscCalibTool.h.

m_use2Samples

bool CscCalibTool::m_use2Samples

protected

Definition at line 171 of file CscCalibTool.h.

---

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

• CscCalibTool.h
• CscCalibTool.cxx