TileRawChNoiseCalibAlg Class Reference

#include <TileRawChNoiseCalibAlg.h>

Inheritance diagram for TileRawChNoiseCalibAlg:

Collaboration diagram for TileRawChNoiseCalibAlg:

Public Member Functions
	TileRawChNoiseCalibAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TileRawChNoiseCalibAlg ()
virtual StatusCode	initialize () override
	Only array initialization is done here All the helpers initialization is done at the first event.
virtual StatusCode	execute () override
	Main method.
virtual StatusCode	finalize () override
	The output ntuple is created in finalize method.
void	finalRawCh (int rctype)
	finalDigits is called during finalize Here the average Ped, lfn, hfn and covariance are calculated.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Attributes
static constexpr int	NSIDES = 2
static constexpr int	NSAMPLES = 4
static constexpr int	NTOWERS = 17
static constexpr int	NCELLGAINS = 6
static constexpr int	NPARS = 8

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
enum	RCtype {   Fit = 0 , Fixed = 1 , Opt = 2 , Dsp = 3 ,   OF1 = 4 , MF = 5 , RCnum = 6 }
enum	trigtype {   Unknown = 0 , Phys = 1 , Las = 2 , Ped = 4 ,   Cis = 8 }
enum	CELL_CHANNEL { OUTER_MBTS_CHANNEL = 4 , SPECIAL_C10_CHANNEL = 5 , E1_CHANNEL = 12 }
using	Tile = TileCalibUtils
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	FirstEvt_initialize ()
	Initialization done at the first event.
StatusCode	fillRawChannels (const TileDQstatus *dqStatus, const SG::ReadHandleKey< TileRawChannelContainer > &rawChannelContainerKey, RCtype rctype)
void	StoreRunInfo (const TileDQstatus *dqStatus)
	StoreRunInfo is called only during the first event.
void	fillCell (TileRawChannelUnit::UNIT RChUnit, const TileRawChannel *rch)
void	fillCellHist ()
	fillCellHist is called during execute It fill the HGHG and LGLG combination of the cell energies
void	finalCell ()
	finalCell is called during finalize Here the cell variables of the ntuple are filled.
void	deleteHist ()
	deleteHist is called at finalize to ensure that no histogram goes into any output root file delete [] didn't work properly
int	digiChannel2PMT (int ros, int chan)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static void	doFit (TH1F *h, float *gp, bool invert=true)
	doFit performs the double gaussian fit of the amplitude

Private Attributes
bool	m_calibMode
bool	m_doFit
bool	m_doFixed
bool	m_doOpt
bool	m_doDsp
bool	m_doOF1
bool	m_doMF
bool	m_saveHist
bool	m_invertChanRatio
int	m_UseforCells
bool	m_maskBadChannels
bool	m_usePMT
bool	m_fillidx
TileBeamElemContByteStreamCnv *	m_beamCnv
const TileCablingService *	m_cabling
const TileID *	m_tileID
const TileHWID *	m_tileHWID
ToolHandle< TileCondToolEmscale >	m_tileToolEmscale
ToolHandle< ITileBadChanTool >	m_tileBadChanTool
SG::ReadHandleKey< TileDQstatus >	m_dqStatusKey
ToolHandle< TileCondIdTransforms >	m_tileIdTrans
const uint32_t *	m_cispar
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerFixedKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerFitKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerOptKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerDspKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerOF1Key
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerMFKey
std::string	m_ntupleID
std::string	m_file
int64_t	m_treeSize
std::string	m_digitsContainer
std::string	m_beamElemContainer
std::string	m_fixedRawChannelContainer
std::string	m_fitRawChannelContainer
std::string	m_optRawChannelContainer
std::string	m_dspRawChannelContainer
std::string	m_OF1RawChannelContainer
std::string	m_MFRawChannelContainer
TH1F *(*	m_histAmp )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
TH1F *(*	m_histCellAmp )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
int	m_evtNr
int(*	m_evt )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
uint8_t(*	m_ros )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
uint8_t(*	m_drawer )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
uint8_t(*	m_channel )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
bool(*	m_gain )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
int	m_time
int	m_year
int	m_month
int	m_day
int	m_yday
int	m_hour
int	m_min
int	m_run
int	m_trigType
float(*	m_rc_mean )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_sigma )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_av )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_rms )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_skewness )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_kurtosis )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_mean_err )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_sigma_err )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_chi2 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_ndf )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_probC2 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_ggpar )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]
float(*	m_rc_gsigma1 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_gsigma2 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_gnorm )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_gchi2 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_gerrsigma1 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_gerrsigma2 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_gerrnorm )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_rc_gcorrsigma1sigma2 )[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
bool(*	m_side )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
uint8_t(*	m_phi )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
uint8_t(*	m_sample )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
uint8_t(*	m_tower )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
uint8_t(*	m_gg )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_ecell_av )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_ecell_rms )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
uint32_t(*	m_ecell_hash )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS]
int(*	m_cell_nch )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
float(*	m_ecell_ene )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
float(*	m_ggpar )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]
float(*	m_gsigma1 )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_gsigma2 )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_gnorm )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_gchi2 )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_gerrsigma1 )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_gerrsigma2 )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_gerrnorm )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
float(*	m_gcorrsigma1sigma2 )[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 47 of file TileRawChNoiseCalibAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Tile

using TileRawChNoiseCalibAlg::Tile = TileCalibUtils

private

Definition at line 168 of file TileRawChNoiseCalibAlg.h.

Member Enumeration Documentation

CELL_CHANNEL

enum TileRawChNoiseCalibAlg::CELL_CHANNEL

private

Enumerator
OUTER_MBTS_CHANNEL
SPECIAL_C10_CHANNEL
E1_CHANNEL

Definition at line 243 of file TileRawChNoiseCalibAlg.h.

{OUTER_MBTS_CHANNEL = 4, SPECIAL_C10_CHANNEL = 5, E1_CHANNEL = 12};

RCtype

enum TileRawChNoiseCalibAlg::RCtype

private

Enumerator
Fit
Fixed
Opt
Dsp
OF1
MF
RCnum

Definition at line 67 of file TileRawChNoiseCalibAlg.h.

                {
      Fit = 0, Fixed = 1, Opt = 2, Dsp = 3, OF1 = 4, MF = 5, RCnum = 6
    };

trigtype

enum TileRawChNoiseCalibAlg::trigtype

private

Enumerator
Unknown
Phys
Las
Ped
Cis

Definition at line 71 of file TileRawChNoiseCalibAlg.h.

                  {
      Unknown = 0, Phys = 1, Las = 2, Ped = 4, Cis = 8
    };

Constructor & Destructor Documentation

TileRawChNoiseCalibAlg()

TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 51 of file TileRawChNoiseCalibAlg.cxx.

 : AthAlgorithm(name,pSvcLocator)
  , m_beamCnv(nullptr)
  , m_cabling(nullptr)
  , m_tileID(nullptr)
  , m_tileHWID(nullptr)
  , m_cispar(nullptr)
  //, m_nDrawers(0)
  , m_time(0)
  , m_year(0)
  , m_month(0)
  , m_day(0)
  , m_yday(0)
  , m_hour(0)
  , m_min(0)
  , m_run(0)
  , m_trigType(0)
{
 
  declareProperty("TileDigitsContainer", m_digitsContainer = "TileDigitsCnt");    
  declareProperty("TileBeamElemContainer", m_beamElemContainer = "TileBeamElemCnt");
  declareProperty("doFit" , m_doFit  = true);
  declareProperty("doFixed", m_doFixed = true); 
  declareProperty("doOpt" , m_doOpt  = true); 
  declareProperty("doDsp" , m_doDsp  = true); 
  declareProperty("doOF1" , m_doOF1  = true); 
  declareProperty("doMF" , m_doMF  = true); 
  declareProperty("SaveHist", m_saveHist = false); // write all histograms to output file
  declareProperty("InvertChanRatio", m_invertChanRatio = true); // swap two sigmas and invert ratio if it is above 1.0 (channel fit only)
  declareProperty("MaskBadChannels",m_maskBadChannels = true);
  declareProperty("UseforCells" , m_UseforCells  = 2); // Fit=0, Fixed=1,  Opt=2, Dsp=3, OF1=4, MF=5
  declareProperty("CalibMode", m_calibMode = true);  
  declareProperty("UsePMT", m_usePMT = false);  
  declareProperty("RunNumber", m_run=0);
  declareProperty("FileNamePrefix", m_file="RawCh_NoiseCalib");
  declareProperty("NtupleID", m_ntupleID="RawCh_NoiseCalib");
  declareProperty("TreeSize", m_treeSize = 16000000000LL);
  declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
 
  m_evtNr=-1;
 
  m_fillidx=false;
 
  m_histAmp = new TH1F*[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_histCellAmp = new TH1F*[2][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_mean = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_sigma = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_av = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_rms = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_skewness = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_kurtosis = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_mean_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_sigma_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_chi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_ndf = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_probC2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_ggpar = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]();
  m_rc_gsigma1 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_gsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_gnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_gchi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_gerrsigma1= new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_gerrsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_gerrnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_rc_gcorrsigma1sigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
 
  m_side = new bool[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_phi = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_sample = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_tower = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gg = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_ecell_av = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_ecell_rms= new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_ecell_hash= new uint32_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS]();
  
  m_cell_nch = new int[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
  m_ecell_ene = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
  m_ggpar = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]();
  m_gsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gchi2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gerrsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gerrsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gerrnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
  m_gcorrsigma1sigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
}

~TileRawChNoiseCalibAlg()

TileRawChNoiseCalibAlg::~TileRawChNoiseCalibAlg ( )

virtual

Definition at line 144 of file TileRawChNoiseCalibAlg.cxx.

{ 
  delete[] m_histAmp;
  delete[] m_histCellAmp;
  delete[] m_evt;
  delete[] m_ros;
  delete[] m_drawer;
  delete[] m_channel;
  delete[] m_gain;
  delete[] m_rc_mean;
  delete[] m_rc_sigma;
  delete[] m_rc_av;
  delete[] m_rc_rms;
  delete[] m_rc_skewness;
  delete[] m_rc_kurtosis;
  delete[] m_rc_mean_err;
  delete[] m_rc_sigma_err;
  delete[] m_rc_chi2;
  delete[] m_rc_ndf;
  delete[] m_rc_probC2;
  delete[] m_rc_ggpar;
  delete[] m_rc_gsigma1;
  delete[] m_rc_gsigma2;
  delete[] m_rc_gnorm;
  delete[] m_rc_gchi2;
  delete[] m_rc_gerrsigma1;
  delete[] m_rc_gerrsigma2;
  delete[] m_rc_gerrnorm;
  delete[] m_rc_gcorrsigma1sigma2;
 
  delete[] m_side;
  delete[] m_phi;
  delete[] m_sample;
  delete[] m_tower;
  delete[] m_gg;
  delete[] m_ecell_av;
  delete[] m_ecell_rms;
  delete[] m_ecell_hash;
   
  delete[] m_cell_nch;
  delete[] m_ecell_ene;
  delete[] m_ggpar;
  delete[] m_gsigma1;
  delete[] m_gsigma2;
  delete[] m_gnorm;
  delete[] m_gchi2;
  delete[] m_gerrsigma1;
  delete[] m_gerrsigma2;
  delete[] m_gerrnorm;
  delete[] m_gcorrsigma1sigma2;
}

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

deleteHist()

void TileRawChNoiseCalibAlg::deleteHist ( )

private

deleteHist is called at finalize to ensure that no histogram goes into any output root file delete [] didn't work properly

Definition at line 1136 of file TileRawChNoiseCalibAlg.cxx.

                                        {
/*---------------------------------------------------------*/
 
  for (int rc = 0; rc < RCnum; ++rc) {
    for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
      for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
 
        for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
          for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
            delete m_histAmp[rc][ros][drawer][ch][g];
          }
        }
      }
    }
  }
 
  for (int side = 0; side < 2; side++) {
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      for (int sample = 0; sample < 4; ++sample) {
        for (int tower = 0; tower < 17; ++tower) {
          for (int gg = 0; gg < 6; gg++) {
            delete m_histCellAmp[side][drawer][sample][tower][gg];
          }
        }
      }
    }
  }
 
}

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

