L1CaloPprPhos4Shape Class Reference

#include <L1CaloPprPhos4Shape.h>

Inheritance diagram for L1CaloPprPhos4Shape:

Collaboration diagram for L1CaloPprPhos4Shape:

Public Types
enum	CaloLayer { LAYER_NOT_SET = 0, EM = 1, HAD = 2 }

Public Member Functions
	L1CaloPprPhos4Shape (const L1CaloCoolChannelId &coolId)
	~L1CaloPprPhos4Shape ()
void	SetMinimumSignalHeight (const unsigned int min)
unsigned int	GetMinimumSignalHeight (void) const
void	SetEta (const float eta)
float	GetEta (void) const
void	SetPhi (const float phi)
float	GetPhi (void) const
void	SetLayer (const CaloLayer layer)
CaloLayer	GetLayer (void) const
StatusCode	Fill (const unsigned int ns_step, const unsigned int adc)
	Fill the profile with the ADC values at each nanosecond step. More...
StatusCode	Fill (const unsigned int timeSlice, const unsigned int rodHeaderStep, const int adc)
	Fill the profile with the ADC values at each nanosecond step Here I can accept the rodHeaderStep and ADC time slice directly and I will calculate the nanosecond step. More...
StatusCode	Fill (const unsigned int rodHeaderStep, const std::vector< int > &adc)
	Fill the profile with the ADC values at each nanosecond step Here I can accept the rodHeaderStep and a vector of the ADC values, which should only contain as many entries as there are ADC time slices since I use the vector to determine the number of time slices. More...
StatusCode	Finalize (void)
	In finalize I want the profile to be processed and extract some useful characteristics like the peak value and the peak location. More...
TProfile *	GetRawSignalShape (void)
unsigned int	GetRawMaxPeakBin (void)
float	GetRawMaxPeakValue (void)
unsigned int	GetRawMaxFullDelayData (void)
unsigned int	GetRawFitPeakBin (void)
float	GetRawFitPeakValue (void)
unsigned int	GetRawFitFullDelayData (void)
bool	GetRawFitPerformed (void)
TF1 *	GetRawFit (void)
TH1F *	GetProcessedSignalShape (void)
unsigned int	GetProcessedMaxPeakBin (void)
float	GetProcessedMaxPeakValue (void)
unsigned int	GetProcessedMaxFullDelayData (void)
unsigned int	GetProcessedFitPeakBin (void)
float	GetProcessedFitPeakValue (void)
unsigned int	GetProcessedFitFullDelayData (void)
bool	GetProcessedFitPerformed (void)
TF1 *	GetProcessedFit (void)
unsigned int	GetRawPhos4Setting (void)
unsigned int	GetCoolId (void)
void	SetPedValue (unsigned int value)
void	SetL1aFadcSlice (unsigned int slice)
unsigned int	GetPedValue (void)
unsigned int	GetL1aFadcSlice (void)
float	GetRisingSlopeMean (void)
float	GetRisingSlopeSigma (void)
unsigned int	GetErrorCode (void)
float	GetPedestalMean (void)
float	GetPedestalSigma (void)
void	SetCurrentFullDelayData (unsigned int delay)
unsigned int	GetCurrentFullDelayData (void)
bool	IsValidChannel (void)
void	SetValidChannel (bool validity)
bool	IsEnabled (void)
void	SetEnabled (bool enabled)
bool	IsProcessed (void)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...
MsgStream &	msg () const
	The standard message stream. More...
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Private Member Functions
	L1CaloPprPhos4Shape ()
	L1CaloPprPhos4Shape (const L1CaloPprPhos4Shape &rhs)
void	operator= (const L1CaloPprPhos4Shape &rhs)
unsigned int	CalculateFullDelayData (const int truePeakPosition)
void	CorrectRawPedestal (void)
void	CalculatePedCorrection (void)
void	CalculatePedestal (TH1 *histo, float &pedMean, float &pedSigma)
void	FindBinWithMaxValue (TH1 *histo, float &peakValue, unsigned int &peakBin)
	Given a signal profile, this finds the maximum value and it's corresponding bin. More...
TF1 *	FitSignalPeak (TH1 *histo, const float maxPeakValue, const unsigned int maxPeakBin, const unsigned int pedestal, float &fitPeakValue, unsigned int &fitPeakBin)
	Given a signal profile, this finds the maximum value and it's corresponding bin. More...
void	FillErrorCode (bool signalIsPresent, bool signalIsSaturated)
bool	IsSignalPresent (TH1 *histo, const unsigned int threshold) const
bool	IsSignalSaturated (TH1 *histo, const unsigned int saturationPoint) const
void	CheckRisingSlope (TH1 *histo, unsigned int peakBin, float peakValue)
std::string	GetPlotName (const std::string &base, const L1CaloCoolChannelId &coolId) const
std::string	GetPlotTitle (const std::string &base, const L1CaloCoolChannelId &coolId) const
std::string	CoolIdToString (const L1CaloCoolChannelId &coolId) const
void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
unsigned int	m_minSignalHeight
L1CaloCoolChannelId	m_coolId
float	m_eta
float	m_phi
CaloLayer	m_layer
bool	m_isValid
bool	m_isEnabled
unsigned int	m_currentFullDelayData
unsigned int	m_pedValue
unsigned int	m_l1aFadcSlice
ChanCalibErrorCode	m_errorCode
TProfile *	m_raw_signalShape
float	m_raw_maxPeakValue
unsigned int	m_raw_maxPeakBin
unsigned int	m_raw_maxFullDelayData
float	m_raw_fitPeakValue
unsigned int	m_raw_fitPeakBin
unsigned int	m_raw_fitFullDelayData
bool	m_raw_fitPerformed
TF1 *	m_raw_fit
float	m_rawPedestalMean
float	m_rawPedestalSigma
std::vector< unsigned int >	m_pedCorrectionSum
std::vector< unsigned int >	m_pedCorrectionSum2
std::vector< unsigned int >	m_pedCorrectionN
std::vector< float >	m_pedCorrectionMean
std::vector< float >	m_pedCorrectionSigma
TH1F *	m_processed_signalShape
float	m_processed_maxPeakValue
unsigned int	m_processed_maxPeakBin
unsigned int	m_processed_maxFullDelayData
float	m_processed_fitPeakValue
unsigned int	m_processed_fitPeakBin
unsigned int	m_processed_fitFullDelayData
bool	m_processed_fitPerformed
TF1 *	m_processed_fit
float	m_risingSlopeMean
float	m_risingSlopeSigma
bool	m_processSignalShape
std::string	m_nm
	Message source name. More...
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Static Private Attributes
static const unsigned int	MAX_ADC_TIME_SLICES = 15
static const unsigned int	NANOSEC_PER_LHC_CLOCK_TICK = 25
static const unsigned int	MAX_PEDESTAL_SIGMA = 4
static const unsigned int	SATURATED_ADC = 1000

