#include <TileLaserTimingTool.h>

Inheritance diagram for TileLaserTimingTool:

Collaboration diagram for TileLaserTimingTool:

Classes
struct	DigitizerData

struct	DrawerData

struct	PMTData

Public Member Functions
	TileLaserTimingTool (const std::string &type, const std::string &name, const IInterface *pParent)

virtual	~TileLaserTimingTool ()

virtual StatusCode	initialize () override

virtual StatusCode	initNtuple (int runNumber, int runType, TFile *rootfile) override

virtual StatusCode	execute () override
	TODO: determine event type, select laser? More...

virtual StatusCode	finalizeCalculations () override

virtual StatusCode	writeNtuple (int runNumber, int runType, TFile *rootfile) override

virtual StatusCode	finalize () override

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

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

bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef float(*	TPMTArray)[NDRAWERS][NCHANNELS]

typedef float(*	TDrawerArrayF)[NDRAWERS]

typedef int(*	TDrawerArrayI)[NDRAWERS]

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
DrawerData *	drawerData (int ros, int drawer)

bool	isConnectedChan (int ros, int chan)

int	channel2PMT (int ros, int chan)

double	fiberCorrection (int ros, int pmt)

HWIdentifier	drawerId (int frag)

std::string	drawerIdStr (int frag)

HWIdentifier	drawerId (int ros, int drawer)

void	fitGauss (TH1F &hi, float &p1, float &p2, float &p1_err)
	Fit a Gaussian function (m_gaussf) to the given histogram, store mean, rms and mean error. More...

void	fitGauss2 (TH1F &hi, float &p1, float &p2, float &chi2, float &p1_err, float w1, float w2)
	Fit a Gaussian function with two iterations mean range = hi.mean +- w1\|w2 * hi.rms. More...

void	correctEvenOddPMT (int ros, int drawer, TPMTArray &ChannelOffset, TDrawerArrayF &MeanOddPmtTdiff, TDrawerArrayI &OddPmtCounter, TDrawerArrayF &MeanEvenPmtTdiff, TDrawerArrayI &EvenPmtCounter, TDrawerArrayF &EvenOddTimeDiff)
	Correct for differences between even and odd PMTs. More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static bool	isConnectedPMT (int ros, int chan)

static bool	isBarrel (int ros)

static bool	isExtBarrel (int ros)

static float	fiberLength (int ros, int pmt)

Private Attributes
DrawerData (	m_drawerData )[NDRAWERS]

float(*	m_DrawerOffset )[NDRAWERS]

float(*	m_DrawerOffsetError )[NDRAWERS]

float(*	m_ChannelOffset )[NDRAWERS][NCHANNELS]

float(*	m_ChannelOffsetError )[NDRAWERS][NCHANNELS]

float(*	m_ADCAmplitude )[NDRAWERS][NCHANNELS]

float(*	m_PedestalMean )[NDRAWERS][NCHANNELS]

float(*	m_PedestalSigma )[NDRAWERS][NCHANNELS]

float(*	m_TimeDiffMean )[NDRAWERS][NCHANNELS]

float(*	m_TimeDiffMeanError )[NDRAWERS][NCHANNELS]

float(*	m_TimeDiffSigma )[NDRAWERS][NCHANNELS]

float(*	m_MeanOddPmtTdiffPMT0 )[NDRAWERS]

int(*	m_OddPmtCounterPMT0 )[NDRAWERS]

float(*	m_MeanEvenPmtTdiffPMT0 )[NDRAWERS]

int(*	m_EvenPmtCounterPMT0 )[NDRAWERS]

float(*	m_EvenOddTimeDiffPMT0 )[NDRAWERS]

float(*	m_FiberLength )[NDRAWERS][NCHANNELS]

float(*	m_TimeDiffPMTDigi0 )[NDRAWERS][NCHANNELS]

float(*	m_FiberCorrection )[NDRAWERS][NCHANNELS]

int(*	m_IsConnected )[NDRAWERS][NCHANNELS]

float(*	m_MeanOddPmtTdiff )[NDRAWERS]

int(*	m_OddPmtCounter )[NDRAWERS]

float(*	m_MeanEvenPmtTdiff )[NDRAWERS]

int(*	m_EvenPmtCounter )[NDRAWERS]

float(*	m_EvenOddTimeDiff )[NDRAWERS]

float(*	m_DSkewSet )[NDRAWERS][NDIGI]

float(*	m_DigiMean )[NDRAWERS][NDIGI]

SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey

SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerKey

SG::ReadHandleKey< TileDigitsContainer >	m_digitsContainerKey

const TileHWID *	m_tileHWID

const TileCablingService *	m_cabling

ToolHandle< TileCondToolTiming >	m_tileToolTiming

std::string	m_rawChannelContainerName

std::string	m_digitsContainerName

std::string	m_ntupleID

double	m_fiberLightSpeed = 0.0

unsigned	m_nSamples

double	m_eneLowLimitPulseShape

unsigned int	m_refDrawer

bool	m_useMeanChannelOffset

float	m_maxTimeDiff

bool	m_usePMT0AsDskewRef

std::string	m_IOVTag

int	m_nevts
	number of laser events More...

TF1 *	m_gaussf

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Static Private Attributes
static const int	NROS = 5

static const float	s_fiberLength [2][48]

Detailed Description

Definition at line 79 of file TileLaserTimingTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ TDrawerArrayF

typedef float(* TileLaserTimingTool::TDrawerArrayF)[NDRAWERS]

private

Definition at line 355 of file TileLaserTimingTool.h.

◆ TDrawerArrayI

typedef int(* TileLaserTimingTool::TDrawerArrayI)[NDRAWERS]

private

Definition at line 356 of file TileLaserTimingTool.h.

◆ TPMTArray

typedef float(* TileLaserTimingTool::TPMTArray)[NDRAWERS][NCHANNELS]

private

Definition at line 354 of file TileLaserTimingTool.h.

Constructor & Destructor Documentation

◆ TileLaserTimingTool()

TileLaserTimingTool::TileLaserTimingTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pParent
	)

Definition at line 122 of file TileLaserTimingTool.cxx.

   : AthAlgTool(type, name, pParent)
   , m_tileHWID(nullptr)
   , m_cabling(nullptr)
   , m_nevts(0)
   , m_gaussf(nullptr)
 {
  
   declareInterface<ITileCalibTool>( this );
  
   declareProperty("NtupleID", m_ntupleID = "h3000");
   declareProperty("FiberLightSpeed", m_fiberLightSpeed);
   declareProperty("NSamples", m_nSamples = 9);
   declareProperty("EneLowLimitPulseShape", m_eneLowLimitPulseShape = 0.000001);
   declareProperty("ReferenceDrawer", m_refDrawer = 39);
  
   declareProperty("UseMeanChannelOffset", m_useMeanChannelOffset = true);
   declareProperty("MaxTimeDiff", m_maxTimeDiff = 10000.);
   declareProperty("UsePMT0AsDskewRef", m_usePMT0AsDskewRef = true);
  
 #ifdef TileLaserTimingMonPulse
   // create mon histos
   m_h1_time_check = new TH1F("h1_time_check", "Time(Tfit based) - Time(cispar based)", 1000, -200., 200.);
   m_h2_time_check = new TH2F("h2_time_check", "Time(Tfit based) vs Time(cispar based)", 1000, -200., 200., 1000, -200., 200.);
  
   m_PulseShapeHigh = new TProfile("pulse_shape_HG", "pulse shape HG", 400, -200., 300., 0, 100000.);
   m_PulseShapeLow = new TProfile("pulse_shape_LG", "pulse shape LG", 400, -200., 300., 0, 100000.);
 #endif
  
   // creating multi-dim arrays on the heap and initialize all elements to zeros
   m_drawerData = new DrawerData*[NPARTITIONS][NDRAWERS]();
  
   m_DrawerOffset = new float[NROS][NDRAWERS]();
   m_DrawerOffsetError = new float[NROS][NDRAWERS]();
  
   m_ChannelOffset = new float[NROS][NDRAWERS][NCHANNELS]();
   m_ChannelOffsetError = new float[NROS][NDRAWERS][NCHANNELS]();
  
   m_ADCAmplitude = new float[NROS][NDRAWERS][NCHANNELS]();
  
   m_PedestalMean = new float[NROS][NDRAWERS][NCHANNELS]();
   m_PedestalSigma = new float[NROS][NDRAWERS][NCHANNELS]();
  
   m_TimeDiffMean = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffSigma = new float[NROS][NDRAWERS][NCHANNELS]();
  
   m_MeanOddPmtTdiffPMT0 = new float[NROS][NDRAWERS]();
   m_OddPmtCounterPMT0 = new int[NROS][NDRAWERS]();
   m_MeanEvenPmtTdiffPMT0 = new float[NROS][NDRAWERS]();
   m_EvenPmtCounterPMT0 = new int[NROS][NDRAWERS]();
   m_EvenOddTimeDiffPMT0 = new float[NROS][NDRAWERS]();
  
 #ifdef TileLaserTimingPMT0Mon
   m_TimeDiffHighMean = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffHighMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffHighSigma = new float[NROS][NDRAWERS][NCHANNELS]();
  
   m_TimeDiffLowMean = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffLowMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffLowSigma = new float[NROS][NDRAWERS][NCHANNELS]();
  
   m_TimeDiffNoCFCorrMean = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffNoCFCorrMeanError = new float[NROS][NDRAWERS][NCHANNELS]();
   m_TimeDiffNoCFCorrSigma = new float[NROS][NDRAWERS][NCHANNELS]();
 #endif
  
   m_FiberLength = new float[NROS][NDRAWERS][NCHANNELS]();
  
 #ifdef TileLaserTimingMon
   m_TimeDiffPMTDigi0 = new float[NROS][NDRAWERS][NCHANNELS]();
   m_FiberCorrection = new float[NROS][NDRAWERS][NCHANNELS]();
   m_IsConnected = new int[NROS][NDRAWERS][NCHANNELS]();
  
   m_MeanOddPmtTdiff = new float[NROS][NDRAWERS]();
   m_OddPmtCounter = new int[NROS][NDRAWERS]();
   m_MeanEvenPmtTdiff = new float[NROS][NDRAWERS]();
   m_EvenPmtCounter = new int[NROS][NDRAWERS]();
  
   m_EvenOddTimeDiff = new float[NROS][NDRAWERS]();
 #endif
  
   m_DSkewSet = new float[NROS][NDRAWERS][NDIGI]();
   m_DigiMean = new float[NROS][NDRAWERS][NDIGI]();
 }