digiChannel2PMT()

int TileRawChNoiseCalibAlg::digiChannel2PMT ( int ros, int chan )

inlineprivate

Definition at line 89 of file TileRawChNoiseCalibAlg.h.

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

doFit()

void TileRawChNoiseCalibAlg::doFit ( TH1F * h, float * gp, bool invert = true )

staticprivate

doFit performs the double gaussian fit of the amplitude

Definition at line 1000 of file TileRawChNoiseCalibAlg.cxx.

                                                                   {
/*---------------------------------------------------------*/
  Double_t par[6];
 
  float xmin = h->GetBinCenter(1);
  float xmax = h->GetBinCenter(h->GetNbinsX());
  TF1 total("total", "gaus(0)+gaus(3)", xmin, xmax);
  total.SetLineColor(2);
 
  float nentries = h->GetEntries();
 
  if (nentries == 0) {
    // Protect against empty histogram.
    std::fill (gp, gp+8, 0);
    return;
  }
 
  float rms = h->GetRMS();
  float bin = h->GetBinWidth(0);
 
  par[0] = 0.1 * nentries;
  par[1] = 0.;
  par[2] = 0.7 * std::max(rms, bin);
 
  par[3] = 0.15 * par[0];
  par[4] = 0.;
  par[5] = 5. * par[2];
 
  total.SetParameters(par);
 
  float lim1 = bin / 2.;
  float lim2 = std::max(rms * 1.05, bin * 2.0);
  float lim3 = std::max(rms * 10.0, bin * 20.);
 
  float limN1 = nentries;
  if (lim1 < 0.5) limN1 /= (2. * lim1); // a bit more than Nentries / ( sqrt(2*pi) * sigma1 )
  float limN2 = nentries;
  if (lim2 < 0.5) limN2 /= (2. * lim2); // a bit more than Nentries / ( sqrt(2*pi) * sigma2 )
   
  total.SetParLimits(0, 0., limN1);
  total.FixParameter(1, 0.);
  total.SetParLimits(2, lim1, lim2);
  total.SetParLimits(3, 0., limN2);
  total.FixParameter(4, 0.);
  total.SetParLimits(5, lim2, lim3);
 
  TFitResultPtr resfit = h->Fit(&total, "BLQRS");
 
  float par0 = total.GetParameter(0);
  float par3 = total.GetParameter(3);
 
  float sigma1 = total.GetParameter(2); //sigma gauss1
  float sigma2 = total.GetParameter(5); //sigma gauss1
 
  //Get errors
  float errpar0 = total.GetParError(0);
  float errpar3 = total.GetParError(3);
 
  float errsigma1 = total.GetParError(2);
  float errsigma2 = total.GetParError(5);
 
  float norm = par0 != 0 ? par3 / par0 : 0; //rel normalization of the gaussians
 
  if (invert && norm > 1.) {  //invert the 2 gaussians if normalization is greater than 1
 
    gp[0] = sigma2;
    gp[1] = 1. / norm;
    gp[2] = sigma1;
 
    gp[4] = errsigma2;
    gp[5] = sqrt((errpar0 * errpar0) + (errpar3 * errpar3) * (par0 * par0) / (par3 * par3)) / par3;
    gp[6] = errsigma1;
 
  } else {
 
    gp[0] = sigma1;
    gp[1] = norm;
    gp[2] = sigma2;
 
    gp[4] = errsigma1;
    gp[5] = par0 != 0 ? sqrt((errpar3 * errpar3) + (errpar0 * errpar0) * (par3 * par3) / (par0 * par0)) / par0 : 0;
    gp[6] = errsigma2;
 
  }
 
  if (total.GetNDF() > 0) {
    gp[3] = total.GetChisquare() / total.GetNDF(); //chi2/ndf
  } else {
    gp[3] = 0.;
  }
 
  // Get correlation sigma1, sigma2
  if (resfit->CovMatrixStatus()) {
    TMatrixDSym corr = resfit->GetCorrelationMatrix();
    gp[7] = corr(2, 5);
  }
  else {
    // May happen if the input histogram is empty.
    gp[7] = 0;
  }
}

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TileRawChNoiseCalibAlg::execute ( )

overridevirtual

Main method.

Definition at line 317 of file TileRawChNoiseCalibAlg.cxx.

                                           {
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
 
  bool empty(false); // to add all StatusCodes
 
  if (m_evtNr < 0) {
 
    if (FirstEvt_initialize().isFailure()) { ATH_MSG_ERROR( "FirstEvt_initialize failed" ); }
 
    bool calibMode  = (dqStatus->calibMode() == 1);
    if ( calibMode != m_calibMode ) {
      ATH_MSG_INFO( "Overwriting calib mode [" << m_calibMode << "] by one from data: " << calibMode );
      m_calibMode = calibMode;
    }
 
    m_cispar = dqStatus->cispar();
    StoreRunInfo(dqStatus); // done only once
  }
 
  memset(m_ecell_ene     ,0,          2 * sizeof( *m_ecell_ene     ));
  memset(m_cell_nch      ,0,          2 * sizeof( *m_cell_nch      ));
 
  m_cispar = dqStatus->cispar();
  if (m_evtNr % 1000 == 0) ATH_MSG_INFO( " events processed so far " << m_evtNr );
  
 
  if (m_doFit) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerFitKey, Fit).isFailure());}
  if (m_doFixed) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerFixedKey, Fixed).isFailure());}
  if (m_doOpt) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerOptKey, Opt).isFailure());}
  if (m_doDsp) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerDspKey, Dsp).isFailure());}
  if (m_doOF1) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerOF1Key, OF1).isFailure());}
  if (m_doMF) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerMFKey, MF).isFailure());}
 
 
  if (empty) {ATH_MSG_ERROR( "Error in execute " ); }
  ++m_evtNr;
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

fillCell()

void TileRawChNoiseCalibAlg::fillCell ( TileRawChannelUnit::UNIT RChUnit, const TileRawChannel * rch )

private