Detailed Description

Definition at line 86 of file L1CaloPprPhos4Shape.h.

Member Enumeration Documentation

CaloLayer

enum L1CaloPprPhos4Shape::CaloLayer

Enumerator
LAYER_NOT_SET
EM
HAD

Definition at line 92 of file L1CaloPprPhos4Shape.h.

                  {
      LAYER_NOT_SET = 0,
      EM = 1,
      HAD = 2
   };

Constructor & Destructor Documentation

L1CaloPprPhos4Shape() [1/3]

L1CaloPprPhos4Shape::L1CaloPprPhos4Shape

(

const L1CaloCoolChannelId &

coolId

)

Definition at line 17 of file L1CaloPprPhos4Shape.cxx.

                                                                          :
   AthMessaging("L1CaloPprPhos4Shape"),
   m_minSignalHeight                (30),
   m_coolId                         (coolId),
   m_eta                            (999),
   m_phi                            (999),
   m_layer                          (LAYER_NOT_SET),
   m_isValid                        (true),
   m_isEnabled                      (true),
   m_currentFullDelayData           (0),
   m_pedValue                       (0),
   m_l1aFadcSlice                   (0)
{
   // setup raw signal profile.
   m_raw_signalShape = new TProfile(GetPlotName("rawSignalShape",m_coolId).c_str(),GetPlotTitle("",m_coolId).c_str(),MAX_ADC_TIME_SLICES*NANOSEC_PER_LHC_CLOCK_TICK,0,MAX_ADC_TIME_SLICES*NANOSEC_PER_LHC_CLOCK_TICK);
//    sm_raw_signalShape->GetXaxis()->SetTitle("nanosecond steps");
   
   m_raw_maxPeakValue               = 0.;
   m_raw_maxPeakBin                 = 0;
   m_raw_maxFullDelayData           = 0;
   m_raw_fitPeakValue               = 0.;
   m_raw_fitPeakBin                 = 0;
   m_raw_fitFullDelayData           = 0;
   m_raw_fitPerformed               = true;
   
   m_raw_fit                        = 0;
   
   m_rawPedestalMean                = 0.;
   m_rawPedestalSigma               = 0.;
   
   // I use the first 50 entries, which should all be pedestal level, to
   // correct for the nanosecond depedent PHOS4 correction.
   m_pedCorrectionSum.resize(NANOSEC_PER_LHC_CLOCK_TICK,0);
   m_pedCorrectionSum2.resize(NANOSEC_PER_LHC_CLOCK_TICK,0);
   m_pedCorrectionN.resize(NANOSEC_PER_LHC_CLOCK_TICK,0);
   m_pedCorrectionMean.resize(NANOSEC_PER_LHC_CLOCK_TICK,0.0);
   m_pedCorrectionSigma.resize(NANOSEC_PER_LHC_CLOCK_TICK,0.0);
   
   m_processed_signalShape          = 0;
   m_processed_maxPeakValue         = 0.;
   m_processed_maxPeakBin           = 0;
   m_processed_maxFullDelayData     = 0;
   m_processed_fitPeakValue         = 0.;
   m_processed_fitPeakBin           = 0;
   m_processed_fitFullDelayData     = 0;
   m_processed_fitPerformed         = true;
   
   m_processed_fit                  = 0;
   
   m_risingSlopeMean                = 0.;
   m_risingSlopeSigma               = 0.;
   
   m_processSignalShape = true;
   
}

~L1CaloPprPhos4Shape()

L1CaloPprPhos4Shape::~L1CaloPprPhos4Shape

(

)

Definition at line 73 of file L1CaloPprPhos4Shape.cxx.

                                             {
 
}

L1CaloPprPhos4Shape() [2/3]

L1CaloPprPhos4Shape::L1CaloPprPhos4Shape ( )

private

L1CaloPprPhos4Shape() [3/3]

L1CaloPprPhos4Shape::L1CaloPprPhos4Shape ( const L1CaloPprPhos4Shape &  rhs )

private

Member Function Documentation

CalculateFullDelayData()

unsigned int L1CaloPprPhos4Shape::CalculateFullDelayData ( const int  truePeakPosition )

private

Definition at line 352 of file L1CaloPprPhos4Shape.cxx.

                                                                                  {
   
   // Stephen Hillier derived this calculation
   
   // integer division to get the course timing delay
   const int courseDelay = (int)(m_currentFullDelayData/NANOSEC_PER_LHC_CLOCK_TICK);
   // base delay
   const int baseDelay   = courseDelay*NANOSEC_PER_LHC_CLOCK_TICK + 9;
   
   const int idealPeakPosition = m_l1aFadcSlice*NANOSEC_PER_LHC_CLOCK_TICK;
   const int dt = idealPeakPosition - truePeakPosition;
   
   const int newFullDelayData = (baseDelay + dt);
   if(newFullDelayData < 0){
      ATH_MSG_WARNING("[CalculateFullDelayData]: New Full Delay data was calculated as zero. Should only be greater than zero. Returning 0 for safety. Channel 0x" << CoolIdToString(m_coolId) << ". Peak position passed was: " << truePeakPosition << " and the idealPeakPosition is: " << idealPeakPosition);
      return 0;
   }
   
   return (unsigned int)newFullDelayData;
}

CalculatePedCorrection()

void L1CaloPprPhos4Shape::CalculatePedCorrection ( void  )

private

Definition at line 344 of file L1CaloPprPhos4Shape.cxx.

                                                    {
   for(unsigned int step=0;step<NANOSEC_PER_LHC_CLOCK_TICK;++step){
      m_pedCorrectionMean[step] = (m_pedCorrectionN[step] == 0) ? 0 : (float)m_pedCorrectionSum[step]/(float)m_pedCorrectionN[step];
      m_pedCorrectionSigma[step] = (m_pedCorrectionN[step] == 0) ? 0 : sqrt( (1.0/(float)m_pedCorrectionN[step])* (float)m_pedCorrectionSum2[step] - m_pedCorrectionMean[step]*m_pedCorrectionMean[step] );
   }
   
}

CalculatePedestal()

void L1CaloPprPhos4Shape::CalculatePedestal ( TH1 *  histo, float &  pedMean, float &  pedSigma  )