◆ ~TileLaserTimingTool()

TileLaserTimingTool::~TileLaserTimingTool ( )

virtual

Definition at line 208 of file TileLaserTimingTool.cxx.

                                           {
  
   delete[] m_drawerData;
   delete[] m_DrawerOffset;
   delete[] m_DrawerOffsetError;
   delete[] m_ChannelOffset;
   delete[] m_ChannelOffsetError;
   delete[] m_ADCAmplitude;
   delete[] m_PedestalMean;
   delete[] m_PedestalSigma;
   delete[] m_TimeDiffMean;
   delete[] m_TimeDiffMeanError;
   delete[] m_TimeDiffSigma;
   delete[] m_MeanOddPmtTdiffPMT0;
   delete[] m_OddPmtCounterPMT0;
   delete[] m_MeanEvenPmtTdiffPMT0;
   delete[] m_EvenPmtCounterPMT0;
   delete[] m_EvenOddTimeDiffPMT0;
 #ifdef TileLaserTimingPMT0Mon
   delete[] m_TimeDiffHighMean;
   delete[] m_TimeDiffHighMeanError;
   delete[] m_TimeDiffHighSigma;
   delete[] m_TimeDiffLowMean;
   delete[] m_TimeDiffLowMeanError;
   delete[] m_TimeDiffLowSigma;
   delete[] m_TimeDiffNoCFCorrMean;
   delete[] m_TimeDiffNoCFCorrMeanError;
   delete[] m_TimeDiffNoCFCorrSigma;
 #endif
  
   delete[] m_FiberLength;
  
 #ifdef TileLaserTimingMon
   delete[] m_TimeDiffPMTDigi0;
   delete[] m_FiberCorrection;
   delete[] m_IsConnected;
   delete[] m_MeanOddPmtTdiff;
   delete[] m_OddPmtCounter;
   delete[] m_MeanEvenPmtTdiff;
   delete[] m_EvenPmtCounter;
   delete[] m_EvenOddTimeDiff;
 #endif
   delete[] m_DSkewSet;
   delete[] m_DigiMean;
 }

Member Function Documentation

◆ channel2PMT()

int TileLaserTimingTool::channel2PMT	(	int	ros,
		int	chan
	)

inlineprivate

Returns: PMT#-1 for given ros and channel

Definition at line 311 of file TileLaserTimingTool.h.

                                               {
       return (abs(m_cabling->channel2hole(ros, chan)) - 1);
     }

◆ correctEvenOddPMT()

void TileLaserTimingTool::correctEvenOddPMT	(	int	ros,
		int	drawer,
		TPMTArray &	ChannelOffset,
		TDrawerArrayF &	MeanOddPmtTdiff,
		TDrawerArrayI &	OddPmtCounter,
		TDrawerArrayF &	MeanEvenPmtTdiff,
		TDrawerArrayI &	EvenPmtCounter,
		TDrawerArrayF &	EvenOddTimeDiff
	)

private

Correct for differences between even and odd PMTs.

Definition at line 952 of file TileLaserTimingTool.cxx.

                                                                               {
  
  
   float DeltaParity = 0;
  
   //=== determine overall shift between odd and even fibers ===
   //=== for this take only into account channels with connected PMT
   //=== don't take into the mean the value of tdiff when it is too far from zero
   for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
     if (isConnectedPMT(ros, ipmt)) {
       if (ipmt % 2 == 1) {
         // odd PMTs
         if (fabs(ChannelOffset[ros][drawer][ipmt]) < m_maxTimeDiff) {
           MeanOddPmtTdiff[ros][drawer] += ChannelOffset[ros][drawer][ipmt];
           ++OddPmtCounter[ros][drawer];
         } else {
           ATH_MSG_WARNING( "correctEvenOddPMT()"
                            << " time overflow (" << ChannelOffset[ros][drawer][ipmt]
                            << ") ros:" << ros
                            << " dr:" << drawer
                            << " pmt:" << ipmt );
  
         }
       } else if (ipmt % 2 == 0) {
         // even PMTs
         if (fabs(ChannelOffset[ros][drawer][ipmt]) < m_maxTimeDiff) {
           MeanEvenPmtTdiff[ros][drawer] += ChannelOffset[ros][drawer][ipmt];
           ++EvenPmtCounter[ros][drawer];
         } else {
           ATH_MSG_WARNING( "correctEvenOddPMT()"
                            << " time overflow (" << ChannelOffset[ros][drawer][ipmt]
                            << ") ros:" << ros
                            << " dr:" << drawer
                            << " pmt:" << ipmt );
         }
       }
     }
   }
  
   // Save Time difference b/w odd/even pmt's
   MeanOddPmtTdiff[ros][drawer] /= (float) OddPmtCounter[ros][drawer];
   MeanEvenPmtTdiff[ros][drawer] /= (float) EvenPmtCounter[ros][drawer];
   DeltaParity = 0.5 * (MeanOddPmtTdiff[ros][drawer] - MeanEvenPmtTdiff[ros][drawer]);
  
   EvenOddTimeDiff[ros][drawer] = 2 * DeltaParity;
  
   ATH_MSG_DEBUG( "correctEvenOddPMT()"
                 << "  ros: " << ros
                 << " drawer:" << drawer
                 << " EvenOddTimeDiff:" << EvenOddTimeDiff[ros][drawer]
                 << " | MeanOddPmtTdiff:" << MeanOddPmtTdiff[ros][drawer]
                 << " MeanEvenPmtTdiff:" << MeanEvenPmtTdiff[ros][drawer]
                 << " DeltaParity:" << DeltaParity );
  
   //==================================================================
   //=== Correct for overall shift b/w odd and even fibers          ===
   //==================================================================
   for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
     if (isConnectedPMT(ros, ipmt)) {
       if (ipmt % 2 == 1)
         ChannelOffset[ros][drawer][ipmt] -= DeltaParity;
       else if (ipmt % 2 == 0) ChannelOffset[ros][drawer][ipmt] += DeltaParity;
     }
   } // end pmt loop
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ drawerData()

DrawerData* TileLaserTimingTool::drawerData	(	int	ros,
		int	drawer
	)

inlineprivate

Returns: drawer data

Definition at line 239 of file TileLaserTimingTool.h.

                                                        {
       if (!m_drawerData[ros - 1][drawer]) {
         std::ostringstream sout;
         sout << ros << '_' << drawer;
         m_drawerData[ros - 1][drawer] = new DrawerData(sout.str());
       }
       return m_drawerData[ros - 1][drawer];
     }

◆ drawerId() [1/2]

HWIdentifier TileLaserTimingTool::drawerId ( int frag )