Definition at line 871 of file TileRawChNoiseCalibAlg.cxx.

                                                                                                {
  /*---------------------------------------------------------*/
 
  int index, pmt;
  Identifier cell_id = rch->cell_ID_index(index, pmt);
  if (index > -1) { //disconnect channel index is -1/ MBTS cell index is -2 and they don't have an idhash
    unsigned int ros(0), drawer(0), channel(0), gain(0);
    m_tileIdTrans->getIndices(rch->adc_HWID(), ros, drawer, channel, gain);
    unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
    if (m_maskBadChannels && m_tileBadChanTool->getAdcStatus(drawerIdx, channel, gain).isBad()) {
      ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
                       << " channel: " << channel
                       << " ADC: " << gain
                       << " in fillCell() because channel is bad in DB." );
      return;
    }
 
    int sample = m_tileID->sample(cell_id);
    int tower = m_tileID->tower(cell_id);
    int side = m_tileID->side(cell_id);
 
    if (side == 1) side = 0; //A side
    else if (side == -1) side = 1; //C side
    else side = 0; //D0 cell? we put it in LBA
 
    if (m_evtNr < 1) { //first event
      m_ecell_hash[side][drawer][sample][tower] = m_tileID->cell_hash(cell_id);
    }
 
    int g, gg;
    if (gain == 0) {
      gg = 0;
      if (pmt == 0) g = 1; //in most cases even channels on side A AND odd channels on side C
      else  g = 2;                        //are the first channels of the cells
    } else {
      gg = 3;
      if (pmt == 0) g = 4; //pmt tells us which is the first and second channel of the cells!!
      else g = 5;
    }
 
    //not needed anymore    if (channel==0 && ros==2) g++;  //D0 second channel is special : move from first to second channel
 
    double amp = rch->amplitude();
    amp = m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, amp, RChUnit, TileRawChannelUnit::MegaElectronVolts);
    int nch = 1;
    
    if (m_cabling->isRun2PlusCabling() && (ros > 2)) { // Ext.barrel modules
        
      if (channel == E1_CHANNEL) { // Raw channel -> E1 cell.
        int drawer2 = m_cabling->E1_merged_with_run2plus(ros, drawer);
        if (drawer2 != 0) { // Raw channel splitted into two E1 cells for Run 2.
          amp /= 2.0F;
          m_ecell_ene[side][drawer2][sample][tower][gg / 3] += amp;
          ++m_cell_nch[side][drawer2][sample][tower][gg / 3];
        
          if (TMath::Abs(amp) > 1.e-5) {
            m_histCellAmp[side][drawer2][sample][tower][g]->Fill(amp);
          }
        }
 
      } else if (!TileCablingService::C10_connected(drawer)) { // modules with special C10
        if (channel == OUTER_MBTS_CHANNEL) {
          amp = 0.0; // ignore MBTS completely
          nch = 0;
        } else if (channel == SPECIAL_C10_CHANNEL) {
          nch = 2; // count this channel twice - needed for correct bad-channel masking
        }
      }
    }
 
    m_ecell_ene[side][drawer][sample][tower][gg / 3] += amp;
    m_cell_nch[side][drawer][sample][tower][gg / 3] += nch;
 
    if (TMath::Abs(amp) > 1.e-5) {
      m_histCellAmp[side][drawer][sample][tower][g]->Fill(amp);
    }
 
  } // is a connected channel
}

fillCellHist()

void TileRawChNoiseCalibAlg::fillCellHist ( )

private

fillCellHist is called during execute It fill the HGHG and LGLG combination of the cell energies

Definition at line 1106 of file TileRawChNoiseCalibAlg.cxx.

                                          {
/*---------------------------------------------------------*/
 
  for (int side = 0; side < 2; ++side) {
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      for (int sample = 0; sample < 4; ++sample) {
        for (int tower = 0; tower < 17; ++tower) {
          for (unsigned int gg = 0; gg < TileCalibUtils::MAX_GAIN; ++gg) {
 
            float ene = m_ecell_ene[side][drawer][sample][tower][gg];
            if (m_cell_nch[side][drawer][sample][tower][gg] == 1 && sample != 3) ene *= 2; // one good channel in normal cell - multiply energy by 2
 
            if (TMath::Abs(ene) > 1.e-5) {
              m_histCellAmp[side][drawer][sample][tower][gg * 3]->Fill(ene);
            }
 
          }
        }
      }
    }
  }
 
}

fillRawChannels()

StatusCode TileRawChNoiseCalibAlg::fillRawChannels ( const TileDQstatus * dqStatus, const SG::ReadHandleKey< TileRawChannelContainer > & rawChannelContainerKey, RCtype rctype )

private

Definition at line 712 of file TileRawChNoiseCalibAlg.cxx.

                                                                  {
/*---------------------------------------------------------*/
 
  SG::ReadHandle<TileRawChannelContainer> rawChannelContainer(rawChannelContainerKey);
  ATH_CHECK( rawChannelContainer.isValid() );
 
  if ((rctype == Dsp) && (m_trigType != Phys)) {
    ATH_MSG_ERROR( "Removing DSP RawChannelContainer for non Phys run. TrigType is: " << m_trigType );
    return StatusCode::FAILURE;
  }
 
  TileRawChannelUnit::UNIT RChUnit = rawChannelContainer->get_unit();
 
  TileRawChannelContainer::const_iterator collItr = rawChannelContainer->begin();
  TileRawChannelContainer::const_iterator lastColl = rawChannelContainer->end();
 
  for (; collItr != lastColl; ++collItr) {
 
    TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
    TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
 
    for (; chItr != lastCh; ++chItr) {
 
      const TileRawChannel* rch = (*chItr);
 
      HWIdentifier adc_id = (*chItr)->adc_HWID();
      unsigned int ros(0), drawer(0), channel(0), gain(0);
      m_tileIdTrans->getIndices(adc_id, ros, drawer, channel, gain);
      unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
      if (dqStatus->isChEmpty(ros, drawer, channel)) continue;
 
      // If DQ problem, do not fill calib ntuple
      if (m_calibMode == 1) { // Bigain: check indivual adc's
 
        if (!(dqStatus->isAdcDQgood(ros, drawer, channel, gain))) {
          ATH_MSG_VERBOSE(  "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
                           << " channel: " << channel
                           << " ADC: " << gain << " due to DQ error found." );
 
          continue;
        }
      } else { // monogain, just check channel
 
        if (!(dqStatus->isChanDQgood(ros, drawer, channel))) {
          ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
                           << " channel: " << channel << " due to DQ error found."  );
 
          continue;
        }
      }
 
      // we fill the cell information now for selected method
      // note that fillCell is called only for good channels
      if (rctype == m_UseforCells) fillCell(RChUnit, rch);
 
      double amp = rch->amplitude();
      if (RChUnit > TileRawChannelUnit::OnlineADCcounts) {
        // go from online units to ADC counts
        amp = m_tileToolEmscale->undoOnlCalib(drawerIdx, channel, gain, amp, RChUnit);
      } else if (RChUnit == TileRawChannelUnit::OnlineADCcounts) {
        // nothing to do
      } else if (RChUnit > TileRawChannelUnit::ADCcounts) {
        // go from offline units to ADC counts
        amp /= m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, 1.0, TileRawChannelUnit::ADCcounts, RChUnit);
      }
 
      // PMT-1 or channel index depending on jobOptions
      unsigned int chan = (m_usePMT) ? digiChannel2PMT(ros, channel) : channel;
 
      m_evt[ros][drawer][chan][gain]++;
      m_histAmp[rctype][ros][drawer][chan][gain]->Fill(amp);
    }
  }
 
  if (rctype == m_UseforCells) fillCellHist(); //we fill the cell histograms only at the end of the loop over the channels,
                                               //when all the cells have been built
 
  return StatusCode::SUCCESS;
}

finalCell()

void TileRawChNoiseCalibAlg::finalCell ( )

private

finalCell is called during finalize Here the cell variables of the ntuple are filled.

Definition at line 956 of file TileRawChNoiseCalibAlg.cxx.

                                       {
  /*---------------------------------------------------------*/
 
  for (int side = 0; side < 2; ++side) {
    ATH_MSG_INFO( "Fitting cells side " << side );
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      for (int sample = 0; sample < 4; ++sample) {
        for (int tower = 0; tower < 17; ++tower) {
          for (int gg = 0; gg < 6; ++gg) {
 
            m_side[side][drawer][sample][tower][gg] = side;
            m_phi[side][drawer][sample][tower][gg] = drawer;
            m_sample[side][drawer][sample][tower][gg] = sample;
            m_tower[side][drawer][sample][tower][gg] = tower;
            m_gg[side][drawer][sample][tower][gg] = gg;
 
            if (m_histCellAmp[side][drawer][sample][tower][gg]->GetEntries() > 0) {
 
              m_ecell_av[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetMean();
              m_ecell_rms[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetRMS();
              doFit(m_histCellAmp[side][drawer][sample][tower][gg], m_ggpar[side][drawer][sample][tower][gg]);
              m_gsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][0];
              m_gsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][2];
              m_gnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][1];
              m_gchi2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][3];
              m_gerrsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][4];
              m_gerrnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][5];
              m_gerrsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][6];
              m_gcorrsigma1sigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][7];
//              gcorrsigma1norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][8];
//              gcorrsigma2norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][9];
 
            }
 
          }
        }
      }
    }
  }
 
}

finalize()

StatusCode TileRawChNoiseCalibAlg::finalize ( )

overridevirtual

The output ntuple is created in finalize method.