private

Definition at line 292 of file L1CaloPprPhos4Shape.cxx.

                                                                                    {
   
   if((unsigned int)histo->GetNbinsX() < NANOSEC_PER_LHC_CLOCK_TICK*2){
      ATH_MSG_WARNING("[CalculatePedestal] Could not calculate pedestal due to lack of bins in " << histo->GetName());
      return;
   }
   
   float pedSum=0,pedSum2=0;
   unsigned int pedN=0;
   for(unsigned int bin=1;bin<NANOSEC_PER_LHC_CLOCK_TICK*2;++bin){
      pedSum += histo->GetBinContent(bin);
      pedSum2 += histo->GetBinContent(bin)*histo->GetBinContent(bin);
      pedN++;
   }
   // pedN > 0 <=>  NANOSEC_PER_LHC_CLOCK_TICK > 0, which is protected by the above return
   pedMean = pedSum/(float)pedN;
   pedSigma = sqrt( (1.0/(float)pedN)*pedSum2 - pedMean*pedMean);
   
}

CheckRisingSlope()

void L1CaloPprPhos4Shape::CheckRisingSlope ( TH1 *  histo, unsigned int  peakBin, float  peakValue  )

private

Definition at line 462 of file L1CaloPprPhos4Shape.cxx.

                                                                                         {
   
   // want to only look at the slope from 10% to 90%
   const float peakValue10percent = peakValue*0.10;
   const float peakValue90percent = peakValue*0.90;
   unsigned int peakBin10percent = 0;
   unsigned int peakBin90percent = 0;
   for(unsigned int bin=peakBin;bin>0;--bin){
      if(histo->GetBinContent(bin) < peakValue10percent && peakBin10percent == 0){
         peakBin10percent = bin;
         break;
      }
      if(histo->GetBinContent(bin) < peakValue90percent && peakBin90percent == 0){
         peakBin90percent = bin;
      }
      
   }// end for(bin)
   
   //now calculate the mean and sigma instantaneous slope
   float sum=0,sum2=0;
   unsigned int n=0;
   for(unsigned int bin=peakBin10percent+1;bin<=peakBin90percent;++bin){
      float dydx = histo->GetBinContent(bin) - histo->GetBinContent(bin-1);
      // dx = 1 by definition so dy = dydx
      
      sum += dydx;
      sum2 += dydx*dydx;
      n++;
      
   }
   
   m_risingSlopeMean = (n == 0) ? 0 : sum/(float)n;
   m_risingSlopeSigma = (n == 0) ? 0 : sqrt( (1.0/(float)n)*sum2 - m_risingSlopeMean*m_risingSlopeMean);
   
}

CoolIdToString()

std::string L1CaloPprPhos4Shape::CoolIdToString ( const L1CaloCoolChannelId &  coolId ) const

private

Definition at line 508 of file L1CaloPprPhos4Shape.cxx.

                                                                                    {
   char temp[200];
   sprintf(temp,"%08x",coolId.id());
   std::string tempStr = temp;
   return tempStr;
}

CorrectRawPedestal()

void L1CaloPprPhos4Shape::CorrectRawPedestal ( void  )

private

Definition at line 312 of file L1CaloPprPhos4Shape.cxx.

                                                {
   
   // if the pedestal sigma is greater than this value we set
   // the pedestal is flat to false so that the correction is
   // not completed and the raw signal is used instead.
   m_processed_signalShape = new TH1F(GetPlotName("processedSignalShape",m_coolId).c_str(),GetPlotTitle("",m_coolId).c_str(),MAX_ADC_TIME_SLICES*NANOSEC_PER_LHC_CLOCK_TICK,0,MAX_ADC_TIME_SLICES*NANOSEC_PER_LHC_CLOCK_TICK);
   //m_processed_signalShape->GetXaxis()->SetTitle("nanosecond steps");
   
   if(m_rawPedestalSigma > MAX_PEDESTAL_SIGMA){
      m_processSignalShape = false;
   }
   else{
      CalculatePedCorrection();
      
      
      for(unsigned int bin=1;(int)bin<m_raw_signalShape->GetNbinsX();++bin){
         
         unsigned int phos4step = (bin - 1) % NANOSEC_PER_LHC_CLOCK_TICK;
         
         // add the bin content from the raw and pedestal correction
         m_processed_signalShape->SetBinContent(bin,m_raw_signalShape->GetBinContent(bin)-m_pedCorrectionMean[phos4step]);
         
         // calculate the error
         float error = sqrt(m_raw_signalShape->GetBinError(bin)*m_raw_signalShape->GetBinError(bin) + m_pedCorrectionSigma[phos4step]*m_pedCorrectionSigma[phos4step] );
         
         m_processed_signalShape->SetBinError(bin,error);
         
      }
   }
   
}

Fill() [1/3]

StatusCode L1CaloPprPhos4Shape::Fill	(	const unsigned int	ns_step,
		const unsigned int	adc
	)

Fill the profile with the ADC values at each nanosecond step.

Definition at line 78 of file L1CaloPprPhos4Shape.cxx.

                                                                                     {
   m_raw_signalShape->Fill(ns_step,adc);
   
   if(ns_step < NANOSEC_PER_LHC_CLOCK_TICK*2){
      const unsigned int phos4step = ns_step % NANOSEC_PER_LHC_CLOCK_TICK;
      m_pedCorrectionSum[phos4step] += adc;
      m_pedCorrectionSum2[phos4step] += adc*adc;
      ++m_pedCorrectionN[phos4step];
   }
   
   return StatusCode::SUCCESS;
}

Fill() [2/3]

StatusCode L1CaloPprPhos4Shape::Fill	(	const unsigned int	rodHeaderStep,
		const std::vector< int > &	adc
	)

Fill the profile with the ADC values at each nanosecond step Here I can accept the rodHeaderStep and a vector of the ADC values, which should only contain as many entries as there are ADC time slices since I use the vector to determine the number of time slices.

Definition at line 113 of file L1CaloPprPhos4Shape.cxx.

                                                                                              {
   const unsigned int phos4step = rodHeaderStep % NANOSEC_PER_LHC_CLOCK_TICK;
   
   for(unsigned int timeSlice = 0;timeSlice < adc.size();++timeSlice){
      const unsigned int ns_step = timeSlice*NANOSEC_PER_LHC_CLOCK_TICK + phos4step; 
      m_raw_signalShape->Fill(ns_step,adc[timeSlice]);
   }
   
   m_pedCorrectionSum[phos4step] += adc[0];
   m_pedCorrectionSum2[phos4step] += adc[0]*adc[0];
   ++m_pedCorrectionN[phos4step];
   
   m_pedCorrectionSum[phos4step] += adc[1];
   m_pedCorrectionSum2[phos4step] += adc[1]*adc[1];
   ++m_pedCorrectionN[phos4step];
   
   return StatusCode::SUCCESS;
}