inlineprivate

Returns: HWIdentifier for fragment

Definition at line 331 of file TileLaserTimingTool.h.

                                            {
       return m_tileHWID->drawer_id(frag);
     }

◆ drawerId() [2/2]

HWIdentifier TileLaserTimingTool::drawerId	(	int	ros,
		int	drawer
	)

inlineprivate

Returns: HWIdentifier for ros and drawer

Definition at line 339 of file TileLaserTimingTool.h.

                                                       {
       return m_tileHWID->drawer_id(ros, drawer);
     }

◆ drawerIdStr()

std::string TileLaserTimingTool::drawerIdStr ( int frag )

inlineprivate

Returns: string for fragment id

Definition at line 335 of file TileLaserTimingTool.h.

                                            {
       return m_tileHWID->to_string(drawerId(frag));
     }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode TileLaserTimingTool::execute ( )

overridevirtual

TODO: determine event type, select laser?

Implements ITileCalibTool.

Definition at line 307 of file TileLaserTimingTool.cxx.

                                         {
  
   ATH_MSG_DEBUG( "execute()" );
  
   gROOT->cd();
  
   // Get event's CIS parameters
   // QQQ: const uint32_t *cispar = m_beamInfo->cispar();
   // QQQ: const uint32_t dac = cispar[6];
   // QQQ: const uint32_t phase = cispar[5];
   // QQQ: const uint32_t cap = cispar[7];
  
   // Get EventInfo
   SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
   ATH_CHECK( eventInfo.isValid() );
  
  
   // QQQ: const unsigned runNumber = eventInfo->runNumber();
   // QQQ: const unsigned eventNumber = eventInfo->eventNumber();
  
   // Check if event should be used in calibration
   bool pass = true;
  
   // Get TileRawChannelContainer
   SG::ReadHandle<TileRawChannelContainer> container(m_rawChannelContainerKey);
   ATH_CHECK( container.isValid() );
  
   // Get TileDigitsContainer
   SG::ReadHandle<TileDigitsContainer> digitsCnt(m_digitsContainerKey);
   ATH_CHECK( digitsCnt.isValid() );
  
   // Create iterator over RawChannelContainer
   TileRawChannelContainer::const_iterator itColl = (*container).begin();
   TileRawChannelContainer::const_iterator itCollEnd = (*container).end();
   TileRawChannelCollection::const_iterator it, itEnd;
  
   // tmp vars
   const TileDigitsCollection *digiColl = nullptr;
   const TileDigits* digits;
   const TileRawChannel *rawch = nullptr;
   float dtime, dtimeNoCFCorr;
  
 #ifdef TileLaserTimingMonPulse  
   float f_SampleTime, f_phase1, f_phase2, f_time, f_tfittime;
 #endif
  
   size_t colls;
   int Nconnected;
   float ChannelOffset;
  
   DrawerData *ddata = nullptr;
  
   unsigned frag;
   if (pass) {
     m_nevts++;
  
     // Go through all TileRawChannelCollections
     for (; itColl != itCollEnd; ++itColl) {
       // Get the digits collection for the drawer corresponding to the raw channel
       frag = (*itColl)->identify();
       const auto *digiCollIt = digitsCnt->indexFindPtr(digitsCnt->hashFunc()(frag));
       if (digiCollIt == nullptr) {
         ATH_MSG_ERROR( " unable to get TileDigitsCollection for drawer:" << drawerIdStr(frag) );
  
       } else {
         digiColl = digiCollIt;
         colls = (*itColl)->size();
         ATH_MSG_VERBOSE( "execute() colls:" << colls
                          << " digiColl->size:" << digiColl->size()
                          << " drawer:" << drawerIdStr((*itColl)->identify()) );
  
         if (digiColl->size() != colls) {
           ATH_MSG_ERROR( " size of TileDigitsCollection and TileRawChannelCollection differ for drawer:" << drawerIdStr((*itColl)->identify()) );
  
         } else {
           // ZZZ: Assume the first RawChannel in the collection corresponds to PMT 0
           // ZZZ: if this is not the case (for some reason) there will be a nasty segflt
  
           // get drawer HWID
           HWIdentifier dhwid = drawerId((*itColl)->identify());
           // LBA=1  LBC=2  EBA=3  EBC=4
           int ros = m_tileHWID->ros(dhwid);
           // 0 to 63
           int drawer = m_tileHWID->drawer(dhwid);
           // get and create DrawerData if needed, cannot be null
           ddata = drawerData(ros, drawer);
           // store ref to first PMT
           PMTData &pmt0data = *ddata->pmtd[0];
  
           for (size_t i = 0; i < colls; ++i) {
             digits = digiColl->at(i);
             rawch = (*itColl)->at(i);
  
             // require both digits and raw channels with equal ids
             if (!digits || !rawch || (digits->identify() != rawch->identify())) {
               if (!digits) {
                 ATH_MSG_ERROR( " no TileDigits for drawer:" << drawerIdStr((*itColl)->identify())  );
               }
  
               if (!rawch) {
                 ATH_MSG_ERROR( " no TileRawChannel for drawer:" << drawerIdStr((*itColl)->identify()) );
               }
  
               if (rawch && digits) {
                 ATH_MSG_ERROR( " no id mismatch for drawer:" << drawerIdStr((*itColl)->identify()) );
               }
  
             } else {
               // get hardware id to identify adc
               HWIdentifier hwid = rawch->adc_HWID();
               // int ros    = m_tileHWID->ros(hwid);    // LBA=1  LBC=2  EBA=3  EBC=4
               // int drawer = m_tileHWID->drawer(hwid); // 0 to 63
               const int chan = m_tileHWID->channel(hwid);  // 0 to 47 channel not PMT
               const int gain = m_tileHWID->adc(hwid);      // low=0 high=1
               const int ipmt = channel2PMT(ros, chan);
  
               // store Fit data
               PMTData &pmtdata = *ddata->pmtd[ipmt];
               pmtdata.time = rawch->time();
               pmtdata.energy = rawch->amplitude();
               pmtdata.pedestal.add(rawch->pedestal());
  
               // in case of the first PMT (i.e. 0) this will be 0 as per definition
               dtimeNoCFCorr = pmtdata.time - pmt0data.time;
               dtime = dtimeNoCFCorr - fiberCorrection(ros, ipmt);
               pmtdata.TimeDiffHisto.Fill(dtime);
  
 #ifdef TileLaserTimingPMT0        
               pmtdata.TimeDiffNoCFCorrHisto.Fill(dtimeNoCFCorr);
  
               if(gain == 0) pmtdata.TimeDiffHistoLow.Fill(dtime);
               else pmtdata.TimeDiffHistoHigh.Fill(dtime);
 #endif
  
 #ifdef TileLaserTimingMon
               pmtdata.timeHisto.Fill(pmtdata.time);
               pmtdata.eneHisto.Fill(pmtdata.energy);
               pmtdata.gainHisto.Fill(gain);
 #endif
  
               // pulse data-->
 #ifdef TileLaserTimingMonPulse
               if(isConnectedChan(ros, chan)) {
                 std::vector<float> sample = digits->samples();
                 if(sample.size() != m_nSamples) {
                   ATH_MSG_ERROR( " sample size mismatch for drawer:" << drawerIdStr(frag)
                                  <<" in:" << sample.size() << " expected:" << m_nSamples );
                 } else {
                   for (unsigned jsample = 0; jsample < m_nSamples; ++jsample) {
                     f_SampleTime = ((float) jsample) * 25.;
                     f_phase1 = (25. * ((float) phase)) / (30. * 8);
                     f_phase2 = -pmtdata.time;
                     f_time = f_SampleTime + f_phase1 - 100;
                     f_tfittime = f_SampleTime + f_phase2 - 100;
                     if (phase >= 160) {
                       f_time -= 25;
                       f_phase1 -= 25;
                     }
  
                     if (phase < 140 || phase > 160) {
                       // if Low gain convert to the HG scale
                       if (gain == 0) {
                         m_h1_time_check->Fill(f_phase1 - f_phase2);
                         m_h2_time_check->Fill(f_phase1, f_phase2);
  
                         if (fabs(pmtdata.energy) > m_eneLowLimitPulseShape) {
                           pmtdata.pulseShapeLow.Fill(f_tfittime, (LG2HG * (sample[jsample] - rawch->pedestal())));
                         }
                       }
                       //HG
                       else if (fabs(pmtdata.energy) > m_eneLowLimitPulseShape) {
                         pmtdata.pulseShapeHigh.Fill(f_tfittime, (sample[jsample] - rawch->pedestal()));
                       }
                     } // if Cispar not in 140->160 (range with time jitter,
                     //difficult to handle for smooth pulse shape
                   }
                 } // end loop over jsample
               } // end if PMT is connected
 #endif
               // <--pulse data
  
             } // else: ok digits and raw channels
           } // end collection loop
  
           //=====================================================================================
           //=== Compute mean Tfit (corrected for laser fiber length) over the first digitizer ===
           //=====================================================================================
           Nconnected = 0;
           ddata->FarDigitizerMeanTime = 0.;
           for (int ipmt = 0; ipmt < 6; ++ipmt) {
             if (isConnectedPMT(ros, ipmt)) {
               ddata->FarDigitizerMeanTime += (ddata->pmtd[ipmt]->time - fiberCorrection(ros, ipmt));
               Nconnected++;
             }
           }
           if (Nconnected) 
             ddata->FarDigitizerMeanTime /= (float) Nconnected;
  
 #ifdef TileLaserTimingMon
           ddata->Digi0Time.Fill(ddata->FarDigitizerMeanTime);
 #endif
  
           if (msgLvl(MSG::VERBOSE) && (ros == 1) && (drawer == 1)) {
             ATH_MSG_VERBOSE( " ddata->FarDigitizerMeanTime:" << ddata->FarDigitizerMeanTime );
           }
  
           //============================================================================
           //=== Calculate residuals. Fill histos with time diff b/w PMT i and digi 1 ===
           //============================================================================
           for (int ipmt = 0; ipmt < NCHANNELS; ipmt++) {
             if (isConnectedPMT(ros, ipmt)) {
               ChannelOffset = -(ddata->pmtd[ipmt]->time - fiberCorrection(ros, ipmt) - ddata->FarDigitizerMeanTime);
               ddata->pmtd[ipmt]->TimeDiffResHis.Fill(ChannelOffset);
               if (msgLvl(MSG::VERBOSE) && (ros == 1) && (drawer == 1)) {
                 ATH_MSG_VERBOSE(  " ipmt:" << ipmt << " ChannelOffset:" << ChannelOffset );
               }
             }
           }
  
         } // else: matching digits and raw channel collections
       }
     } // end container loop
  
     //=====================================================================================
     //=== this histogram contains the difference between first digitizer of drawer 1 and drawer 2: drawer offset
     //=====================================================================================
     for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
       if (drawerData(ros, m_refDrawer)) {
         DrawerData &drawer0data = *drawerData(ros, m_refDrawer);
         for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
           if ((drawer != m_refDrawer) && drawerData(ros, drawer)) {
             DrawerData &ddata = *drawerData(ros, drawer);
             ddata.Digi0TimeDiffHisto.Fill( ddata.FarDigitizerMeanTime - drawer0data.FarDigitizerMeanTime);
  
             if (msgLvl(MSG::VERBOSE) && (ros == 1) && (drawer == 1)) {
               ATH_MSG_VERBOSE( " drawerdiff:" << ddata.FarDigitizerMeanTime - drawer0data.FarDigitizerMeanTime );
             }
           }
         }
       }
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fiberCorrection()

double TileLaserTimingTool::fiberCorrection	(	int	ros,
		int	pmt
	)

inlineprivate

Returns: timing correction for fiber length, for given PMT

Definition at line 323 of file TileLaserTimingTool.h.

                                                     {
       return (s_fiberLength[isExtBarrel(ros)][pmt] - s_fiberLength[isExtBarrel(ros)][0])
           / m_fiberLightSpeed;
     }

◆ fiberLength()

static float TileLaserTimingTool::fiberLength	(	int	ros,
		int	pmt
	)

inlinestaticprivate

Definition at line 327 of file TileLaserTimingTool.h.

                                                       {
       return s_fiberLength[isExtBarrel(ros)][pmt];
     }

◆ finalize()

StatusCode TileLaserTimingTool::finalize ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 873 of file TileLaserTimingTool.cxx.

                                          {
  
   ATH_MSG_INFO( "finalize()" );
  
   return StatusCode::SUCCESS;
 } 

◆ finalizeCalculations()

StatusCode TileLaserTimingTool::finalizeCalculations ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 553 of file TileLaserTimingTool.cxx.

                                                      {
  
   ATH_MSG_INFO( "finalizeCalculations()" );
  
   gROOT->cd();
  
   float fmean, fdummy, fchi2, fmeanerr;
  
   for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
     for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
       DrawerData &drawerd = *drawerData(ros, drawer);
  
       for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
         PMTData &pmtd = *drawerd.pmtd[ipmt];
         // to simplify the root analysis, store the fiber length, not really neccessary
         m_FiberLength[ros][drawer][ipmt] = fiberLength(ros, ipmt);
 #ifdef TileLaserTimingMon
         m_FiberCorrection[ros][drawer][ipmt] = fiberCorrection(ros, ipmt);
         m_IsConnected[ros][drawer][ipmt] = isConnectedPMT(ros, ipmt);
 #endif
         //==========================================================================================
         //==== Pulse shapes ====
  
         // use the number of entries in the histos as the number of passed events for high/low
  
 #ifdef TileLaserTimingMonPulse
         if(pmtd.TimeDiffHistoLow.GetEntries() > 0.99 * m_nevts) {
           m_PulseShapeLow->Add(&pmtd.pulseShapeLow);
         }
  
         if(pmtd.TimeDiffHistoHigh.GetEntries() > 0.99 * m_nevts) {
           m_PulseShapeHigh->Add(&pmtd.pulseShapeHigh);
         }
 #endif
  
         if (ipmt > 0) {
           //==================================================================
           // Fit time difference regardless of gain, to derive standard Dskews
           //==================================================================
           if (isConnectedPMT(ros, ipmt)) {
             fitGauss(pmtd.TimeDiffHisto, m_TimeDiffMean[ros][drawer][ipmt], m_TimeDiffSigma[ros][drawer][ipmt], m_TimeDiffMeanError[ros][drawer][ipmt]);
           }
  
 #ifdef TileLaserTimingPMT0
           //===========================================================
           //=== Fit time difference without clear fiber corrections ===
           //===========================================================
           if(isConnectedPMT(ros, ipmt)) {
             fitGauss(pmtd.TimeDiffNoCFCorrHisto, m_TimeDiffNoCFCorrMean[ros][drawer][ipmt], m_TimeDiffNoCFCorrSigma[ros][drawer][ipmt], m_TimeDiffNoCFCorrMeanError[ros][drawer][ipmt]);
           }
  
           //================================================================================
           //==== Fit gauss to time differences in all gains/ low gain/ high gain in all PMTs
           //================================================================================
  
           fitGauss(pmtd.TimeDiffHistoLow, m_TimeDiffLowMean[ros][drawer][ipmt], m_TimeDiffLowSigma[ros][drawer][ipmt], m_TimeDiffLowMeanError[ros][drawer][ipmt]);
  
           //------------------------------------- For high gain --------------------------------------
  
           fitGauss(pmtd.TimeDiffHistoHigh, m_TimeDiffHighMean[ros][drawer][ipmt], m_TimeDiffHighSigma[ros][drawer][ipmt], m_TimeDiffHighMeanError[ros][drawer][ipmt]);
 #endif
         }
  
         //==================================================================================
         //=== Fit mean value of time difference b/w drawer_i(pmt_j) and drawer_i(digi_1) ===
         //==================================================================================
  
         // TODO: previous values on error
         if (isConnectedPMT(ros, ipmt)) {
           if (m_useMeanChannelOffset) {
             m_TimeDiffPMTDigi0[ros][drawer][ipmt] = m_ChannelOffset[ros][drawer][ipmt] =  pmtd.TimeDiffResHis.GetMean();
             m_ChannelOffsetError[ros][drawer][ipmt] = pmtd.TimeDiffResHis.GetMeanError();
           } else {
             fitGauss2(pmtd.TimeDiffResHis, fmean, fdummy, fchi2, fmeanerr, 1.0, 3.0);
  
             if (fchi2 > 500) {
               ATH_MSG_WARNING( "pmt # " << ipmt + 1
                                << " has chi2 value " << fchi2
                                << " force timing residual same as PMT-1 " );
  
               // FittedMean=PreviousFittedMean;
               fchi2 = -fchi2; // just to make Coverity happt
               fmean = -4711;
               fmeanerr = 0.0;
             }
             if (fabs(fmean) > 100) {
               ATH_MSG_WARNING( " pmt # " << ipmt + 1
                                << " has ChannelOffset " << fmean
                                << " force timing residual same as PMT-1" );
  
               // FittedMean=PreviousFittedMean;
               fmean = -4711;
               fmeanerr = 0.0;
             }
             m_ChannelOffset[ros][drawer][ipmt] = fmean;
             m_ChannelOffsetError[ros][drawer][ipmt] = fmeanerr;
           }
         } else {
           m_ChannelOffset[ros][drawer][ipmt] = 0.0;
           m_ChannelOffsetError[ros][drawer][ipmt] = 0.0;
         }
  
 #ifdef TileLaserTimingMonPulse
         //===========================================================
         //=== Pedestal and ADC Amplitudes                         ===
         //===========================================================
         pmtd.pedestal.getStat(m_PedestalMean[ros][drawer][ipmt], m_PedestalSigma[ros][drawer][ipmt]);
         if (isConnectedPMT(ros, ipmt))
           m_ADCAmplitude[ros][drawer][ipmt] = fmax(pmtd.pulseShapeHigh.GetMaximum(), pmtd.pulseShapeLow.GetMaximum());
         else
           m_ADCAmplitude[ros][drawer][ipmt] = 0.;
  
         if (msgLvl(MSG::VERBOSE) && (ros == 1) && (drawer == 1)) {
           msg(MSG::VERBOSE) << "ipmt: " << ipmt
                             << " TimeDiffLow: " << m_TimeDiffLowMean[ros][drawer][ipmt] << "(" << m_TimeDiffLowSigma[ros][drawer][ipmt] << ") +-" << m_TimeDiffLowMeanError[ros][drawer][ipmt]
                             << " TimeDiffHigh:" << m_TimeDiffHighMean[ros][drawer][ipmt] << "(" << m_TimeDiffHighSigma[ros][drawer][ipmt] << ") +-" << m_TimeDiffHighMeanError[ros][drawer][ipmt] << endmsg;
  
           msg(MSG::VERBOSE) << "     TimeDiff:" << m_TimeDiffMean[ros][drawer][ipmt] << "(" << m_TimeDiffSigma[ros][drawer][ipmt] << ") +-" << m_TimeDiffMeanError[ros][drawer][ipmt]
                             << " TomeDiffNoCF:" << m_TimeDiffNoCFCorrMean[ros][drawer][ipmt] << "(" << m_TimeDiffNoCFCorrSigma[ros][drawer][ipmt] << ") +-" << m_TimeDiffNoCFCorrMeanError[ros][drawer][ipmt] << endmsg;
  
           msg(MSG::VERBOSE) << "     ped:" << m_PedestalMean[ros][drawer][ipmt] << "(" << m_PedestalSigma[ros][drawer][ipmt]
                             << ") amp:" << m_ADCAmplitude[ros][drawer][ipmt] << endmsg;
         }
 #endif
  
       } // end PMT loop
  
       //============================================
       //========= Fit mean DrawerOffset ============
       //============================================
  
       fitGauss2(drawerd.Digi0TimeDiffHisto, m_DrawerOffset[ros][drawer], fdummy, fdummy, m_DrawerOffsetError[ros][drawer], 0.5, 1.0);
  
       ATH_MSG_DEBUG( "finalizeCalculations()"
                      << " ros: " << ros
                      << " drawer:" << drawer
                      << " DrawerOffset:" << m_DrawerOffset[ros][drawer] << "("
                      << m_DrawerOffsetError[ros][drawer] << ")" );
  
       //==============================================================
       //=== correct for overall offset between odd and even fibers ===
       //
       // Better would be to meassure the laser fiber lengths and 
       // implement this as a correction. Meanwhile, use this as 
       // a compromise.
       //==============================================================
       // CCC: MeanEvenPmtTdiff= 0;
       // CCC: MeanOddPmtTdiff = 0;
       // CCC: DeltaParity     = 0;
       // CCC: OddPmtCounter =0;
       // CCC: EvenPmtCounter =0;
  
       correctEvenOddPMT(ros, drawer, m_ChannelOffset, m_MeanOddPmtTdiff, m_OddPmtCounter, m_MeanEvenPmtTdiff, m_EvenPmtCounter, m_EvenOddTimeDiff);
  
       correctEvenOddPMT(ros, drawer, m_TimeDiffMean, m_MeanOddPmtTdiffPMT0, m_OddPmtCounterPMT0, m_MeanEvenPmtTdiffPMT0, m_EvenPmtCounterPMT0, m_EvenOddTimeDiffPMT0);
  
       TPMTArray& timeDiffs = m_usePMT0AsDskewRef ? m_TimeDiffMean : m_ChannelOffset;
  
       //==================================================================
       //=== Calculate Dskews                                           ===
       //==================================================================
       for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
         // LBA and LBC
         if (isBarrel(ros)) {
           if (isConnectedPMT(ros, ipmt) && (timeDiffs[ros][drawer][ipmt] < 300)) {
             drawerd.digid[ipmt / 6].Add(timeDiffs[ros][drawer][ipmt]);
           }
           if (ipmt % 6 == 5) {
             drawerd.digid[ipmt / 6].Freeze();
           }
         } // end isBarrel
         // EBA and EBC%
         else if (isExtBarrel(ros)) {
           if (isConnectedPMT(ros, ipmt) && (timeDiffs[ros][drawer][ipmt] < 300)) {
             if (ipmt < 6)                    drawerd.digid[0].Add(timeDiffs[ros][drawer][ipmt]);
             else if (ipmt > 5 && ipmt < 12)  drawerd.digid[1].Add(timeDiffs[ros][drawer][ipmt]);
             else if (ipmt > 11 && ipmt < 18) drawerd.digid[2].Add(timeDiffs[ros][drawer][ipmt]);
             else if (ipmt > 17 && ipmt < 24) drawerd.digid[3].Add(timeDiffs[ros][drawer][ipmt]);
             else if (ipmt > 27 && ipmt < 34) {
               drawerd.digid[4].Add(timeDiffs[ros][drawer][ipmt]);
               drawerd.digid[5].Add(timeDiffs[ros][drawer][ipmt]);
             } else if (ipmt > 35) {
               drawerd.digid[6].Add(timeDiffs[ros][drawer][ipmt]);
               drawerd.digid[7].Add(timeDiffs[ros][drawer][ipmt]);
             }
           }
  
           if (ipmt == 5)       drawerd.digid[0].Freeze();
           else if (ipmt == 11) drawerd.digid[1].Freeze();
           else if (ipmt == 17) drawerd.digid[2].Freeze();
           else if (ipmt == 23) drawerd.digid[3].Freeze();
           else if (ipmt == 33) {
             drawerd.digid[4].Freeze();
             drawerd.digid[5].Freeze();
           } else if (ipmt == 47) {
             drawerd.digid[6].Freeze();
             drawerd.digid[7].Freeze();
           }
         } // end isExtBarrel
       } // end PMT loop
  
       for (int digi = 0; digi < NDIGI; ++digi) {
         m_DigiMean[ros][drawer][digi] = drawerd.digid[digi].GetDigiTime();
         m_DSkewSet[ros][drawer][digi] = (m_DigiMean[ros][drawer][digi] - m_DigiMean[ros][drawer][0]) * 240. / 25.;
  
         ATH_MSG_DEBUG( "finalizeCalculations()"
                        << " ros: " << ros
                        << " drawer: " << drawer
                        << " digi: " << digi
                        << " digi_time: " << drawerd.digid[digi].GetDigiTime()
                        << " #active: " << drawerd.digid[digi].GetTotActive()
                        << " DSkewSet: " << m_DSkewSet[ros][drawer][digi] );
  
       }
     } // end drawer loop
   } // end ros loop
  
   return StatusCode::SUCCESS;
 }