Definition at line 361 of file TileRawChNoiseCalibAlg.cxx.

                                            {
 
  ATH_MSG_INFO( "Finalizing TileRawChNoiseCalibAlg" );
 
  if (m_doFit) finalRawCh(Fit);
  if (m_doFixed) finalRawCh(Fixed);
  if (m_doOpt) finalRawCh(Opt);
  if (m_doDsp) finalRawCh(Dsp);
  if (m_doOF1) finalRawCh(OF1);
  if (m_doMF) finalRawCh(MF);
 
  if (m_UseforCells == 0) {
    if (m_doFit) finalCell();
  } else if (m_UseforCells == 1) {
    if (m_doFixed) finalCell();
  } else if (m_UseforCells == 2) {
    if (m_doOpt) finalCell();
  } else if (m_UseforCells == 3) {
    if (m_doDsp) finalCell();
  } else if (m_UseforCells == 4) {
    if (m_doOF1) finalCell();
  } else if (m_UseforCells == 5) {
    if (m_doMF) finalCell();
  } else {
    ATH_MSG_WARNING( "unknown rawchannel type used for cells" << m_UseforCells );
  }
 
  std::ostringstream sStr;
  std::string trig_str;
 
  if (m_trigType == Phys) trig_str = "Phys";
  else if (m_trigType == Las) trig_str = "Las";
  else if (m_trigType == Ped) trig_str = "Ped";
  else if (m_trigType == Cis) trig_str = "Cis";
  else {
    ATH_MSG_WARNING( "Unknown trigger type " << m_trigType );
    trig_str = "Unk";
  }
 
  sStr << m_file << "_" << m_run  << "_" << trig_str << ".root";
  m_file = sStr.str();
  ATH_MSG_INFO( "Writing calibrations to file " << m_file );
 
  // Create output file: for now creating file for just this
  // algorithm; want to add to ntuple file eventually??
  TFile* fout = new TFile(m_file.c_str(), "recreate");
 
  // Create tree with branches
  TTree* t = new TTree(m_ntupleID.c_str(), "Tile_RC_NoiseCalib-Ntuple");
 
  t->Branch("RunNumber", &m_run, "RunNumber/I");
  t->Branch("TrigType", &m_trigType, "TrigType/I");
  t->Branch("Time", &m_time, "Time/I");
  t->Branch("Year", &m_year, "Year/I");
  t->Branch("Month", &m_month, "Month/I");
  t->Branch("Day", &m_day, "Day/I");
  t->Branch("YDay", &m_yday, "YDay/I");
  t->Branch("Hour", &m_hour, "Hour/I");
  t->Branch("Min", &m_min, "Min/I"); 
  t->Branch("nEvt", &m_evtNr, "nEvt/I"); // events processed
  t->Branch("EvtNr", &m_evtNr, "EvtNr/I");
  t->Branch("EvtGood", *m_evt, "Evt[5][64][48][2]/I"); // events used in the noise calculation for every channel
 
 
  t->Branch("ros", *m_ros, "ros[5][64][48][2]/b");
  t->Branch("drawer", *m_drawer, "drawer[5][64][48][2]/b");
  t->Branch("channel", *m_channel, "channel[5][64][48][2]/b");
  t->Branch("gain", *m_gain, "gain[5][64][48][2]/O");
 
  t->Branch("efit_mean",*(m_rc_mean[Fit]),"efit_mean[5][64][48][2]/F");
  t->Branch("efit_av",*(m_rc_av[Fit]),"efit_av[5][64][48][2]/F");
  t->Branch("efit_rms",*(m_rc_rms[Fit]),"efit_rms[5][64][48][2]/F");
  t->Branch("efit_sigma",*(m_rc_sigma[Fit]),"efit_sigma[5][64][48][2]/F");
  t->Branch("efit_mean_err",*(m_rc_mean_err[Fit]),"efit_mean_err[5][64][48][2]/F");
  t->Branch("efit_sigma_err",*(m_rc_sigma_err[Fit]),"efit_sigma_err[5][64][48][2]/F");
  t->Branch("efit_kurtosis",*(m_rc_kurtosis[Fit]),"efit_kurtosis[5][64][48][2]/F");
  t->Branch("efit_skewness",*(m_rc_skewness[Fit]),"efit_skewness[5][64][48][2]/F");
  t->Branch("efit_chi2",*(m_rc_chi2[Fit]),"efit_chi2[5][64][48][2]/F");
  t->Branch("efit_ndf",*(m_rc_ndf[Fit]),"efit_ndf[5][64][48][2]/F");
  t->Branch("efit_probC2",*(m_rc_probC2[Fit]),"efit_probC2[5][64][48][2]/F");
 
  t->Branch("efit_gsigma1",*(m_rc_gsigma1[Fit]),"efit_gsigma1[5][64][48][2]/F");
  t->Branch("efit_gsigma2",*(m_rc_gsigma2[Fit]),"efit_gsigma2[5][64][48][2]/F");
  t->Branch("efit_gnorm",*(m_rc_gnorm[Fit]),"efit_gnorm[5][64][48][2]/F");
  t->Branch("efit_gchi2",*(m_rc_gchi2[Fit]),"efit_gchi2[5][64][48][2]/F");
  t->Branch("efit_gerrsigma1",*(m_rc_gerrsigma1[Fit]),"efit_gerrsigma1[5][64][48][2]/F");
  t->Branch("efit_gerrnorm",*(m_rc_gerrnorm[Fit]),"efit_gerrnorm[5][64][48][2]/F");
  t->Branch("efit_gerrsigma2",*(m_rc_gerrsigma2[Fit]),"efit_gerrsigma2[5][64][48][2]/F");  
  t->Branch("efit_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Fit]),"efit_gcorrsigma1sigma2[5][64][48][2]/F");
 
 
  t->Branch("efixed_mean",*(m_rc_mean[Fixed]),"efixed_mean[5][64][48][2]/F");
  t->Branch("efixed_av",*(m_rc_av[Fixed]),"efixed_av[5][64][48][2]/F");
  t->Branch("efixed_rms",*(m_rc_rms[Fixed]),"efixed_rms[5][64][48][2]/F");
  t->Branch("efixed_sigma",*(m_rc_sigma[Fixed]),"efixed_sigma[5][64][48][2]/F");
  t->Branch("efixed_mean_err",*(m_rc_mean_err[Fixed]),"efixed_mean_err[5][64][48][2]/F");
  t->Branch("efixed_sigma_err",*(m_rc_sigma_err[Fixed]),"efixed_sigma_err[5][64][48][2]/F");
  t->Branch("efixed_kurtosis",*(m_rc_kurtosis[Fixed]),"efixed_kurtosis[5][64][48][2]/F");
  t->Branch("efixed_skewness",*(m_rc_skewness[Fixed]),"efixed_skewness[5][64][48][2]/F");
  t->Branch("efixed_chi2",*(m_rc_chi2[Fixed]),"efixed_chi2[5][64][48][2]/F");
  t->Branch("efixed_ndf",*(m_rc_ndf[Fixed]),"efixed_ndf[5][64][48][2]/F");
  t->Branch("efixed_probC2",*(m_rc_probC2[Fixed]),"efixed_probC2[5][64][48][2]/F");
 
  t->Branch("efixed_gsigma1",*(m_rc_gsigma1[Fixed]),"efixed_gsigma1[5][64][48][2]/F");
  t->Branch("efixed_gsigma2",*(m_rc_gsigma2[Fixed]),"efixed_gsigma2[5][64][48][2]/F");
  t->Branch("efixed_gnorm",*(m_rc_gnorm[Fixed]),"efixed_gnorm[5][64][48][2]/F");
  t->Branch("efixed_gchi2",*(m_rc_gchi2[Fixed]),"efixed_gchi2[5][64][48][2]/F");
  t->Branch("efixed_gerrsigma1",*(m_rc_gerrsigma1[Fixed]),"efixed_gerrsigma1[5][64][48][2]/F");
  t->Branch("efixed_gerrnorm",*(m_rc_gerrnorm[Fixed]),"efixed_gerrnorm[5][64][48][2]/F");
  t->Branch("efixed_gerrsigma2",*(m_rc_gerrsigma2[Fixed]),"efixed_gerrsigma2[5][64][48][2]/F");  
  t->Branch("efixed_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Fixed]),"efixed_gcorrsigma1sigma2[5][64][48][2]/F");
 
 
  t->Branch("eopt_mean",*(m_rc_mean[Opt]),"eopt_mean[5][64][48][2]/F");
  t->Branch("eopt_av",*(m_rc_av[Opt]),"eopt_av[5][64][48][2]/F");
  t->Branch("eopt_rms",*(m_rc_rms[Opt]),"eopt_rms[5][64][48][2]/F");
  t->Branch("eopt_sigma",*(m_rc_sigma[Opt]),"eopt_sigma[5][64][48][2]/F");
  t->Branch("eopt_mean_err",*(m_rc_mean_err[Opt]),"eopt_mean_err[5][64][48][2]/F");
  t->Branch("eopt_sigma_err",*(m_rc_sigma_err[Opt]),"eopt_sigma_err[5][64][48][2]/F");
  t->Branch("eopt_kurtosis",*(m_rc_kurtosis[Opt]),"eopt_kurtosis[5][64][48][2]/F");
  t->Branch("eopt_skewness",*(m_rc_skewness[Opt]),"eopt_skewness[5][64][48][2]/F");
  t->Branch("eopt_chi2",*(m_rc_chi2[Opt]),"eopt_chi2[5][64][48][2]/F");
  t->Branch("eopt_ndf",*(m_rc_ndf[Opt]),"eopt_ndf[5][64][48][2]/F");
  t->Branch("eopt_probC2",*(m_rc_probC2[Opt]),"eopt_probC2[5][64][48][2]/F");
 
  t->Branch("eopt_gsigma1",*(m_rc_gsigma1[Opt]),"eopt_gsigma1[5][64][48][2]/F");
  t->Branch("eopt_gsigma2",*(m_rc_gsigma2[Opt]),"eopt_gsigma2[5][64][48][2]/F");
  t->Branch("eopt_gnorm",*(m_rc_gnorm[Opt]),"eopt_gnorm[5][64][48][2]/F");
  t->Branch("eopt_gchi2",*(m_rc_gchi2[Opt]),"eopt_gchi2[5][64][48][2]/F");
  t->Branch("eopt_gerrsigma1",*(m_rc_gerrsigma1[Opt]),"eopt_gerrsigma1[5][64][48][2]/F");
  t->Branch("eopt_gerrnorm",*(m_rc_gerrnorm[Opt]),"eopt_gerrnorm[5][64][48][2]/F");
  t->Branch("eopt_gerrsigma2",*(m_rc_gerrsigma2[Opt]),"eopt_gerrsigma2[5][64][48][2]/F");  
  t->Branch("eopt_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Opt]),"eopt_gcorrsigma1sigma2[5][64][48][2]/F");
 
 
  t->Branch("edsp_mean",*(m_rc_mean[Dsp]),"edsp_mean[5][64][48][2]/F");
  t->Branch("edsp_av",*(m_rc_av[Dsp]),"edsp_av[5][64][48][2]/F");
  t->Branch("edsp_rms",*(m_rc_rms[Dsp]),"edsp_rms[5][64][48][2]/F");
  t->Branch("edsp_sigma",*(m_rc_sigma[Dsp]),"edsp_sigma[5][64][48][2]/F");
  t->Branch("edsp_mean_err",*(m_rc_mean_err[Dsp]),"edsp_mean_err[5][64][48][2]/F");
  t->Branch("edsp_sigma_err",*(m_rc_sigma_err[Dsp]),"edsp_sigma_err[5][64][48][2]/F");
  t->Branch("edsp_kurtosis",*(m_rc_kurtosis[Dsp]),"edsp_kurtosis[5][64][48][2]/F");
  t->Branch("edsp_skewness",*(m_rc_skewness[Dsp]),"edsp_skewness[5][64][48][2]/F");
  t->Branch("edsp_chi2",*(m_rc_chi2[Dsp]),"edsp_chi2[5][64][48][2]/F");
  t->Branch("edsp_ndf",*(m_rc_ndf[Dsp]),"edsp_ndf[5][64][48][2]/F");
  t->Branch("edsp_probC2",*(m_rc_probC2[Dsp]),"edsp_probC2[5][64][48][2]/F");
 
  t->Branch("edsp_gsigma1",*(m_rc_gsigma1[Dsp]),"edsp_gsigma1[5][64][48][2]/F");
  t->Branch("edsp_gsigma2",*(m_rc_gsigma2[Dsp]),"edsp_gsigma2[5][64][48][2]/F");
  t->Branch("edsp_gnorm",*(m_rc_gnorm[Dsp]),"edsp_gnorm[5][64][48][2]/F");
  t->Branch("edsp_gchi2",*(m_rc_gchi2[Dsp]),"edsp_gchi2[5][64][48][2]/F");
  t->Branch("edsp_gerrsigma1",*(m_rc_gerrsigma1[Dsp]),"edsp_gerrsigma1[5][64][48][2]/F");
  t->Branch("edsp_gerrnorm",*(m_rc_gerrnorm[Dsp]),"edsp_gerrnorm[5][64][48][2]/F");
  t->Branch("edsp_gerrsigma2",*(m_rc_gerrsigma2[Dsp]),"edsp_gerrsigma2[5][64][48][2]/F");  
  t->Branch("edsp_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Dsp]),"edsp_gcorrsigma1sigma2[5][64][48][2]/F");
 
 
  t->Branch("eOF1_mean",*(m_rc_mean[OF1]),"eOF1_mean[5][64][48][2]/F");
  t->Branch("eOF1_av",*(m_rc_av[OF1]),"eOF1_av[5][64][48][2]/F");
  t->Branch("eOF1_rms",*(m_rc_rms[OF1]),"eOF1_rms[5][64][48][2]/F");
  t->Branch("eOF1_sigma",*(m_rc_sigma[OF1]),"eOF1_sigma[5][64][48][2]/F");
  t->Branch("eOF1_mean_err",*(m_rc_mean_err[OF1]),"eOF1_mean_err[5][64][48][2]/F");
  t->Branch("eOF1_sigma_err",*(m_rc_sigma_err[OF1]),"eOF1_sigma_err[5][64][48][2]/F");
  t->Branch("eOF1_kurtosis",*(m_rc_kurtosis[OF1]),"eOF1_kurtosis[5][64][48][2]/F");
  t->Branch("eOF1_skewness",*(m_rc_skewness[OF1]),"eOF1_skewness[5][64][48][2]/F");
  t->Branch("eOF1_chi2",*(m_rc_chi2[OF1]),"eOF1_chi2[5][64][48][2]/F");
  t->Branch("eOF1_ndf",*(m_rc_ndf[OF1]),"eOF1_ndf[5][64][48][2]/F");
  t->Branch("eOF1_probC2",*(m_rc_probC2[OF1]),"eOF1_probC2[5][64][48][2]/F");
 
  t->Branch("eOF1_gsigma1",*(m_rc_gsigma1[OF1]),"eOF1_gsigma1[5][64][48][2]/F");
  t->Branch("eOF1_gsigma2",*(m_rc_gsigma2[OF1]),"eOF1_gsigma2[5][64][48][2]/F");
  t->Branch("eOF1_gnorm",*(m_rc_gnorm[OF1]),"eOF1_gnorm[5][64][48][2]/F");
  t->Branch("eOF1_gchi2",*(m_rc_gchi2[OF1]),"eOF1_gchi2[5][64][48][2]/F");
  t->Branch("eOF1_gerrsigma1",*(m_rc_gerrsigma1[OF1]),"eOF1_gerrsigma1[5][64][48][2]/F");
  t->Branch("eOF1_gerrnorm",*(m_rc_gerrnorm[OF1]),"eOF1_gerrnorm[5][64][48][2]/F");
  t->Branch("eOF1_gerrsigma2",*(m_rc_gerrsigma2[OF1]),"eOF1_gerrsigma2[5][64][48][2]/F");  
  t->Branch("eOF1_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[OF1]),"eOF1_gcorrsigma1sigma2[5][64][48][2]/F");
 
 
  t->Branch("eMF_mean",*(m_rc_mean[MF]),"eMF_mean[5][64][48][2]/F");
  t->Branch("eMF_av",*(m_rc_av[MF]),"eMF_av[5][64][48][2]/F");
  t->Branch("eMF_rms",*(m_rc_rms[MF]),"eMF_rms[5][64][48][2]/F");
  t->Branch("eMF_sigma",*(m_rc_sigma[MF]),"eMF_sigma[5][64][48][2]/F");
  t->Branch("eMF_mean_err",*(m_rc_mean_err[MF]),"eMF_mean_err[5][64][48][2]/F");
  t->Branch("eMF_sigma_err",*(m_rc_sigma_err[MF]),"eMF_sigma_err[5][64][48][2]/F");
  t->Branch("eMF_kurtosis",*(m_rc_kurtosis[MF]),"eMF_kurtosis[5][64][48][2]/F");
  t->Branch("eMF_skewness",*(m_rc_skewness[MF]),"eMF_skewness[5][64][48][2]/F");
  t->Branch("eMF_chi2",*(m_rc_chi2[MF]),"eMF_chi2[5][64][48][2]/F");
  t->Branch("eMF_ndf",*(m_rc_ndf[MF]),"eMF_ndf[5][64][48][2]/F");
  t->Branch("eMF_probC2",*(m_rc_probC2[MF]),"eMF_probC2[5][64][48][2]/F");
 
  t->Branch("eMF_gsigma1",*(m_rc_gsigma1[MF]),"eMF_gsigma1[5][64][48][2]/F");
  t->Branch("eMF_gsigma2",*(m_rc_gsigma2[MF]),"eMF_gsigma2[5][64][48][2]/F");
  t->Branch("eMF_gnorm",*(m_rc_gnorm[MF]),"eMF_gnorm[5][64][48][2]/F");
  t->Branch("eMF_gchi2",*(m_rc_gchi2[MF]),"eMF_gchi2[5][64][48][2]/F");
  t->Branch("eMF_gerrsigma1",*(m_rc_gerrsigma1[MF]),"eMF_gerrsigma1[5][64][48][2]/F");
  t->Branch("eMF_gerrnorm",*(m_rc_gerrnorm[MF]),"eMF_gerrnorm[5][64][48][2]/F");
  t->Branch("eMF_gerrsigma2",*(m_rc_gerrsigma2[MF]),"eMF_gerrsigma2[5][64][48][2]/F");  
  t->Branch("eMF_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[MF]),"eMF_gcorrsigma1sigma2[5][64][48][2]/F");
 
 
  t->Branch("ecell_av",*(m_ecell_av),"ecell_av[2][64][4][17][6]/F");
  t->Branch("ecell_rms",*(m_ecell_rms),"ecell_rms[2][64][4][17][6]/F");
  t->Branch("ecell_hash",*(m_ecell_hash),"ecell_hash[2][64][4][17]/i");
  t->Branch("ecell_gsigma1",*(m_gsigma1),"ecell_gsigma1[2][64][4][17][6]/F");
  t->Branch("ecell_gsigma2",*(m_gsigma2),"ecell_gsigma2[2][64][4][17][6]/F");
  t->Branch("ecell_gnorm",*(m_gnorm),"ecell_gnorm[2][64][4][17][6]/F");
  t->Branch("ecell_gchi2",*(m_gchi2),"ecell_gchi2[2][64][4][17][6]/F");
  t->Branch("ecell_gerrsigma1",*(m_gerrsigma1),"ecell_gerrsigma1[2][64][4][17][6]/F");
  t->Branch("ecell_gerrnorm",*(m_gerrnorm),"ecell_gerrnorm[2][64][4][17][6]/F");
  t->Branch("ecell_gerrsigma2",*(m_gerrsigma2),"ecell_gerrsigma2[2][64][4][17][6]/F");  
  t->Branch("ecell_gcorrsigma1sigma2",*(m_gcorrsigma1sigma2),"ecell_gcorrsigma1sigma2[2][64][4][17][6]/F");
//  t->Branch("ecell_gcorrsigma1norm",*(gcorrsigma1norm),"ecell_gcorrsigma1norm[2][64][4][17][6]/F");
//  t->Branch("ecell_gcorrsigma2norm",*(gcorrsigma2norm),"ecell_gcorrsigma2norm[2][64][4][17][6]/F");
  t->Branch("side", *m_side, "side[2][64][4][17][6]/O");
  t->Branch("phi", *m_phi, "phi[2][64][4][17][6]/b");
  t->Branch("sample", *m_sample, "sample[2][64][4][17][6]/b");
  t->Branch("tower", *m_tower, "tower[2][64][4][17][6]/b");
  t->Branch("gaingain", *m_gg, "gaingain[2][64][4][17][6]/b");
 
  // Fill with current values (i.e. tree will have only one entry for this whole run)
 
  t->Fill();
  t->Write();
 
  if (m_saveHist) {
      
    for (int rc = 0; rc < RCnum; ++rc) {
 
      if ((m_doFit && rc == Fit)
          || (m_doFixed && rc == Fixed)
          || (m_doOpt && rc == Opt)
          || (m_doDsp && rc == Dsp)
          || (m_doOF1 && rc == OF1)
          || (m_doMF && rc == MF)) {
 
        for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
          for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
            for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
              for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
                m_histAmp[rc][ros][drawer][ch][g]->Write();
              }
            }
          }
        }
      }
    }
    
    for (int side = 0; side < NSIDES; side++) {
      for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
        for (int sample = 0; sample < NSAMPLES; ++sample) {
          for (int tower = 0; tower < NTOWERS; ++tower) {
            for (int gg = 0; gg < NCELLGAINS; ++gg) {
              m_histCellAmp[side][drawer][sample][tower][gg]->Write();
            }
          }
        }
      }
    }
  }
 
  fout->Close();
 
 
  deleteHist();
 
  return StatusCode::SUCCESS;
}

finalRawCh()

void TileRawChNoiseCalibAlg::finalRawCh

(

int

rctype

)

finalDigits is called during finalize Here the average Ped, lfn, hfn and covariance are calculated.

Definition at line 798 of file TileRawChNoiseCalibAlg.cxx.

                                                  {
  /*---------------------------------------------------------*/
 
  // Some of the ROOT histogram/fitting code is not protected against FPEs.
  // Just disable the detection of FPEs for this function.
  CxxUtils::FPControl ctl;
  ctl.disable (CxxUtils::FPControl::Exc::divbyzero |
               CxxUtils::FPControl::Exc::invalid);
 
  TF1 * fit_gaus = new TF1("g", "gaus");
 
  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
    ATH_MSG_INFO( "Fitting RCh container " << rctype << " ROS " << ros );
 
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
        for (unsigned int chan = 0; chan < TileCalibUtils::MAX_CHAN; ++chan) {
 
          if (!m_fillidx) {
            m_fillidx = true;
            m_ros[ros][drawer][chan][gain] = ros;
            m_drawer[ros][drawer][chan][gain] = drawer;
            m_channel[ros][drawer][chan][gain] = chan;
            m_gain[ros][drawer][chan][gain] = gain;
          }
 
          if (m_evt[ros][drawer][chan][gain] > 0) {
 
            TH1F& histAmp = *m_histAmp[rctype][ros][drawer][chan][gain];
            histAmp.Fit("g", "NQ");
 
            m_rc_av[rctype][ros][drawer][chan][gain] = histAmp.GetMean();
            m_rc_rms[rctype][ros][drawer][chan][gain] = histAmp.GetRMS();
 
            if (TMath::Abs(histAmp.GetSkewness()) < 1000.)
              m_rc_skewness[rctype][ros][drawer][chan][gain] = histAmp.GetSkewness();
            if (TMath::Abs(histAmp.GetKurtosis()) < 1000.)
              m_rc_kurtosis[rctype][ros][drawer][chan][gain] = histAmp.GetKurtosis();
 
            m_rc_mean[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(1);
            m_rc_mean_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(1);
            m_rc_sigma[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(2);
            m_rc_sigma_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(2);
            m_rc_chi2[rctype][ros][drawer][chan][gain] = fit_gaus->GetChisquare();
            m_rc_ndf[rctype][ros][drawer][chan][gain] = fit_gaus->GetNDF();
            m_rc_probC2[rctype][ros][drawer][chan][gain] = fit_gaus->GetProb();
 
            doFit(&histAmp, m_rc_ggpar[rctype][ros][drawer][chan][gain], m_invertChanRatio);
 
            m_rc_gsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][0];
            m_rc_gsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][2];
            m_rc_gnorm[rctype][ros][drawer][chan][gain] =   m_rc_ggpar[rctype][ros][drawer][chan][gain][1];
            m_rc_gchi2[rctype][ros][drawer][chan][gain] =   m_rc_ggpar[rctype][ros][drawer][chan][gain][3];
            m_rc_gerrsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][4];
            m_rc_gerrnorm[rctype][ros][drawer][chan][gain] =   m_rc_ggpar[rctype][ros][drawer][chan][gain][5];
            m_rc_gerrsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][6];
            m_rc_gcorrsigma1sigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][7];
 
          } // end if evt>0 
 
        }
      }
    }
  } // end if ros
 
  delete fit_gaus;
 
}