Fill() [3/3]

StatusCode L1CaloPprPhos4Shape::Fill	(	const unsigned int	timeSlice,
		const unsigned int	rodHeaderStep,
		const int	adc
	)

Fill the profile with the ADC values at each nanosecond step Here I can accept the rodHeaderStep and ADC time slice directly and I will calculate the nanosecond step.

Definition at line 94 of file L1CaloPprPhos4Shape.cxx.

                                                                                                               {
   const unsigned int phos4step = rodHeaderStep % NANOSEC_PER_LHC_CLOCK_TICK;
   const unsigned int ns_step = timeSlice*NANOSEC_PER_LHC_CLOCK_TICK + phos4step; 
   m_raw_signalShape->Fill(ns_step,adc);
   
   if(ns_step < NANOSEC_PER_LHC_CLOCK_TICK*2){
      m_pedCorrectionSum[phos4step] += adc;
      m_pedCorrectionSum2[phos4step] += adc*adc;
      ++m_pedCorrectionN[phos4step];
   }
   
   return StatusCode::SUCCESS;
}

FillErrorCode()

void L1CaloPprPhos4Shape::FillErrorCode ( bool  signalIsPresent, bool  signalIsSaturated  )

private

Definition at line 373 of file L1CaloPprPhos4Shape.cxx.

                                                                                  {
   
   // if the signal is not present set the bad data bit
   if(!signalIsPresent){
      ATH_MSG_WARNING("[FillErrorCode] Set bad data bit because signal not present. Channel 0x" << CoolIdToString(m_coolId));
      m_errorCode.badData(true);
      m_errorCode.phos4ScanNoSignal(true);
      
      // fill FullDelayData variables with current database value for safety
      m_raw_maxFullDelayData = m_currentFullDelayData;
      m_raw_fitFullDelayData = m_currentFullDelayData;
      m_processed_maxFullDelayData = m_currentFullDelayData;
      m_processed_fitFullDelayData = m_currentFullDelayData;
      return;
   }
   
   if(signalIsSaturated){
      ATH_MSG_WARNING("[FillErrorCode] Set bad data bit because signal is saturated. Channel 0x" << CoolIdToString(m_coolId));
      m_errorCode.badData(true);
      m_errorCode.phos4ScanSignalSaturated(true);
      
      // fill FullDelayData variables with current database value for safety
      m_raw_maxFullDelayData = m_currentFullDelayData;
      m_raw_fitFullDelayData = m_currentFullDelayData;
      m_processed_maxFullDelayData = m_currentFullDelayData;
      m_processed_fitFullDelayData = m_currentFullDelayData;
      
   }
   
   if(m_processSignalShape)
      CheckRisingSlope(m_processed_signalShape,m_processed_maxPeakBin,m_processed_maxPeakValue);
   else
      CheckRisingSlope(m_raw_signalShape,m_raw_maxPeakBin,m_raw_maxPeakValue);
   
   // if no Mean or sigma was calculated this usually indicates a bad signal shape
   if((m_risingSlopeMean < 0.0001 || m_risingSlopeSigma < 0.0001)){
      ATH_MSG_WARNING("[FillErrorCode] Set bad data bit because the signal shape is corrupt. Channel 0x" << CoolIdToString(m_coolId));
      m_errorCode.badData(true);
      ATH_MSG_WARNING("[FillErrorCode] Set phos4 scan bad signal bit because the signal shape is corrupt. Channel 0x" << CoolIdToString(m_coolId));
      m_errorCode.phos4ScanBadSignal(true);
      
      
      // fill FullDelayData variables with current database value for safety
      m_raw_maxFullDelayData = m_currentFullDelayData;
      m_raw_fitFullDelayData = m_currentFullDelayData;
      m_processed_maxFullDelayData = m_currentFullDelayData;
      m_processed_fitFullDelayData = m_currentFullDelayData;
   }
   else if( m_risingSlopeSigma > 10.0){
      ATH_MSG_WARNING("[FillErrorCode] Set bad data because the signal rising edge instantaneous slope has a large sigma. Channel 0x" << CoolIdToString(m_coolId));
      m_errorCode.badData(true);
      ATH_MSG_WARNING("[FillErrorCode] Set phos4 scan bad signal bit because the signal rising edge instantaneous slope has a large sigma. Channel 0x" << CoolIdToString(m_coolId));
      m_errorCode.phos4ScanBadSignal(true);
      
      
      // fill FullDelayData variables with current database value for safety
      m_raw_maxFullDelayData = m_currentFullDelayData;
      m_raw_fitFullDelayData = m_currentFullDelayData;
      m_processed_maxFullDelayData = m_currentFullDelayData;
      m_processed_fitFullDelayData = m_currentFullDelayData;
   }
   
   
}

Finalize()

StatusCode L1CaloPprPhos4Shape::Finalize

(

void

)

In finalize I want the profile to be processed and extract some useful characteristics like the peak value and the peak location.