◆ fitGauss()

void TileLaserTimingTool::fitGauss	(	TH1F &	hi,
		float &	p1,
		float &	p2,
		float &	p1_err
	)

private

Fit a Gaussian function (m_gaussf) to the given histogram, store mean, rms and mean error.

Definition at line 896 of file TileLaserTimingTool.cxx.

                                                                                 {
  
   if (hi.GetEntries() == 0) {
     p1 = p2 = p1_err = 0.0;
     return;
   }
   double MaxAmplitude = hi.GetMaximum();
   double MeanTimeDiff = hi.GetMean();
   double RMSTimeDiff = hi.GetRMS();
   m_gaussf->SetParameter(0, MaxAmplitude);
   m_gaussf->SetParameter(1, MeanTimeDiff);
   m_gaussf->SetParameter(2, RMSTimeDiff);
   m_gaussf->SetRange(MeanTimeDiff - 2.0 * RMSTimeDiff, MeanTimeDiff + 2.0 * RMSTimeDiff);
  
   hi.Fit(m_gaussf, "QR");
  
   p1 = m_gaussf->GetParameter(1);
   p1_err = m_gaussf->GetParError(1);
   p2 = m_gaussf->GetParameter(2);
 }

◆ fitGauss2()

void TileLaserTimingTool::fitGauss2	(	TH1F &	hi,
		float &	p1,
		float &	p2,
		float &	chi2,
		float &	p1_err,
		float	w1,
		float	w2
	)