FirstEvt_initialize()

StatusCode TileRawChNoiseCalibAlg::FirstEvt_initialize ( )

private

Initialization done at the first event.

All the helpers and data dependent variables are initialized here

Definition at line 273 of file TileRawChNoiseCalibAlg.cxx.

                                                       {
 
  
  // find TileCablingService
  m_cabling = TileCablingService::getInstance();
 
  // retrieve TileID helper from det store
  CHECK( detStore()->retrieve(m_tileID) );
 
  CHECK( detStore()->retrieve(m_tileHWID) );
 
  ATH_MSG_INFO( "calibMode " << m_calibMode  );
 
 
  // set event number to 0 before first event
 
  if ( m_evtNr < 0 ) {
    m_evtNr = 0;
    if (m_beamElemContainer.length() > 0) {
      ServiceHandle<IConversionSvc> cnvSvc("ByteStreamCnvSvc","");
      if (cnvSvc.retrieve().isFailure()) {
        ATH_MSG_ERROR( " Can't get ByteStreamCnvSvc " );
        m_beamCnv = nullptr;
      
      } else {
      
        m_beamCnv = dynamic_cast<TileBeamElemContByteStreamCnv *> ( cnvSvc->converter( ClassID_traits<TileBeamElemContainer>::ID() ) );
  
        if ( m_beamCnv == nullptr ) {
          ATH_MSG_ERROR( " Can't get TileBeamElemContByteStreamCnv " );
        }
      }
    } else {
      m_beamCnv = nullptr;
    }
  }        
 
  ATH_MSG_INFO( "initialization completed" );
 
  return StatusCode::SUCCESS;
 
}