Definition at line 135 of file L1CaloPprPhos4Shape.cxx.

                                            {
   
   
   // calculate pedestal with first 50 ns steps
   CalculatePedestal(m_raw_signalShape,m_rawPedestalMean,m_rawPedestalSigma);
   const unsigned int pedestal = (unsigned int)m_rawPedestalMean;
   // use pedestal + minSignalHeight as the cut unless it is lower than 6sigma
   unsigned int signalCut = m_minSignalHeight;
   if(signalCut < (unsigned int)(m_rawPedestalSigma*6.))
      signalCut = (unsigned int)(m_rawPedestalSigma*6.);
   
   // signal cut above pedestal
   signalCut += pedestal;
 
   bool signalIsPresent = IsSignalPresent(m_raw_signalShape,signalCut);
   
   if(!signalIsPresent || !m_isValid || !m_isEnabled){
      // subtract the pedestal correction from the raw signal
      CorrectRawPedestal();
      
      FillErrorCode(signalIsPresent,false);
      
      return StatusCode::SUCCESS;
   }
   
   // check if the signal is saturated
   const unsigned short int saturationLevel = 1020;
   bool signalIsSaturated = IsSignalSaturated(m_raw_signalShape,saturationLevel);
   // if signal is saturated, don't fit signals
   if(signalIsSaturated){
      m_raw_fitPerformed = false;
      m_processed_fitPerformed = false;
   }
   
   // find the peak value and location for the raw signal
   FindBinWithMaxValue(m_raw_signalShape,m_raw_maxPeakValue,m_raw_maxPeakBin);
   // calculate the fullDelayData for these max values
   m_raw_maxFullDelayData = CalculateFullDelayData(m_raw_maxPeakBin - 1);
   // find the peak value and location using landau/gaus fit
   if(m_raw_fitPerformed){
      m_raw_fit = FitSignalPeak(m_raw_signalShape,m_raw_maxPeakValue,m_raw_maxPeakBin,m_pedValue,m_raw_fitPeakValue,m_raw_fitPeakBin);
      std::string rawFitName = "raw_";
      rawFitName += m_raw_fit->GetName();
      m_raw_fit->SetName(rawFitName.c_str());
      // calculate the fullDelayData for these fitvalues
      m_raw_fitFullDelayData = CalculateFullDelayData(m_raw_fitPeakBin - 1);
   }
   
   // find the peak value and location for the corrected signal
   // and calculate the new FullDataDelay
   if(m_processSignalShape){
      // subtract the pedestal correction from the raw signal
      CorrectRawPedestal();
      
      FindBinWithMaxValue(m_processed_signalShape,m_processed_maxPeakValue,m_processed_maxPeakBin);
      // calculate the fullDelayData for these fitvalues
      m_processed_maxFullDelayData = CalculateFullDelayData(m_processed_maxPeakBin - 1);
      
      
      // find the peak value and location using landau/gaus fit
      if(m_processed_fitPerformed){
         m_processed_fit = FitSignalPeak(m_processed_signalShape,m_processed_maxPeakValue,m_processed_maxPeakBin,0,m_processed_fitPeakValue,m_processed_fitPeakBin);
         
         std::string processedFitName = "processed_";
         processedFitName += m_processed_fit->GetName();
         m_processed_fit->SetName(processedFitName.c_str());
         
         // calculate the fullDelayData for these fitvalues
         m_processed_fitFullDelayData = CalculateFullDelayData(m_processed_fitPeakBin - 1);
      }
   }
   
   // Fill Error Code
   FillErrorCode(signalIsPresent,signalIsSaturated);
   
   return StatusCode::SUCCESS;
}

FindBinWithMaxValue()

void L1CaloPprPhos4Shape::FindBinWithMaxValue ( TH1 *  histo, float &  peakValue, unsigned int &  peakBin  )

private

Given a signal profile, this finds the maximum value and it's corresponding bin.

Definition at line 214 of file L1CaloPprPhos4Shape.cxx.

                                                                                              {
   
   peakValue = 0;
   peakBin = 0;
   for(unsigned int bin=1;(int)bin<=histo->GetNbinsX();++bin){
      if(peakValue < histo->GetBinContent(bin)){
         peakValue = histo->GetBinContent(bin);
         peakBin = bin;
      }
   }
}

FitSignalPeak()

TF1 * L1CaloPprPhos4Shape::FitSignalPeak ( TH1 *  histo, const float  maxPeakValue, const unsigned int  maxPeakBin, const unsigned int  pedestal, float &  fitPeakValue, unsigned int &  fitPeakBin  )

private

Given a signal profile, this finds the maximum value and it's corresponding bin.

Definition at line 226 of file L1CaloPprPhos4Shape.cxx.

                                                                                                                                                                                 {
   
   fitPeakValue = 0.;
   fitPeakBin = 0;
   
   const unsigned int fitRangeWidth = 13;
   const unsigned int minFitRange   = maxPeakBin - fitRangeWidth - 1; // -1 for bin to ns correction
   const unsigned int maxFitRange   = maxPeakBin + fitRangeWidth - 1;
   
   LandGaussFunc *fitFunc = new LandGaussFunc;
   
   std::string fitName = "fit_" + CoolIdToString(m_coolId);
   TF1* fit = new TF1(fitName.c_str(),fitFunc,minFitRange,maxFitRange,5);
   // fix the pedestal value
   fit->FixParameter(4,pedestal);
   
   // constrain the mean position
//    const unsigned int xmax_min = 0, xmax_max = 15*25;
//    fit->SetParLimits(0,xmax_min,xmax_max);
   // set initial mean position to that of the maximum bin
   const unsigned int xmax_init = maxPeakBin-1;
   fit->SetParameter(0,xmax_init);
   
   // constrain the amplitude
//    const unsigned int amp_min = m_minSignalHeight+pedestal, amp_max = 1020;
//    fit->SetParLimits(1,amp_min,amp_max);
   // set initial amplitude
   const float amp_init = (maxPeakValue-pedestal)*exp(0.5);
   fit->SetParameter(1,amp_init);
   
   // constrain the sigma gaus
//    const unsigned int gSigma_min = 1, gSigma_max = 60;
//    fit->SetParLimits(2,gSigma_min,gSigma_max);
   // set initial sigma gaus
   const unsigned int gSigma_init = 25;
   fit->SetParameter(2,gSigma_init);
   
   // constrain the sigma landau
//    const unsigned int lSigma_min = 1, lSigma_max = 60;
//    fit->SetParLimits(3,lSigma_min,lSigma_max);
   // set initial sigma gaus
   const unsigned int lSigma_init = 15;
   fit->SetParameter(3,lSigma_init);
   
   histo->Fit(fit,"qurnob");
   
   
   
//    const float x_max = fit->GetParameter(0);
   const float ampl  = fit->GetParameter(1);
//    const float gSigma = fit->GetParameter(2);
//    const float lSigma = fit->GetParameter(3);
//    const float ped   = fit->GetParameter(4);
   
   fitPeakValue = ampl*exp(-0.5)+pedestal;
   // +0.5 deals with rounding. If fitPeakValue is between x.0 and x.49
   // the bin should not change after adding 0.5, but if it is x.5 to x.9
   // the bin should be assigned to the next bin (so rounding up)
   fitPeakBin = histo->FindBin(fit->GetParameter(0));
   
   delete fitFunc;
   fitFunc = 0;
   
   return fit;
}

GetCoolId()

unsigned int L1CaloPprPhos4Shape::GetCoolId ( void  )

inline

Definition at line 140 of file L1CaloPprPhos4Shape.h.

{return m_coolId.id();};

GetCurrentFullDelayData()

unsigned int L1CaloPprPhos4Shape::GetCurrentFullDelayData ( void  )

inline