private

Fit a Gaussian function with two iterations mean range = hi.mean +- w1|w2 * hi.rms.

Definition at line 917 of file TileLaserTimingTool.cxx.

                                                                                                                   {
  
   if (hi.GetEntries() == 0) {
     p1 = p2 = chi2 = p1_err = w1 = w2 = 0.0;
     return;
   }
  
   double MaxAmplitude = hi.GetMaximum();
   double MeanTimeDiff = hi.GetMean();
   double RMSTimeDiff = hi.GetRMS();
  
   m_gaussf->SetParameter(0, MaxAmplitude);
   m_gaussf->SetParameter(1, MeanTimeDiff);
   m_gaussf->SetParameter(2, RMSTimeDiff);
   m_gaussf->SetRange(MeanTimeDiff - w1 * RMSTimeDiff, MeanTimeDiff + w1 * RMSTimeDiff);
  
   hi.Fit(m_gaussf, "QR");
   double FittedAmplitude = m_gaussf->GetParameter(0);
   double FittedMean = m_gaussf->GetParameter(1);
   double FittedSigma = m_gaussf->GetParameter(2);
  
   //=== Iterate once ===
  
   m_gaussf->SetParameter(0, FittedAmplitude);
   m_gaussf->SetParameter(1, FittedMean);
   m_gaussf->SetParameter(2, FittedSigma);
   m_gaussf->SetRange(FittedMean - w2 * FittedSigma, FittedMean + w2 * FittedSigma);
  
   hi.Fit(m_gaussf, "QR");
   p1 = m_gaussf->GetParameter(1);
   p2 = m_gaussf->GetParameter(2);
   p1_err = m_gaussf->GetParError(1);
   chi2 = m_gaussf->GetChisquare();
 }