initialize()

StatusCode TileRawChNoiseCalibAlg::initialize ( )

overridevirtual

Only array initialization is done here All the helpers initialization is done at the first event.

Definition at line 198 of file TileRawChNoiseCalibAlg.cxx.

                                              {
 
  int nbin = 151;
  float binwidth[2] = { 0.125, 0.25 }; // in ADC
  float xmax[2] = { (float) nbin * binwidth[0] / 2.F, (float) nbin * binwidth[1] / 2.F }; // in ADC
 
  std::ostringstream sStr;
  std::string nam;
 
  for (int rc = 0; rc < RCnum; ++rc) {
    for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
      for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
        for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
          for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
            sStr.str("");
            sStr << "Amplitudes_RC_" << rc << "_Part_" << ros << "_Drawer_" << drawer << "_Ch_" << ch << "_Gain_" << g;
            nam = sStr.str();
            m_histAmp[rc][ros][drawer][ch][g] = new TH1F(nam.c_str(), nam.c_str(), nbin, -xmax[g], xmax[g]);
            m_histAmp[rc][ros][drawer][ch][g]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
            m_histAmp[rc][ros][drawer][ch][g]->SetDirectory(nullptr);
          }
        }
      }
    }
  }
 
  nbin = 301;
  float cellbin[2] = { 80., 2.5 }; //in MeV
  float xcellmax[2] = { (float) nbin * cellbin[0] / 2.F, (float) nbin * cellbin[1] / 2.F }; //in MeV
 
  for (int side = 0; side < NSIDES; side++) {
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      for (int sample = 0; sample < NSAMPLES; sample++) {
        for (int tower = 0; tower < NTOWERS; tower++) {
          for (int gg = 0; gg < NCELLGAINS; gg++) {
            sStr.str("");
            sStr << "CellAmplitude_Side_" << side << "_Drawer_" << drawer << "_Sample_" << sample << "_Tower_" << tower << "_Gains_" << gg;
            nam = sStr.str();
            m_histCellAmp[side][drawer][sample][tower][gg] = new TH1F(nam.c_str(), nam.c_str(), nbin, -xcellmax[gg / 3], xcellmax[gg / 3]); // cell limits should be at least sqrt(2)*channel limits
            m_histCellAmp[side][drawer][sample][tower][gg]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
            m_histCellAmp[side][drawer][sample][tower][gg]->SetDirectory(nullptr);
          }
        }
      }
    }
  }
 
 
  //=== get TileCondToolEmscale
  CHECK( m_tileToolEmscale.retrieve() );
 
  //=== get TileBadChanTool
  CHECK( m_tileBadChanTool.retrieve() );
 
  //=== get TileCondIdTransforms
  CHECK( m_tileIdTrans.retrieve() );
 
  CHECK( m_dqStatusKey.initialize() );
 
  ATH_CHECK( m_rawChannelContainerFitKey.initialize(m_doFit) );
  ATH_CHECK( m_rawChannelContainerFixedKey.initialize(m_doFixed) );
  ATH_CHECK( m_rawChannelContainerOptKey.initialize(m_doOpt) );
  ATH_CHECK( m_rawChannelContainerDspKey.initialize(m_doDsp) );
  ATH_CHECK( m_rawChannelContainerOF1Key.initialize(m_doOF1) );
  ATH_CHECK( m_rawChannelContainerMFKey.initialize(m_doMF) );
 
  if (!m_eventInfoKey.key().empty()) {
    ATH_CHECK( m_eventInfoKey.initialize() );
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::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< Algorithm > >::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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

StoreRunInfo()

void TileRawChNoiseCalibAlg::StoreRunInfo ( const TileDQstatus * dqStatus )

private

StoreRunInfo is called only during the first event.

Definition at line 631 of file TileRawChNoiseCalibAlg.cxx.

                                                                      {
  if (not dqStatus){
    m_time = 0;
    m_year = 0;
    m_month = 0;
    m_day = 0;
    m_yday = 0;
    m_hour = 0;
    m_min = 0;
    m_trigType = 0;
    ATH_MSG_WARNING("TileRawChNoiseCalibAlg::StoreRunInfo : dqStatus pointer is null");
    return;
  }
  MsgStream log(msgSvc(), name());
 
  if (dqStatus->calibMode() == 1 && m_beamElemContainer.length() > 0) {// Bigain can use cispar
 
    if (m_beamCnv) {
 
      if (m_beamCnv->validBeamFrag()) {
        m_run = m_beamCnv->robFragment()->rod_run_no();   // take it from beam ROD header
      } else {
        m_run = 0;
      }
    } else
      m_run = 0;
 
    if (m_cispar) {
      m_time = m_cispar[10]; //time in sc from 1970
      m_trigType = m_cispar[12];
    } else {
      m_time = 0;
      m_year = 0;
      m_month = 0;
      m_day = 0;
      m_yday = 0;
      m_hour = 0;
      m_min = 0;
      m_trigType = 0;
    }
  } else { // monogain can use eventinfo
 
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey); 
    if ( !eventInfo.isValid() ) {
      ATH_MSG_ERROR( "No EventInfo object found! Can't read run number!" );
      m_run = 0;
      m_time = 0;
      m_trigType = 0;
    } else {
      m_run = eventInfo->runNumber();
      m_time = eventInfo->timeStamp();
      if (!(eventInfo->eventType(xAOD::EventInfo::IS_CALIBRATION))) // if not calibration, physics
        m_trigType = 1;
      else
        m_trigType = 0;
    }
  }
 
  if (m_time != 0) {
    struct tm t;
    time_t t_time = m_time;
    localtime_r(&t_time, &t);
    m_year = t.tm_year + 1900;
    m_month = t.tm_mon + 1;
    m_day = t.tm_mday;
    m_yday = t.tm_yday + 1;
    m_hour = t.tm_hour;
    m_min = t.tm_min;
  } else {
    m_year = 0;
    m_month = 0;
    m_day = 0;
    m_yday = 0;
    m_hour = 0;
    m_min = 0;
  }
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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);
      }
    }
  }