Definition at line 157 of file L1CaloPprPhos4Shape.h.

{return m_currentFullDelayData;};

GetErrorCode()

unsigned int L1CaloPprPhos4Shape::GetErrorCode ( void  )

inline

Definition at line 151 of file L1CaloPprPhos4Shape.h.

{return m_errorCode.errorCode();};

GetEta()

float L1CaloPprPhos4Shape::GetEta ( void  ) const

inline

Definition at line 102 of file L1CaloPprPhos4Shape.h.

{return m_eta;};

GetL1aFadcSlice()

unsigned int L1CaloPprPhos4Shape::GetL1aFadcSlice ( void  )

inline

Definition at line 146 of file L1CaloPprPhos4Shape.h.

{return m_l1aFadcSlice;};

GetLayer()

CaloLayer L1CaloPprPhos4Shape::GetLayer ( void  ) const

inline

Definition at line 108 of file L1CaloPprPhos4Shape.h.

{return m_layer;};

GetMinimumSignalHeight()

unsigned int L1CaloPprPhos4Shape::GetMinimumSignalHeight ( void  ) const

inline

Definition at line 99 of file L1CaloPprPhos4Shape.h.

{return m_minSignalHeight;};

GetPedestalMean()

float L1CaloPprPhos4Shape::GetPedestalMean ( void  )

inline

Definition at line 153 of file L1CaloPprPhos4Shape.h.

{return m_rawPedestalMean;};

GetPedestalSigma()

float L1CaloPprPhos4Shape::GetPedestalSigma ( void  )

inline

Definition at line 154 of file L1CaloPprPhos4Shape.h.

{return m_rawPedestalSigma;};

GetPedValue()

unsigned int L1CaloPprPhos4Shape::GetPedValue ( void  )

inline

Definition at line 145 of file L1CaloPprPhos4Shape.h.

{return m_pedValue;};

GetPhi()

float L1CaloPprPhos4Shape::GetPhi ( void  ) const

inline

Definition at line 105 of file L1CaloPprPhos4Shape.h.

{return m_phi;};

GetPlotName()

std::string L1CaloPprPhos4Shape::GetPlotName ( const std::string &  base, const L1CaloCoolChannelId &  coolId  ) const

private

Definition at line 498 of file L1CaloPprPhos4Shape.cxx.

                                                                                                        {
   std::string tempStr = base + "_" + CoolIdToString(coolId);
   return tempStr;
}

GetPlotTitle()

std::string L1CaloPprPhos4Shape::GetPlotTitle ( const std::string &  base, const L1CaloCoolChannelId &  coolId  ) const

private

Definition at line 503 of file L1CaloPprPhos4Shape.cxx.

                                                                                                         {
   std::string tempStr = base + " " + CoolIdToString(coolId);
   return tempStr;
}

GetProcessedFit()

TF1* L1CaloPprPhos4Shape::GetProcessedFit ( void  )

inline

Definition at line 136 of file L1CaloPprPhos4Shape.h.

{return m_processed_fit;};

GetProcessedFitFullDelayData()

unsigned int L1CaloPprPhos4Shape::GetProcessedFitFullDelayData ( void  )

inline

Definition at line 133 of file L1CaloPprPhos4Shape.h.

{return m_processed_fitFullDelayData;};

GetProcessedFitPeakBin()

unsigned int L1CaloPprPhos4Shape::GetProcessedFitPeakBin ( void  )

inline

Definition at line 131 of file L1CaloPprPhos4Shape.h.

{return m_processed_fitPeakBin;};

GetProcessedFitPeakValue()

float L1CaloPprPhos4Shape::GetProcessedFitPeakValue ( void  )

inline

Definition at line 132 of file L1CaloPprPhos4Shape.h.

{return m_processed_fitPeakValue;};

GetProcessedFitPerformed()

bool L1CaloPprPhos4Shape::GetProcessedFitPerformed ( void  )

inline

Definition at line 134 of file L1CaloPprPhos4Shape.h.

{return m_processed_fitPerformed;};

GetProcessedMaxFullDelayData()

unsigned int L1CaloPprPhos4Shape::GetProcessedMaxFullDelayData ( void  )

inline

Definition at line 130 of file L1CaloPprPhos4Shape.h.

{return m_processed_maxFullDelayData;};

GetProcessedMaxPeakBin()

unsigned int L1CaloPprPhos4Shape::GetProcessedMaxPeakBin ( void  )

inline

Definition at line 128 of file L1CaloPprPhos4Shape.h.

{return m_processed_maxPeakBin;};

GetProcessedMaxPeakValue()

float L1CaloPprPhos4Shape::GetProcessedMaxPeakValue ( void  )

inline

Definition at line 129 of file L1CaloPprPhos4Shape.h.

{return m_processed_maxPeakValue;};

GetProcessedSignalShape()

TH1F* L1CaloPprPhos4Shape::GetProcessedSignalShape ( void  )

inline

Definition at line 127 of file L1CaloPprPhos4Shape.h.

{return m_processed_signalShape;};

GetRawFit()

TF1* L1CaloPprPhos4Shape::GetRawFit ( void  )

inline

Definition at line 125 of file L1CaloPprPhos4Shape.h.

{return m_raw_fit;};

GetRawFitFullDelayData()

unsigned int L1CaloPprPhos4Shape::GetRawFitFullDelayData ( void  )

inline

Definition at line 122 of file L1CaloPprPhos4Shape.h.

{return m_raw_fitFullDelayData;};

GetRawFitPeakBin()

unsigned int L1CaloPprPhos4Shape::GetRawFitPeakBin ( void  )

inline

Definition at line 120 of file L1CaloPprPhos4Shape.h.

{return m_raw_fitPeakBin;};

GetRawFitPeakValue()

float L1CaloPprPhos4Shape::GetRawFitPeakValue ( void  )

inline

Definition at line 121 of file L1CaloPprPhos4Shape.h.

{return m_raw_fitPeakValue;};

GetRawFitPerformed()

bool L1CaloPprPhos4Shape::GetRawFitPerformed ( void  )

inline

Definition at line 123 of file L1CaloPprPhos4Shape.h.

{return m_raw_fitPerformed;};

GetRawMaxFullDelayData()

unsigned int L1CaloPprPhos4Shape::GetRawMaxFullDelayData ( void  )

inline

Definition at line 119 of file L1CaloPprPhos4Shape.h.

{return m_raw_maxFullDelayData;};

GetRawMaxPeakBin()

unsigned int L1CaloPprPhos4Shape::GetRawMaxPeakBin ( void  )