◆ initialize()

StatusCode TileLaserTimingTool::initialize ( )

overridevirtual

Use timing tool to get cell fiber lengths, when implemented! float athfl, offlfl; const int drawerIdx = TileCalibUtils::getDrawerIdx(1, 0); for (int pmt = 0; pmt < 48; pmt++) { athfl = m_tileToolTiming->getCellFiberLength(drawerIdx, pmt); offlfl = fiberLength(1, pmt); ATH_MSG_INFO( " " << pmt << " : " << athfl << " , " << offlfl ); }

Implements ITileCalibTool.

Definition at line 256 of file TileLaserTimingTool.cxx.

                                            {
  
   ATH_MSG_INFO( "initialize()" );
  
   // get TileHWID helper
   CHECK( detStore()->retrieve(m_tileHWID) );
  
   // get the timing tool
   CHECK( m_tileToolTiming.retrieve() );
  
   // get TileCabling Service
   m_cabling = TileCablingService::getInstance();
  
   m_nevts = 0;
  
   ATH_CHECK( m_eventInfoKey.initialize() );
   ATH_CHECK( m_rawChannelContainerKey.initialize() );
   ATH_CHECK( m_digitsContainerKey.initialize() );
  
   // gauss fit function
   m_gaussf = new TF1("GainGauss", "[0]*exp(- (x-[1])*(x-[1])/(2*[2]*[2]))", -60, 60);
  
   ATH_MSG_DEBUG( "initialize() ready " );
  
   return StatusCode::SUCCESS;
 }

◆ initNtuple()

StatusCode TileLaserTimingTool::initNtuple	(	int	runNumber,
		int	runType,
		TFile *	rootfile
	)

overridevirtual

Implements ITileCalibTool.