Member Data Documentation

m_beamCnv

TileBeamElemContByteStreamCnv* TileRawChNoiseCalibAlg::m_beamCnv

private

Definition at line 115 of file TileRawChNoiseCalibAlg.h.

m_beamElemContainer

std::string TileRawChNoiseCalibAlg::m_beamElemContainer

private

Definition at line 160 of file TileRawChNoiseCalibAlg.h.

m_cabling

const TileCablingService* TileRawChNoiseCalibAlg::m_cabling

private

Definition at line 116 of file TileRawChNoiseCalibAlg.h.

m_calibMode

bool TileRawChNoiseCalibAlg::m_calibMode

private

Definition at line 94 of file TileRawChNoiseCalibAlg.h.

m_cell_nch

int(* TileRawChNoiseCalibAlg::m_cell_nch)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]

private

Definition at line 231 of file TileRawChNoiseCalibAlg.h.

m_channel

uint8_t(* TileRawChNoiseCalibAlg::m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 178 of file TileRawChNoiseCalibAlg.h.

m_cispar

const uint32_t* TileRawChNoiseCalibAlg::m_cispar

private

Definition at line 127 of file TileRawChNoiseCalibAlg.h.

m_day

int TileRawChNoiseCalibAlg::m_day

private

Definition at line 184 of file TileRawChNoiseCalibAlg.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_digitsContainer

std::string TileRawChNoiseCalibAlg::m_digitsContainer

private

Definition at line 159 of file TileRawChNoiseCalibAlg.h.

m_doDsp

bool TileRawChNoiseCalibAlg::m_doDsp

private

Definition at line 99 of file TileRawChNoiseCalibAlg.h.

m_doFit

bool TileRawChNoiseCalibAlg::m_doFit

private

Definition at line 96 of file TileRawChNoiseCalibAlg.h.

m_doFixed

bool TileRawChNoiseCalibAlg::m_doFixed

private

Definition at line 97 of file TileRawChNoiseCalibAlg.h.

m_doMF

bool TileRawChNoiseCalibAlg::m_doMF

private

Definition at line 101 of file TileRawChNoiseCalibAlg.h.

m_doOF1

bool TileRawChNoiseCalibAlg::m_doOF1

private

Definition at line 100 of file TileRawChNoiseCalibAlg.h.

m_doOpt

bool TileRawChNoiseCalibAlg::m_doOpt

private

Definition at line 98 of file TileRawChNoiseCalibAlg.h.

m_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileRawChNoiseCalibAlg::m_dqStatusKey

private

Definition at line 124 of file TileRawChNoiseCalibAlg.h.

m_drawer

uint8_t(* TileRawChNoiseCalibAlg::m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 177 of file TileRawChNoiseCalibAlg.h.

m_dspRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_dspRawChannelContainer

private

Definition at line 164 of file TileRawChNoiseCalibAlg.h.

m_ecell_av

float(* TileRawChNoiseCalibAlg::m_ecell_av)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 227 of file TileRawChNoiseCalibAlg.h.

m_ecell_ene

float(* TileRawChNoiseCalibAlg::m_ecell_ene)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]

private

Definition at line 232 of file TileRawChNoiseCalibAlg.h.

m_ecell_hash

uint32_t(* TileRawChNoiseCalibAlg::m_ecell_hash)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS]

private

Definition at line 229 of file TileRawChNoiseCalibAlg.h.

m_ecell_rms

float(* TileRawChNoiseCalibAlg::m_ecell_rms)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 228 of file TileRawChNoiseCalibAlg.h.

m_eventInfoKey

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

private

Initial value:

{this,
      "EventInfo", "EventInfo", "EventInfo key"}

Definition at line 129 of file TileRawChNoiseCalibAlg.h.

                                                 {this,
      "EventInfo", "EventInfo", "EventInfo key"};

m_evt