inline

Definition at line 117 of file L1CaloPprPhos4Shape.h.

{return m_raw_maxPeakBin;};

GetRawMaxPeakValue()

float L1CaloPprPhos4Shape::GetRawMaxPeakValue ( void  )

inline

Definition at line 118 of file L1CaloPprPhos4Shape.h.

{return m_raw_maxPeakValue;};

GetRawPhos4Setting()

unsigned int L1CaloPprPhos4Shape::GetRawPhos4Setting ( void  )

inline

Definition at line 138 of file L1CaloPprPhos4Shape.h.

{return ((m_processed_maxPeakBin - 1) % 25);};

GetRawSignalShape()

TProfile* L1CaloPprPhos4Shape::GetRawSignalShape ( void  )

inline

Definition at line 116 of file L1CaloPprPhos4Shape.h.

{return m_raw_signalShape;};

GetRisingSlopeMean()

float L1CaloPprPhos4Shape::GetRisingSlopeMean ( void  )

inline

Definition at line 148 of file L1CaloPprPhos4Shape.h.

{return m_risingSlopeMean;};

GetRisingSlopeSigma()

float L1CaloPprPhos4Shape::GetRisingSlopeSigma ( void  )

inline

Definition at line 149 of file L1CaloPprPhos4Shape.h.

{return m_risingSlopeSigma;};

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();
  m_lvl = m_imsg ?
    static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
    MSG::INFO;
}

IsEnabled()

bool L1CaloPprPhos4Shape::IsEnabled ( void  )

inline

Definition at line 162 of file L1CaloPprPhos4Shape.h.

{return m_isEnabled;};

IsProcessed()

bool L1CaloPprPhos4Shape::IsProcessed ( void  )

inline

Definition at line 165 of file L1CaloPprPhos4Shape.h.

{return m_processSignalShape;};

IsSignalPresent()

bool L1CaloPprPhos4Shape::IsSignalPresent ( TH1 *  histo, const unsigned int  threshold  ) const

private

Definition at line 440 of file L1CaloPprPhos4Shape.cxx.

                                                                                      {
   for(unsigned int bin=1;bin<=(unsigned int)histo->GetNbinsX();++bin){
      if(histo->GetBinContent(bin) > threshold){
         return true;
      }
   }
   return false;
}

IsSignalSaturated()

bool L1CaloPprPhos4Shape::IsSignalSaturated ( TH1 *  histo, const unsigned int  saturationPoint  ) const

private

Definition at line 450 of file L1CaloPprPhos4Shape.cxx.

                                                                                              {
   for(unsigned int bin=1;bin<=(unsigned int)histo->GetNbinsX();++bin){
      if(histo->GetBinContent(bin) >= saturationPoint){
         return true;
      }
   }
   return false;
}

IsValidChannel()

bool L1CaloPprPhos4Shape::IsValidChannel ( void  )

inline

Definition at line 159 of file L1CaloPprPhos4Shape.h.

{return m_isValid;};

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 164 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 179 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_initialized.test_and_set()) initMessaging();
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

operator=()

void L1CaloPprPhos4Shape::operator= ( const L1CaloPprPhos4Shape &  rhs )

private

SetCurrentFullDelayData()

void L1CaloPprPhos4Shape::SetCurrentFullDelayData ( unsigned int  delay )

inline

Definition at line 156 of file L1CaloPprPhos4Shape.h.

{m_currentFullDelayData = delay;};

SetEnabled()

void L1CaloPprPhos4Shape::SetEnabled ( bool  enabled )

inline

Definition at line 163 of file L1CaloPprPhos4Shape.h.

{m_isEnabled = enabled;};

SetEta()

void L1CaloPprPhos4Shape::SetEta ( const float  eta )

inline

Definition at line 101 of file L1CaloPprPhos4Shape.h.

{m_eta = eta;};

SetL1aFadcSlice()

void L1CaloPprPhos4Shape::SetL1aFadcSlice ( unsigned int  slice )

inline

Definition at line 143 of file L1CaloPprPhos4Shape.h.

{m_l1aFadcSlice = slice;};

SetLayer()

void L1CaloPprPhos4Shape::SetLayer ( const CaloLayer  layer )

inline

Definition at line 107 of file L1CaloPprPhos4Shape.h.

{m_layer = layer;};

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;
}

SetMinimumSignalHeight()

void L1CaloPprPhos4Shape::SetMinimumSignalHeight ( const unsigned int  min )

inline

Definition at line 98 of file L1CaloPprPhos4Shape.h.

{m_minSignalHeight = min;};

SetPedValue()

void L1CaloPprPhos4Shape::SetPedValue ( unsigned int  value )

inline

Definition at line 142 of file L1CaloPprPhos4Shape.h.

{m_pedValue = value;};

SetPhi()

void L1CaloPprPhos4Shape::SetPhi ( const float  phi )

inline

Definition at line 104 of file L1CaloPprPhos4Shape.h.

{m_phi = phi;};

SetValidChannel()

void L1CaloPprPhos4Shape::SetValidChannel ( bool  validity )

inline

Definition at line 160 of file L1CaloPprPhos4Shape.h.

{m_isValid = validity;};

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_coolId

L1CaloCoolChannelId L1CaloPprPhos4Shape::m_coolId

private

Definition at line 176 of file L1CaloPprPhos4Shape.h.

m_currentFullDelayData

unsigned int L1CaloPprPhos4Shape::m_currentFullDelayData

private

Definition at line 184 of file L1CaloPprPhos4Shape.h.

m_errorCode

ChanCalibErrorCode L1CaloPprPhos4Shape::m_errorCode

private

Definition at line 188 of file L1CaloPprPhos4Shape.h.

m_eta

float L1CaloPprPhos4Shape::m_eta

private

Definition at line 177 of file L1CaloPprPhos4Shape.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_isEnabled

bool L1CaloPprPhos4Shape::m_isEnabled

private

Definition at line 182 of file L1CaloPprPhos4Shape.h.

m_isValid

bool L1CaloPprPhos4Shape::m_isValid

private

Definition at line 181 of file L1CaloPprPhos4Shape.h.

m_l1aFadcSlice

unsigned int L1CaloPprPhos4Shape::m_l1aFadcSlice

private

Definition at line 186 of file L1CaloPprPhos4Shape.h.

m_layer

CaloLayer L1CaloPprPhos4Shape::m_layer

private

Definition at line 179 of file L1CaloPprPhos4Shape.h.

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

m_minSignalHeight

unsigned int L1CaloPprPhos4Shape::m_minSignalHeight