Definition at line 294 of file TileLaserTimingTool.cxx.

                                                                                        {
  
   ATH_MSG_INFO( "initNtuple(" << runNumber << "," << runType << "," << rootFile << ")" );
  
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& ITileCalibTool::interfaceID ( )

inlinestaticinherited

Definition at line 21 of file ITileCalibTool.h.

21 { return IID_ITileCalibTool; }

◆ isBarrel()

static bool TileLaserTimingTool::isBarrel ( int ros )

inlinestaticprivate

Returns: if ros is the barrel, LBA or LBC

Definition at line 315 of file TileLaserTimingTool.h.

                                          {
       return ros == 1 || ros == 2;
     }

◆ isConnectedChan()

bool TileLaserTimingTool::isConnectedChan	(	int	ros,
		int	chan
	)

inlineprivate

Returns: if channel is connected

Definition at line 303 of file TileLaserTimingTool.h.

                                                    {
       if (m_cabling->channel2hole(ros, chan) < 0) return false;
       return true;
     }

◆ isConnectedPMT()

bool TileLaserTimingTool::isConnectedPMT	(	int	ros,
		int	chan
	)

staticprivate

Returns: if a PMT is connected

Definition at line 882 of file TileLaserTimingTool.cxx.

                                                           {
   if (isBarrel(ros)) {
     return !(ipmt == 31 || ipmt == 32 || ipmt == 43);
   } else if (isExtBarrel(ros)) {
     return !(   ipmt == 18 || ipmt == 19 || ipmt == 24 || ipmt == 25
              || ipmt == 26 || ipmt == 27 || ipmt == 30 || ipmt == 31
              || ipmt == 34 || ipmt == 35 || ipmt == 38 || ipmt == 39
              || ipmt == 44 || ipmt == 45 || ipmt == 46 || ipmt == 47);
   }
  
   return false;
 }

◆ isExtBarrel()

static bool TileLaserTimingTool::isExtBarrel ( int ros )

inlinestaticprivate

Returns: if ros is the extended barrel, EBA or EBC

Definition at line 319 of file TileLaserTimingTool.h.

                                             {
       return ros == 3 || ros == 4;
     }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

◆ writeNtuple()

StatusCode TileLaserTimingTool::writeNtuple	(	int	runNumber,
		int	runType,
		TFile *	rootfile
	)

overridevirtual

Implements ITileCalibTool.

Definition at line 773 of file TileLaserTimingTool.cxx.

                                                                                        {
  
   ATH_MSG_INFO( "writeNtuple(" << runNumber << "," << runType << "," << rootFile << ")" );
  
   // Write a tree with all arrays
   TTree *t = new TTree(m_ntupleID.c_str(), "TileLaserTimingNtuple");
   t->Branch("DrawerOffset", m_DrawerOffset, "DrawerOffset[5][64]/F"); // float m_DrawerOffset[s_NRos][64];
   t->Branch("DrawerOffsetError", m_DrawerOffsetError, "DrawerOffsetError[5][64]/F"); // float m_DrawerOffsetError[NROS][64];
  
   t->Branch("ChannelOffset", m_ChannelOffset, "ChannelOffset[5][64][48]/F"); // float m_ChannelOffset[NROS][64][48];
   t->Branch("ChannelOffsetError", m_ChannelOffsetError, "ChannelOffsetError[5][64][48]/F"); // float m_ChannelOffsetError[NROS][64][48];
  
   t->Branch("ADCAmplitude", m_ADCAmplitude, "ADCAmplitude[5][64][48]/F"); // float m_ADCAmplitude[NROS][64][48];
  
   t->Branch("PedestalMean", m_PedestalMean, "PedestalMean[5][64][48]/F"); // float m_PedestalMean[NROS][64][48];
   t->Branch("PedestalSigma", m_PedestalSigma, "PedestalSigma[5][64][48]/F"); // float m_PedestalSigma[NROS][64][48];
  
   t->Branch("TimeDiffMean", m_TimeDiffMean, "TimeDiffMean[5][64][48]/F"); // float m_TimeDiffMean[NROS][64][48];
   t->Branch("TimeDiffMeanError", m_TimeDiffMeanError, "TimeDiffMeanError[5][64][48]/F"); // float m_TimeDiffMeanError[NROS][64][48];
   t->Branch("TimeDiffSigma", m_TimeDiffSigma, "TimeDiffSigma[5][64][48]/F"); // float m_TimeDiffSigma[NROS][64][48];
  
 #ifdef TileLaserTimingPMT0Mon
   t->Branch("TimeDiffHighMean", m_TimeDiffHighMean, "TimeDiffHighMean[5][64][48]/F"); // float m_TimeDiffHighMean[NROS][64][48];
   t->Branch("TimeDiffHighMeanError", m_TimeDiffHighMeanError, "TimeDiffHighMeanError[5][64][48]/F"); // float m_TimeDiffHighMeanError[NROS][64][48];
   t->Branch("TimeDiffHighSigma", m_TimeDiffHighSigma, "TimeDiffHighSigma[5][64][48]/F"); // float m_TimeDiffHighSigma[NROS][64][48];
   t->Branch("TimeDiffLowMean", m_TimeDiffLowMean, "TimeDiffLowMean[5][64][48]/F"); // float m_TimeDiffLowMean[NROS][64][48];
   t->Branch("TimeDiffLowMeanError", m_TimeDiffLowMeanError, "TimeDiffLowMeanError[5][64][48]/F"); // float m_TimeDiffLowMeanError[NROS][64][48];
   t->Branch("TimeDiffLowSigma", m_TimeDiffLowSigma, "TimeDiffLowSigma[5][64][48]/F"); // float m_TimeDiffLowSigma[NROS][64][48];
   t->Branch("TimeDiffNoCFCorrMean", m_TimeDiffNoCFCorrMean, "TimeDiffNoCFCorrMean[5][64][48]/F"); // float m_TimeDiffNoCFCorrMean[NROS][64][48];
   t->Branch("TimeDiffNoCFCorrMeanError", m_TimeDiffNoCFCorrMeanError, "TimeDiffNoCFCorrMeanError[5][64][48]/F"); // float m_TimeDiffNoCFCorrMeanError[NROS][64][48];
   t->Branch("TimeDiffNoCFCorrSigma", m_TimeDiffNoCFCorrSigma, "TimeDiffNoCFCorrSigma[5][64][48]/F"); // float m_TimeDiffNoCFCorrSigma[NROS][64][48];
 #endif
   t->Branch("FiberLength", m_FiberLength, "FiberLength[5][64][48]/F"); // float m_FiberLength[NROS][64][48];
  
 #ifdef TileLaserTimingMon
   t->Branch("EvenOddTimeDiff", m_EvenOddTimeDiff, "EvenOddTimeDiff[5][64]/F"); // float m_EvenOddTimeDiff[NROS][64];
  
   t->Branch("FiberCorrection", m_FiberCorrection, "FiberCorrection[5][64][48]/F"); // float m_FiberCorrection[NROS][64][48];
   t->Branch("IsConnected", m_IsConnected, "IsConnected[5][64][48]/F"); // float m_FiberCorrection[NROS][64][48];
  
   t->Branch("MeanOddPmtTdiff", m_MeanOddPmtTdiff, "MeanOddPmtTdiff[5][64]/F");
   t->Branch("OddPmtCounter", m_OddPmtCounter, "OddPmtCounter[5][64]/I");
   t->Branch("MeanEvenPmtTdiff", m_MeanEvenPmtTdiff, "MeanEvenPmtTdiff[5][64]/F");
   t->Branch("EvenPmtCounter", m_EvenPmtCounter, "EvenPmtCounter[5][64]/I");
  
   t->Branch("TimeDiffPMTDigi0", m_TimeDiffPMTDigi0, "TimeDiffPMTDigi0[5][64][48]/F");
 #endif
  
   // mon pmt0-->
   t->Branch("EvenOddTimeDiffPMT0", m_EvenOddTimeDiffPMT0, "EvenOddTimeDiffPMT0[5][64]/F");
   t->Branch("MeanOddPmtTdiffPMT0", m_MeanOddPmtTdiffPMT0, "MeanOddPmtTdiffPMT0[5][64]/F");
   t->Branch("OddPmtCounterPMT0", m_OddPmtCounterPMT0, "OddPmtCounterPMT0[5][64]/I");
   t->Branch("MeanEvenPmtTdiffPMT0", m_MeanEvenPmtTdiffPMT0, "MeanEvenPmtTdiffPMT0[5][64]/F");
   t->Branch("EvenPmtCounterPMT0", m_EvenPmtCounterPMT0, "EvenPmtCounterPMT0[5][64]/I");
   // <-- mon pmt0
  
   t->Branch("DSkewSet", m_DSkewSet, "DSkewSet[5][64][8]/F");       // float m_DSkewSet[NROS][64][8];
   t->Branch("DigiMean", m_DigiMean, "DigiMean[5][64][8]/F");       // float m_DigiMean[NROS][64][8];
   t->Fill();
   rootFile->cd();
   t->Write();
  
   ATH_MSG_INFO( "writeNtuple(" << runNumber << "," << runType << "," << rootFile << ") data written" );
  
   rootFile->ls();
  
   // store histos 
   for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
     for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
       ATH_MSG_VERBOSE( "writeNtuple() ros:" << ros << " drawer:" << drawer );
  
       DrawerData* dd = drawerData(ros, drawer);
       if (dd) {
         dd->Digi0TimeDiffHisto.Write();
 #ifdef TileLaserTimingMon
         dd->Digi0Time.Write();
 #endif
         for (int ipmt = 0; ipmt < NCHANNELS; ++ipmt) {
           if (isConnectedPMT(ros, ipmt)) {
             /*dd->pmtd[ipmt]->TimeDiffHisto.Write();
              dd->pmtd[ipmt]->TimeDiffNoCFCorrHisto.Write();*/
 #ifdef TileLaserTimingMon
             dd->pmtd[ipmt]->timeHisto.Write();
             dd->pmtd[ipmt]->eneHisto.Write();
             dd->pmtd[ipmt]->gainHisto.Write();
 #endif
             /*dd->pmtd[ipmt]->TimeDiffHistoHigh.Write();
              dd->pmtd[ipmt]->pulseShapeHigh.Write();
              dd->pmtd[ipmt]->TimeDiffHistoLow.Write();
              dd->pmtd[ipmt]->pulseShapeLow.Write();*/
             dd->pmtd[ipmt]->TimeDiffResHis.Write();
           }
         }
       }
     }
   }
  
   return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_ADCAmplitude

float(* TileLaserTimingTool::m_ADCAmplitude)[NDRAWERS][NCHANNELS]

private

Definition at line 188 of file TileLaserTimingTool.h.

◆ m_cabling

const TileCablingService* TileLaserTimingTool::m_cabling

private

Definition at line 258 of file TileLaserTimingTool.h.

◆ m_ChannelOffset

float(* TileLaserTimingTool::m_ChannelOffset)[NDRAWERS][NCHANNELS]

private

Definition at line 185 of file TileLaserTimingTool.h.

◆ m_ChannelOffsetError

float(* TileLaserTimingTool::m_ChannelOffsetError)[NDRAWERS][NCHANNELS]

private

Definition at line 186 of file TileLaserTimingTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DigiMean

float(* TileLaserTimingTool::m_DigiMean)[NDRAWERS][NDIGI]

private

Definition at line 236 of file TileLaserTimingTool.h.

◆ m_digitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileLaserTimingTool::m_digitsContainerKey

private

Initial value:

{this,

"TileDigitsContainer", "TileDigitsCnt", "Tile digits container"}

Definition at line 253 of file TileLaserTimingTool.h.

◆ m_digitsContainerName

std::string TileLaserTimingTool::m_digitsContainerName

private

Definition at line 264 of file TileLaserTimingTool.h.

◆ m_drawerData

DrawerData*(* TileLaserTimingTool::m_drawerData)[NDRAWERS]

private

Definition at line 174 of file TileLaserTimingTool.h.

◆ m_DrawerOffset

float(* TileLaserTimingTool::m_DrawerOffset)[NDRAWERS]

private

Definition at line 181 of file TileLaserTimingTool.h.

◆ m_DrawerOffsetError

float(* TileLaserTimingTool::m_DrawerOffsetError)[NDRAWERS]

private

Definition at line 182 of file TileLaserTimingTool.h.

◆ m_DSkewSet

float(* TileLaserTimingTool::m_DSkewSet)[NDRAWERS][NDIGI]

private

Definition at line 235 of file TileLaserTimingTool.h.

◆ m_eneLowLimitPulseShape

double TileLaserTimingTool::m_eneLowLimitPulseShape

private

Definition at line 269 of file TileLaserTimingTool.h.

◆ m_EvenOddTimeDiff

float(* TileLaserTimingTool::m_EvenOddTimeDiff)[NDRAWERS]

private

Definition at line 232 of file TileLaserTimingTool.h.

◆ m_EvenOddTimeDiffPMT0

float(* TileLaserTimingTool::m_EvenOddTimeDiffPMT0)[NDRAWERS]

private

Definition at line 203 of file TileLaserTimingTool.h.

◆ m_EvenPmtCounter

int(* TileLaserTimingTool::m_EvenPmtCounter)[NDRAWERS]

private