int(* TileRawChNoiseCalibAlg::m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 175 of file TileRawChNoiseCalibAlg.h.

m_evtNr

int TileRawChNoiseCalibAlg::m_evtNr

private

Definition at line 174 of file TileRawChNoiseCalibAlg.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_file

std::string TileRawChNoiseCalibAlg::m_file

private

Definition at line 154 of file TileRawChNoiseCalibAlg.h.

m_fillidx

bool TileRawChNoiseCalibAlg::m_fillidx

private

Definition at line 112 of file TileRawChNoiseCalibAlg.h.

m_fitRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_fitRawChannelContainer

private

Definition at line 162 of file TileRawChNoiseCalibAlg.h.

m_fixedRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_fixedRawChannelContainer

private

Definition at line 161 of file TileRawChNoiseCalibAlg.h.

m_gain

bool(* TileRawChNoiseCalibAlg::m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 179 of file TileRawChNoiseCalibAlg.h.

m_gchi2

float(* TileRawChNoiseCalibAlg::m_gchi2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 237 of file TileRawChNoiseCalibAlg.h.

m_gcorrsigma1sigma2

float(* TileRawChNoiseCalibAlg::m_gcorrsigma1sigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 241 of file TileRawChNoiseCalibAlg.h.

m_gerrnorm

float(* TileRawChNoiseCalibAlg::m_gerrnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 240 of file TileRawChNoiseCalibAlg.h.

m_gerrsigma1

float(* TileRawChNoiseCalibAlg::m_gerrsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 238 of file TileRawChNoiseCalibAlg.h.

m_gerrsigma2

float(* TileRawChNoiseCalibAlg::m_gerrsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 239 of file TileRawChNoiseCalibAlg.h.

m_gg

uint8_t(* TileRawChNoiseCalibAlg::m_gg)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 225 of file TileRawChNoiseCalibAlg.h.

m_ggpar

float(* TileRawChNoiseCalibAlg::m_ggpar)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]

private

Definition at line 233 of file TileRawChNoiseCalibAlg.h.

m_gnorm

float(* TileRawChNoiseCalibAlg::m_gnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 236 of file TileRawChNoiseCalibAlg.h.

m_gsigma1

float(* TileRawChNoiseCalibAlg::m_gsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 234 of file TileRawChNoiseCalibAlg.h.

m_gsigma2

float(* TileRawChNoiseCalibAlg::m_gsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 235 of file TileRawChNoiseCalibAlg.h.

m_histAmp

TH1F*(* TileRawChNoiseCalibAlg::m_histAmp)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 170 of file TileRawChNoiseCalibAlg.h.

m_histCellAmp

TH1F*(* TileRawChNoiseCalibAlg::m_histCellAmp)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 171 of file TileRawChNoiseCalibAlg.h.

m_hour

int TileRawChNoiseCalibAlg::m_hour

private

Definition at line 186 of file TileRawChNoiseCalibAlg.h.

m_invertChanRatio

bool TileRawChNoiseCalibAlg::m_invertChanRatio

private

Definition at line 103 of file TileRawChNoiseCalibAlg.h.

m_maskBadChannels

bool TileRawChNoiseCalibAlg::m_maskBadChannels

private

Definition at line 107 of file TileRawChNoiseCalibAlg.h.

m_MFRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_MFRawChannelContainer

private

Definition at line 166 of file TileRawChNoiseCalibAlg.h.

m_min

int TileRawChNoiseCalibAlg::m_min

private

Definition at line 187 of file TileRawChNoiseCalibAlg.h.

m_month

int TileRawChNoiseCalibAlg::m_month

private

Definition at line 183 of file TileRawChNoiseCalibAlg.h.

m_ntupleID

std::string TileRawChNoiseCalibAlg::m_ntupleID

private

Definition at line 153 of file TileRawChNoiseCalibAlg.h.

m_OF1RawChannelContainer

std::string TileRawChNoiseCalibAlg::m_OF1RawChannelContainer

private

Definition at line 165 of file TileRawChNoiseCalibAlg.h.

m_optRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_optRawChannelContainer

private

Definition at line 163 of file TileRawChNoiseCalibAlg.h.

m_phi

uint8_t(* TileRawChNoiseCalibAlg::m_phi)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 222 of file TileRawChNoiseCalibAlg.h.

m_rawChannelContainerDspKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerDspKey

private

Initial value:

{this,
         "TileRawChannelContainerDsp", "TileRawChannelCnt", 
         "Input Tile raw channel container from DSP"}

Definition at line 140 of file TileRawChNoiseCalibAlg.h.

                                                                        {this,
         "TileRawChannelContainerDsp", "TileRawChannelCnt", 
         "Input Tile raw channel container from DSP"};

m_rawChannelContainerFitKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerFitKey

private

Initial value:

{this,
         "TileRawChannelContainerFit", "TileRawChannelFit", 
         "Input Tile raw channel container reconstructed with Fit method"}

Definition at line 134 of file TileRawChNoiseCalibAlg.h.

                                                                        {this,
         "TileRawChannelContainerFit", "TileRawChannelFit", 
         "Input Tile raw channel container reconstructed with Fit method"};

m_rawChannelContainerFixedKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerFixedKey

private

Initial value:

{this,
         "TileRawChannelContainerFixed", "TileRawChannelFixed", 
         "Input Tile raw channel container reconstructed with ATLAS method"}

Definition at line 131 of file TileRawChNoiseCalibAlg.h.

                                                                          {this,
         "TileRawChannelContainerFixed", "TileRawChannelFixed", 
         "Input Tile raw channel container reconstructed with ATLAS method"};

m_rawChannelContainerMFKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerMFKey

private

Initial value:

{this,
         "TileRawChannelContainerMF", "TileRawChannelMF", 
         "Input Tile raw channel container reconstructed with MF method"}

Definition at line 146 of file TileRawChNoiseCalibAlg.h.

                                                                        {this,
         "TileRawChannelContainerMF", "TileRawChannelMF", 
         "Input Tile raw channel container reconstructed with MF method"};

m_rawChannelContainerOF1Key

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerOF1Key

private

Initial value:

{this,
         "TileRawChannelContainerOF1", "TileRawChannelOF1", 
         "Input Tile raw channel container reconstructed with OF1 method"}

Definition at line 143 of file TileRawChNoiseCalibAlg.h.

                                                                         {this,
         "TileRawChannelContainerOF1", "TileRawChannelOF1", 
         "Input Tile raw channel container reconstructed with OF1 method"};     

m_rawChannelContainerOptKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerOptKey

private

Initial value:

{this,
         "TileRawChannelContainerOpt", "TileRawChannelOpt2", 
         "Input Tile raw channel container reconstructed with Opt method"}

Definition at line 137 of file TileRawChNoiseCalibAlg.h.

                                                                        {this,
         "TileRawChannelContainerOpt", "TileRawChannelOpt2", 
         "Input Tile raw channel container reconstructed with Opt method"};

m_rc_av

float(* TileRawChNoiseCalibAlg::m_rc_av)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 195 of file TileRawChNoiseCalibAlg.h.

m_rc_chi2

float(* TileRawChNoiseCalibAlg::m_rc_chi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 201 of file TileRawChNoiseCalibAlg.h.

m_rc_gchi2

float(* TileRawChNoiseCalibAlg::m_rc_gchi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 209 of file TileRawChNoiseCalibAlg.h.

m_rc_gcorrsigma1sigma2

float(* TileRawChNoiseCalibAlg::m_rc_gcorrsigma1sigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 213 of file TileRawChNoiseCalibAlg.h.

m_rc_gerrnorm

float(* TileRawChNoiseCalibAlg::m_rc_gerrnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 212 of file TileRawChNoiseCalibAlg.h.

m_rc_gerrsigma1

float(* TileRawChNoiseCalibAlg::m_rc_gerrsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 210 of file TileRawChNoiseCalibAlg.h.

m_rc_gerrsigma2

float(* TileRawChNoiseCalibAlg::m_rc_gerrsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 211 of file TileRawChNoiseCalibAlg.h.

m_rc_ggpar

float(* TileRawChNoiseCalibAlg::m_rc_ggpar)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]

private

Definition at line 205 of file TileRawChNoiseCalibAlg.h.

m_rc_gnorm

float(* TileRawChNoiseCalibAlg::m_rc_gnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 208 of file TileRawChNoiseCalibAlg.h.

m_rc_gsigma1

float(* TileRawChNoiseCalibAlg::m_rc_gsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 206 of file TileRawChNoiseCalibAlg.h.

m_rc_gsigma2

float(* TileRawChNoiseCalibAlg::m_rc_gsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 207 of file TileRawChNoiseCalibAlg.h.

m_rc_kurtosis

float(* TileRawChNoiseCalibAlg::m_rc_kurtosis)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 198 of file TileRawChNoiseCalibAlg.h.

m_rc_mean

float(* TileRawChNoiseCalibAlg::m_rc_mean)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 193 of file TileRawChNoiseCalibAlg.h.

m_rc_mean_err

float(* TileRawChNoiseCalibAlg::m_rc_mean_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 199 of file TileRawChNoiseCalibAlg.h.

m_rc_ndf

float(* TileRawChNoiseCalibAlg::m_rc_ndf)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 202 of file TileRawChNoiseCalibAlg.h.

m_rc_probC2

float(* TileRawChNoiseCalibAlg::m_rc_probC2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 203 of file TileRawChNoiseCalibAlg.h.

m_rc_rms

float(* TileRawChNoiseCalibAlg::m_rc_rms)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 196 of file TileRawChNoiseCalibAlg.h.

m_rc_sigma

float(* TileRawChNoiseCalibAlg::m_rc_sigma)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 194 of file TileRawChNoiseCalibAlg.h.

m_rc_sigma_err

float(* TileRawChNoiseCalibAlg::m_rc_sigma_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 200 of file TileRawChNoiseCalibAlg.h.

m_rc_skewness

float(* TileRawChNoiseCalibAlg::m_rc_skewness)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 197 of file TileRawChNoiseCalibAlg.h.

m_ros

uint8_t(* TileRawChNoiseCalibAlg::m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 176 of file TileRawChNoiseCalibAlg.h.

m_run

int TileRawChNoiseCalibAlg::m_run

private

Definition at line 188 of file TileRawChNoiseCalibAlg.h.

m_sample

uint8_t(* TileRawChNoiseCalibAlg::m_sample)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 223 of file TileRawChNoiseCalibAlg.h.

m_saveHist

bool TileRawChNoiseCalibAlg::m_saveHist

private

Definition at line 102 of file TileRawChNoiseCalibAlg.h.

m_side

bool(* TileRawChNoiseCalibAlg::m_side)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 221 of file TileRawChNoiseCalibAlg.h.

m_tileBadChanTool

ToolHandle<ITileBadChanTool> TileRawChNoiseCalibAlg::m_tileBadChanTool

private

Initial value:

{this,
      "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"}

Definition at line 122 of file TileRawChNoiseCalibAlg.h.

                                                  {this,
      "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"};

m_tileHWID

const TileHWID* TileRawChNoiseCalibAlg::m_tileHWID

private

Definition at line 119 of file TileRawChNoiseCalibAlg.h.

m_tileID

const TileID* TileRawChNoiseCalibAlg::m_tileID

private

Definition at line 118 of file TileRawChNoiseCalibAlg.h.

m_tileIdTrans

ToolHandle<TileCondIdTransforms> TileRawChNoiseCalibAlg::m_tileIdTrans

private

Initial value:

{this,
      "TileCondIdTransforms", "TileCondIdTransforms", "Tile Id transforms tool"}

Definition at line 125 of file TileRawChNoiseCalibAlg.h.

                                                  {this,
      "TileCondIdTransforms", "TileCondIdTransforms", "Tile Id transforms tool"};

m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileRawChNoiseCalibAlg::m_tileToolEmscale

private

Initial value:

{this,
      "TileCondToolEmscale", "TileCondToolEmscale", "Tile em scale tool"}

Definition at line 120 of file TileRawChNoiseCalibAlg.h.

                                                     {this,
      "TileCondToolEmscale", "TileCondToolEmscale", "Tile em scale tool"};

m_time

int TileRawChNoiseCalibAlg::m_time

private

Definition at line 181 of file TileRawChNoiseCalibAlg.h.

m_tower

uint8_t(* TileRawChNoiseCalibAlg::m_tower)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]

private

Definition at line 224 of file TileRawChNoiseCalibAlg.h.

m_treeSize

int64_t TileRawChNoiseCalibAlg::m_treeSize

private

Definition at line 155 of file TileRawChNoiseCalibAlg.h.

m_trigType

int TileRawChNoiseCalibAlg::m_trigType

private

Definition at line 189 of file TileRawChNoiseCalibAlg.h.

m_UseforCells

int TileRawChNoiseCalibAlg::m_UseforCells

private

Definition at line 105 of file TileRawChNoiseCalibAlg.h.

m_usePMT

bool TileRawChNoiseCalibAlg::m_usePMT

private

Definition at line 110 of file TileRawChNoiseCalibAlg.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_yday

int TileRawChNoiseCalibAlg::m_yday

private

Definition at line 185 of file TileRawChNoiseCalibAlg.h.

m_year

int TileRawChNoiseCalibAlg::m_year

private

Definition at line 182 of file TileRawChNoiseCalibAlg.h.

NCELLGAINS

int TileRawChNoiseCalibAlg::NCELLGAINS = 6

staticconstexpr

Definition at line 53 of file TileRawChNoiseCalibAlg.h.

NPARS

int TileRawChNoiseCalibAlg::NPARS = 8

staticconstexpr

Definition at line 54 of file TileRawChNoiseCalibAlg.h.

NSAMPLES

int TileRawChNoiseCalibAlg::NSAMPLES = 4

staticconstexpr

Definition at line 51 of file TileRawChNoiseCalibAlg.h.

NSIDES

int TileRawChNoiseCalibAlg::NSIDES = 2

staticconstexpr

Definition at line 50 of file TileRawChNoiseCalibAlg.h.

NTOWERS

int TileRawChNoiseCalibAlg::NTOWERS = 17

staticconstexpr

Definition at line 52 of file TileRawChNoiseCalibAlg.h.

---

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

• TileRawChNoiseCalibAlg.h
• TileRawChNoiseCalibAlg.cxx