private

Definition at line 174 of file L1CaloPprPhos4Shape.h.

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_pedCorrectionMean

std::vector<float> L1CaloPprPhos4Shape::m_pedCorrectionMean

private

Definition at line 209 of file L1CaloPprPhos4Shape.h.

m_pedCorrectionN

std::vector<unsigned int> L1CaloPprPhos4Shape::m_pedCorrectionN

private

Definition at line 208 of file L1CaloPprPhos4Shape.h.

m_pedCorrectionSigma

std::vector<float> L1CaloPprPhos4Shape::m_pedCorrectionSigma

private

Definition at line 210 of file L1CaloPprPhos4Shape.h.

m_pedCorrectionSum

std::vector<unsigned int> L1CaloPprPhos4Shape::m_pedCorrectionSum

private

Definition at line 206 of file L1CaloPprPhos4Shape.h.

m_pedCorrectionSum2

std::vector<unsigned int> L1CaloPprPhos4Shape::m_pedCorrectionSum2

private

Definition at line 207 of file L1CaloPprPhos4Shape.h.

m_pedValue

unsigned int L1CaloPprPhos4Shape::m_pedValue

private

Definition at line 185 of file L1CaloPprPhos4Shape.h.

m_phi

float L1CaloPprPhos4Shape::m_phi

private

Definition at line 178 of file L1CaloPprPhos4Shape.h.

m_processed_fit

TF1* L1CaloPprPhos4Shape::m_processed_fit

private

Definition at line 221 of file L1CaloPprPhos4Shape.h.

m_processed_fitFullDelayData

unsigned int L1CaloPprPhos4Shape::m_processed_fitFullDelayData

private

Definition at line 218 of file L1CaloPprPhos4Shape.h.

m_processed_fitPeakBin

unsigned int L1CaloPprPhos4Shape::m_processed_fitPeakBin

private

Definition at line 217 of file L1CaloPprPhos4Shape.h.

m_processed_fitPeakValue

float L1CaloPprPhos4Shape::m_processed_fitPeakValue

private

Definition at line 216 of file L1CaloPprPhos4Shape.h.

m_processed_fitPerformed

bool L1CaloPprPhos4Shape::m_processed_fitPerformed

private

Definition at line 219 of file L1CaloPprPhos4Shape.h.

m_processed_maxFullDelayData

unsigned int L1CaloPprPhos4Shape::m_processed_maxFullDelayData

private

Definition at line 215 of file L1CaloPprPhos4Shape.h.

m_processed_maxPeakBin

unsigned int L1CaloPprPhos4Shape::m_processed_maxPeakBin

private

Definition at line 214 of file L1CaloPprPhos4Shape.h.

m_processed_maxPeakValue

float L1CaloPprPhos4Shape::m_processed_maxPeakValue

private

Definition at line 213 of file L1CaloPprPhos4Shape.h.

m_processed_signalShape

TH1F* L1CaloPprPhos4Shape::m_processed_signalShape

private

Definition at line 212 of file L1CaloPprPhos4Shape.h.

m_processSignalShape

bool L1CaloPprPhos4Shape::m_processSignalShape

private

Definition at line 226 of file L1CaloPprPhos4Shape.h.

m_raw_fit

TF1* L1CaloPprPhos4Shape::m_raw_fit

private

Definition at line 201 of file L1CaloPprPhos4Shape.h.

m_raw_fitFullDelayData

unsigned int L1CaloPprPhos4Shape::m_raw_fitFullDelayData

private

Definition at line 198 of file L1CaloPprPhos4Shape.h.

m_raw_fitPeakBin

unsigned int L1CaloPprPhos4Shape::m_raw_fitPeakBin

private

Definition at line 197 of file L1CaloPprPhos4Shape.h.

m_raw_fitPeakValue

float L1CaloPprPhos4Shape::m_raw_fitPeakValue

private

Definition at line 196 of file L1CaloPprPhos4Shape.h.

m_raw_fitPerformed

bool L1CaloPprPhos4Shape::m_raw_fitPerformed

private

Definition at line 199 of file L1CaloPprPhos4Shape.h.

m_raw_maxFullDelayData

unsigned int L1CaloPprPhos4Shape::m_raw_maxFullDelayData

private

Definition at line 195 of file L1CaloPprPhos4Shape.h.

m_raw_maxPeakBin

unsigned int L1CaloPprPhos4Shape::m_raw_maxPeakBin

private

Definition at line 194 of file L1CaloPprPhos4Shape.h.

m_raw_maxPeakValue

float L1CaloPprPhos4Shape::m_raw_maxPeakValue

private

Definition at line 193 of file L1CaloPprPhos4Shape.h.

m_raw_signalShape

TProfile* L1CaloPprPhos4Shape::m_raw_signalShape

private

Definition at line 192 of file L1CaloPprPhos4Shape.h.

m_rawPedestalMean

float L1CaloPprPhos4Shape::m_rawPedestalMean

private

Definition at line 203 of file L1CaloPprPhos4Shape.h.

m_rawPedestalSigma

float L1CaloPprPhos4Shape::m_rawPedestalSigma

private

Definition at line 204 of file L1CaloPprPhos4Shape.h.

m_risingSlopeMean

float L1CaloPprPhos4Shape::m_risingSlopeMean

private

Definition at line 223 of file L1CaloPprPhos4Shape.h.

m_risingSlopeSigma

float L1CaloPprPhos4Shape::m_risingSlopeSigma

private

Definition at line 224 of file L1CaloPprPhos4Shape.h.

MAX_ADC_TIME_SLICES

const unsigned int L1CaloPprPhos4Shape::MAX_ADC_TIME_SLICES = 15

staticprivate

Definition at line 229 of file L1CaloPprPhos4Shape.h.

MAX_PEDESTAL_SIGMA

const unsigned int L1CaloPprPhos4Shape::MAX_PEDESTAL_SIGMA = 4

staticprivate

Definition at line 233 of file L1CaloPprPhos4Shape.h.

NANOSEC_PER_LHC_CLOCK_TICK

const unsigned int L1CaloPprPhos4Shape::NANOSEC_PER_LHC_CLOCK_TICK = 25

staticprivate

Definition at line 230 of file L1CaloPprPhos4Shape.h.

SATURATED_ADC

const unsigned int L1CaloPprPhos4Shape::SATURATED_ADC = 1000

staticprivate

Definition at line 235 of file L1CaloPprPhos4Shape.h.

---

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

• L1CaloPprPhos4Shape.h
• L1CaloPprPhos4Shape.cxx