Definition at line 230 of file TileLaserTimingTool.h.

◆ m_EvenPmtCounterPMT0

int(* TileLaserTimingTool::m_EvenPmtCounterPMT0)[NDRAWERS]

private

Definition at line 202 of file TileLaserTimingTool.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> TileLaserTimingTool::m_eventInfoKey

private

Initial value:

{this,

"EventInfo", "EventInfo", "EventInfo key"}

Definition at line 249 of file TileLaserTimingTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_FiberCorrection

float(* TileLaserTimingTool::m_FiberCorrection)[NDRAWERS][NCHANNELS]

private

Definition at line 224 of file TileLaserTimingTool.h.

◆ m_FiberLength

float(* TileLaserTimingTool::m_FiberLength)[NDRAWERS][NCHANNELS]

private

Definition at line 220 of file TileLaserTimingTool.h.

◆ m_fiberLightSpeed

double TileLaserTimingTool::m_fiberLightSpeed = 0.0

private

Definition at line 266 of file TileLaserTimingTool.h.

◆ m_gaussf

TF1* TileLaserTimingTool::m_gaussf

private

Definition at line 286 of file TileLaserTimingTool.h.

◆ m_IOVTag

std::string TileLaserTimingTool::m_IOVTag

private

Definition at line 279 of file TileLaserTimingTool.h.

◆ m_IsConnected

int(* TileLaserTimingTool::m_IsConnected)[NDRAWERS][NCHANNELS]

private

Definition at line 225 of file TileLaserTimingTool.h.

◆ m_maxTimeDiff

float TileLaserTimingTool::m_maxTimeDiff

private

Definition at line 274 of file TileLaserTimingTool.h.

◆ m_MeanEvenPmtTdiff

float(* TileLaserTimingTool::m_MeanEvenPmtTdiff)[NDRAWERS]

private

Definition at line 229 of file TileLaserTimingTool.h.

◆ m_MeanEvenPmtTdiffPMT0

float(* TileLaserTimingTool::m_MeanEvenPmtTdiffPMT0)[NDRAWERS]

private

Definition at line 201 of file TileLaserTimingTool.h.

◆ m_MeanOddPmtTdiff

float(* TileLaserTimingTool::m_MeanOddPmtTdiff)[NDRAWERS]

private

Definition at line 227 of file TileLaserTimingTool.h.

◆ m_MeanOddPmtTdiffPMT0

float(* TileLaserTimingTool::m_MeanOddPmtTdiffPMT0)[NDRAWERS]

private

Definition at line 199 of file TileLaserTimingTool.h.

◆ m_nevts

int TileLaserTimingTool::m_nevts

private

number of laser events

Definition at line 284 of file TileLaserTimingTool.h.

◆ m_nSamples

unsigned TileLaserTimingTool::m_nSamples

private

Definition at line 267 of file TileLaserTimingTool.h.

◆ m_ntupleID

std::string TileLaserTimingTool::m_ntupleID

private

Definition at line 265 of file TileLaserTimingTool.h.

◆ m_OddPmtCounter

int(* TileLaserTimingTool::m_OddPmtCounter)[NDRAWERS]

private

Definition at line 228 of file TileLaserTimingTool.h.

◆ m_OddPmtCounterPMT0

int(* TileLaserTimingTool::m_OddPmtCounterPMT0)[NDRAWERS]

private

Definition at line 200 of file TileLaserTimingTool.h.

◆ m_PedestalMean

float(* TileLaserTimingTool::m_PedestalMean)[NDRAWERS][NCHANNELS]

private

Definition at line 190 of file TileLaserTimingTool.h.

◆ m_PedestalSigma

float(* TileLaserTimingTool::m_PedestalSigma)[NDRAWERS][NCHANNELS]

private

Definition at line 191 of file TileLaserTimingTool.h.

◆ m_rawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileLaserTimingTool::m_rawChannelContainerKey

private

Initial value:

{this,

"TileRawChannelContainer", "TileRawChannelFit", "Tile raw channel container"}

Definition at line 251 of file TileLaserTimingTool.h.

◆ m_rawChannelContainerName

std::string TileLaserTimingTool::m_rawChannelContainerName

private

Definition at line 263 of file TileLaserTimingTool.h.

◆ m_refDrawer

unsigned int TileLaserTimingTool::m_refDrawer

private

Definition at line 271 of file TileLaserTimingTool.h.

◆ m_tileHWID

const TileHWID* TileLaserTimingTool::m_tileHWID

private

Definition at line 257 of file TileLaserTimingTool.h.

◆ m_tileToolTiming

ToolHandle<TileCondToolTiming> TileLaserTimingTool::m_tileToolTiming

private

Initial value:

{this,

"TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"}

Definition at line 259 of file TileLaserTimingTool.h.

◆ m_TimeDiffMean

float(* TileLaserTimingTool::m_TimeDiffMean)[NDRAWERS][NCHANNELS]

private

Definition at line 194 of file TileLaserTimingTool.h.

◆ m_TimeDiffMeanError

float(* TileLaserTimingTool::m_TimeDiffMeanError)[NDRAWERS][NCHANNELS]

private

Definition at line 195 of file TileLaserTimingTool.h.

◆ m_TimeDiffPMTDigi0

float(* TileLaserTimingTool::m_TimeDiffPMTDigi0)[NDRAWERS][NCHANNELS]

private

Definition at line 223 of file TileLaserTimingTool.h.

◆ m_TimeDiffSigma

float(* TileLaserTimingTool::m_TimeDiffSigma)[NDRAWERS][NCHANNELS]

private

Definition at line 196 of file TileLaserTimingTool.h.

◆ m_useMeanChannelOffset

bool TileLaserTimingTool::m_useMeanChannelOffset

private

Definition at line 272 of file TileLaserTimingTool.h.

◆ m_usePMT0AsDskewRef

bool TileLaserTimingTool::m_usePMT0AsDskewRef

private

Definition at line 276 of file TileLaserTimingTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ NROS

const int TileLaserTimingTool::NROS = 5

staticprivate

Definition at line 176 of file TileLaserTimingTool.h.

◆ s_fiberLength

float const TileLaserTimingTool::s_fiberLength

staticprivate

Initial value:

= {{167.1,167.1,178.7,178.7,190.3,190.3,201.9,201.9,213.5,213.5,
                            225.1,225.1,236.7,236.7,248.3,248.3,259.9,259.9,271.5,271.5,
                            283.1,283.1,294.7,294.7,201.9,201.9,213.5,213.5,225.1,225.1,
                            236.7,236.7,248.3,248.3,259.9,259.9,271.5,271.5,283.1,283.1,
                            294.7,294.7,306.3,306.3,317.9,317.9,329.6,329.6},
                           
                           { 51.1, 51.1, 62.7, 62.7, 74.3, 74.3, 85.9, 85.9, 97.5, 97.5,
                            109.1,109.1,120.7,120.7,132.3,132.3,143.9,143.9,143.9,143.9,
                            167.1,167.1,178.1,178.1,178.1,178.1,178.1,178.1,213.5,213.5,
                            213.5,213.5,236.7,236.7,236.7,236.7,259.9,259.9,259.9,259.9,
                            283.1,283.1,294.7,294.7,294.7,294.7,294.7,294.7}}

Definition at line 300 of file TileLaserTimingTool.h.

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

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ TDrawerArrayF

◆ TDrawerArrayI

◆ TPMTArray

Constructor & Destructor Documentation

◆ TileLaserTimingTool()

◆ ~TileLaserTimingTool()

Member Function Documentation

◆ channel2PMT()

◆ correctEvenOddPMT()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ drawerData()

◆ drawerId() [1/2]

◆ drawerId() [2/2]

◆ drawerIdStr()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ fiberCorrection()

◆ fiberLength()

◆ finalize()

◆ finalizeCalculations()

◆ fitGauss()

◆ fitGauss2()

◆ initialize()

◆ initNtuple()

◆ inputHandles()

◆ interfaceID()

◆ isBarrel()

◆ isConnectedChan()

◆ isConnectedPMT()

◆ isExtBarrel()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ writeNtuple()

Member Data Documentation

◆ m_ADCAmplitude

◆ m_cabling

◆ m_ChannelOffset

◆ m_ChannelOffsetError

◆ m_detStore

◆ m_DigiMean

◆ m_digitsContainerKey

◆ m_digitsContainerName

◆ m_drawerData

◆ m_DrawerOffset

◆ m_DrawerOffsetError

◆ m_DSkewSet

◆ m_eneLowLimitPulseShape

◆ m_EvenOddTimeDiff

◆ m_EvenOddTimeDiffPMT0