ATLAS Offline Software
Public Member Functions | Static Public Attributes | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
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. More...
 
virtual StatusCode execute () override
 Main method. More...
 
virtual StatusCode finalize () override
 The output ntuple is created in finalize method. More...
 
void finalRawCh (int rctype)
 finalDigits is called during finalize Here the average Ped, lfn, hfn and covariance are calculated. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
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 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 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 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

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. More...
 
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. More...
 
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 More...
 
void finalCell ()
 finalCell is called during finalize Here the cell variables of the ntuple are filled. More...
 
void deleteHist ()
 deleteHist is called at finalize to ensure that no histogram goes into any output root file delete [] didn't work properly More...
 
int digiChannel2PMT (int ros, int chan)
 
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 void doFit (TH1F *h, float *gp, bool invert=true)
 doFit performs the double gaussian fit of the amplitude More...
 

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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
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.

243 {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.

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

◆ trigtype

enum TileRawChNoiseCalibAlg::trigtype
private
Enumerator
Unknown 
Phys 
Las 
Ped 
Cis 

Definition at line 71 of file TileRawChNoiseCalibAlg.h.

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

Constructor & Destructor Documentation

◆ TileRawChNoiseCalibAlg()

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

Definition at line 50 of file TileRawChNoiseCalibAlg.cxx.

51  : AthAlgorithm(name,pSvcLocator)
52  , m_beamCnv(nullptr)
53  , m_cabling(nullptr)
54  , m_tileID(nullptr)
55  , m_tileHWID(nullptr)
56  , m_cispar(nullptr)
57  //, m_nDrawers(0)
58  , m_time(0)
59  , m_year(0)
60  , m_month(0)
61  , m_day(0)
62  , m_yday(0)
63  , m_hour(0)
64  , m_min(0)
65  , m_run(0)
66  , m_trigType(0)
67 {
68 
69  declareProperty("TileDigitsContainer", m_digitsContainer = "TileDigitsCnt");
70  declareProperty("TileBeamElemContainer", m_beamElemContainer = "TileBeamElemCnt");
71  declareProperty("doFit" , m_doFit = true);
72  declareProperty("doFixed", m_doFixed = true);
73  declareProperty("doOpt" , m_doOpt = true);
74  declareProperty("doDsp" , m_doDsp = true);
75  declareProperty("doOF1" , m_doOF1 = true);
76  declareProperty("doMF" , m_doMF = true);
77  declareProperty("SaveHist", m_saveHist = false); // write all histograms to output file
78  declareProperty("InvertChanRatio", m_invertChanRatio = true); // swap two sigmas and invert ratio if it is above 1.0 (channel fit only)
79  declareProperty("MaskBadChannels",m_maskBadChannels = true);
80  declareProperty("UseforCells" , m_UseforCells = 2); // Fit=0, Fixed=1, Opt=2, Dsp=3, OF1=4, MF=5
81  declareProperty("CalibMode", m_calibMode = true);
82  declareProperty("UsePMT", m_usePMT = false);
83  declareProperty("RunNumber", m_run=0);
84  declareProperty("FileNamePrefix", m_file="RawCh_NoiseCalib");
85  declareProperty("NtupleID", m_ntupleID="RawCh_NoiseCalib");
86  declareProperty("TreeSize", m_treeSize = 16000000000LL);
87  declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
88 
89  m_evtNr=-1;
90 
91  m_fillidx=false;
92 
93  m_histAmp = new TH1F*[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
94  m_histCellAmp = new TH1F*[2][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
95  m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
96  m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
97  m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
98  m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
99  m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
100  m_rc_mean = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
101  m_rc_sigma = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
102  m_rc_av = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
103  m_rc_rms = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
104  m_rc_skewness = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
105  m_rc_kurtosis = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
106  m_rc_mean_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
107  m_rc_sigma_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
108  m_rc_chi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
109  m_rc_ndf = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
110  m_rc_probC2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
111  m_rc_ggpar = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]();
112  m_rc_gsigma1 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
113  m_rc_gsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
114  m_rc_gnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
115  m_rc_gchi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
116  m_rc_gerrsigma1= new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
117  m_rc_gerrsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
118  m_rc_gerrnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
119  m_rc_gcorrsigma1sigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
120 
121  m_side = new bool[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
122  m_phi = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
123  m_sample = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
124  m_tower = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
125  m_gg = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
126  m_ecell_av = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
127  m_ecell_rms= new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
128  m_ecell_hash= new uint32_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS]();
129 
130  m_cell_nch = new int[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
131  m_ecell_ene = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
132  m_ggpar = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]();
133  m_gsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
134  m_gsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
135  m_gnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
136  m_gchi2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
137  m_gerrsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
138  m_gerrsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
139  m_gerrnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
140  m_gcorrsigma1sigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
141 }

◆ ~TileRawChNoiseCalibAlg()

TileRawChNoiseCalibAlg::~TileRawChNoiseCalibAlg ( )
virtual

Definition at line 143 of file TileRawChNoiseCalibAlg.cxx.

144 {
145  delete[] m_histAmp;
146  delete[] m_histCellAmp;
147  delete[] m_evt;
148  delete[] m_ros;
149  delete[] m_drawer;
150  delete[] m_channel;
151  delete[] m_gain;
152  delete[] m_rc_mean;
153  delete[] m_rc_sigma;
154  delete[] m_rc_av;
155  delete[] m_rc_rms;
156  delete[] m_rc_skewness;
157  delete[] m_rc_kurtosis;
158  delete[] m_rc_mean_err;
159  delete[] m_rc_sigma_err;
160  delete[] m_rc_chi2;
161  delete[] m_rc_ndf;
162  delete[] m_rc_probC2;
163  delete[] m_rc_ggpar;
164  delete[] m_rc_gsigma1;
165  delete[] m_rc_gsigma2;
166  delete[] m_rc_gnorm;
167  delete[] m_rc_gchi2;
168  delete[] m_rc_gerrsigma1;
169  delete[] m_rc_gerrsigma2;
170  delete[] m_rc_gerrnorm;
171  delete[] m_rc_gcorrsigma1sigma2;
172 
173  delete[] m_side;
174  delete[] m_phi;
175  delete[] m_sample;
176  delete[] m_tower;
177  delete[] m_gg;
178  delete[] m_ecell_av;
179  delete[] m_ecell_rms;
180  delete[] m_ecell_hash;
181 
182  delete[] m_cell_nch;
183  delete[] m_ecell_ene;
184  delete[] m_ggpar;
185  delete[] m_gsigma1;
186  delete[] m_gsigma2;
187  delete[] m_gnorm;
188  delete[] m_gchi2;
189  delete[] m_gerrsigma1;
190  delete[] m_gerrsigma2;
191  delete[] m_gerrnorm;
192  delete[] m_gcorrsigma1sigma2;
193 }

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ 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 1117 of file TileRawChNoiseCalibAlg.cxx.

1117  {
1118 /*---------------------------------------------------------*/
1119 
1120  for (int rc = 0; rc < RCnum; ++rc) {
1121  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
1122  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1123 
1124  for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
1125  for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
1126  delete m_histAmp[rc][ros][drawer][ch][g];
1127  }
1128  }
1129  }
1130  }
1131  }
1132 
1133  for (int side = 0; side < 2; side++) {
1134  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1135  for (int sample = 0; sample < 4; ++sample) {
1136  for (int tower = 0; tower < 17; ++tower) {
1137  for (int gg = 0; gg < 6; gg++) {
1138  delete m_histCellAmp[side][drawer][sample][tower][gg];
1139  }
1140  }
1141  }
1142  }
1143  }
1144 
1145 }

◆ 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.

95 { return m_detStore; }

◆ digiChannel2PMT()

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

Definition at line 89 of file TileRawChNoiseCalibAlg.h.

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

◆ doFit()

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

doFit performs the double gaussian fit of the amplitude

Definition at line 992 of file TileRawChNoiseCalibAlg.cxx.

992  {
993 /*---------------------------------------------------------*/
994  Double_t par[6];
995 
996  float xmin = h->GetBinCenter(1);
997  float xmax = h->GetBinCenter(h->GetNbinsX());
998  TF1* total = new TF1("total", "gaus(0)+gaus(3)", xmin, xmax);
999  total->SetLineColor(2);
1000 
1001  float nentries = h->GetEntries();
1002  float rms = h->GetRMS();
1003  float bin = h->GetBinWidth(0);
1004 
1005  par[0] = 0.1 * nentries;
1006  par[1] = 0.;
1007  par[2] = 0.7 * std::max(rms, bin);
1008 
1009  par[3] = 0.15 * par[0];
1010  par[4] = 0.;
1011  par[5] = 5. * par[2];
1012 
1013  total->SetParameters(par);
1014 
1015  float lim1 = bin / 2.;
1016  float lim2 = std::max(rms * 1.05, bin * 2.0);
1017  float lim3 = std::max(rms * 10.0, bin * 20.);
1018 
1019  float limN1 = nentries;
1020  if (lim1 < 0.5) limN1 /= (2. * lim1); // a bit more than Nentries / ( sqrt(2*pi) * sigma1 )
1021  float limN2 = nentries;
1022  if (lim2 < 0.5) limN2 /= (2. * lim2); // a bit more than Nentries / ( sqrt(2*pi) * sigma2 )
1023 
1024  total->SetParLimits(0, 0., limN1);
1025  total->FixParameter(1, 0.);
1026  total->SetParLimits(2, lim1, lim2);
1027  total->SetParLimits(3, 0., limN2);
1028  total->FixParameter(4, 0.);
1029  total->SetParLimits(5, lim2, lim3);
1030 
1031  TFitResultPtr resfit = h->Fit(total, "BLQRS");
1032 
1033  float par0 = total->GetParameter(0);
1034  float par3 = total->GetParameter(3);
1035 
1036  float sigma1 = total->GetParameter(2); //sigma gauss1
1037  float sigma2 = total->GetParameter(5); //sigma gauss1
1038 
1039  //Get errors
1040  float errpar0 = total->GetParError(0);
1041  float errpar3 = total->GetParError(3);
1042 
1043  float errsigma1 = total->GetParError(2);
1044  float errsigma2 = total->GetParError(5);
1045 
1046  float norm = par3 / par0; //rel normalization of the gaussians
1047 
1048  if (invert && norm > 1.) { //invert the 2 gaussians if normalization is greater than 1
1049 
1050  gp[0] = sigma2;
1051  gp[1] = 1. / norm;
1052  gp[2] = sigma1;
1053 
1054  gp[4] = errsigma2;
1055  gp[5] = sqrt((errpar0 * errpar0) + (errpar3 * errpar3) * (par0 * par0) / (par3 * par3)) / par3;
1056  gp[6] = errsigma1;
1057 
1058  } else {
1059 
1060  gp[0] = sigma1;
1061  gp[1] = norm;
1062  gp[2] = sigma2;
1063 
1064  gp[4] = errsigma1;
1065  gp[5] = sqrt((errpar3 * errpar3) + (errpar0 * errpar0) * (par3 * par3) / (par0 * par0)) / par0;
1066  gp[6] = errsigma2;
1067 
1068  }
1069 
1070  if (total->GetNDF() > 0) {
1071  gp[3] = total->GetChisquare() / total->GetNDF(); //chi2/ndf
1072  } else {
1073  gp[3] = 0.;
1074  }
1075 
1076  // Get correlation sigma1, sigma2
1077  TMatrixDSym corr = resfit->GetCorrelationMatrix();
1078  gp[7] = corr(2, 5);
1079 
1080  delete total;
1081 }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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 TileRawChNoiseCalibAlg::execute ( )
overridevirtual

Main method.

Definition at line 316 of file TileRawChNoiseCalibAlg.cxx.

316  {
317 
318  const EventContext& ctx = Gaudi::Hive::currentContext();
319  const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
320 
321  bool empty(false); // to add all StatusCodes
322 
323  if (m_evtNr < 0) {
324 
325  if (FirstEvt_initialize().isFailure()) { ATH_MSG_ERROR( "FirstEvt_initialize failed" ); }
326 
327  bool calibMode = (dqStatus->calibMode() == 1);
328  if ( calibMode != m_calibMode ) {
329  ATH_MSG_INFO( "Overwriting calib mode [" << m_calibMode << "] by one from data: " << calibMode );
330  m_calibMode = calibMode;
331  }
332 
333  m_cispar = dqStatus->cispar();
334  StoreRunInfo(dqStatus); // done only once
335  }
336 
337  memset(m_ecell_ene ,0, 2 * sizeof( *m_ecell_ene ));
338  memset(m_cell_nch ,0, 2 * sizeof( *m_cell_nch ));
339 
340  m_cispar = dqStatus->cispar();
341  if (m_evtNr % 1000 == 0) ATH_MSG_INFO( " events processed so far " << m_evtNr );
342 
343 
344  if (m_doFit) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerFitKey, Fit).isFailure());}
345  if (m_doFixed) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerFixedKey, Fixed).isFailure());}
346  if (m_doOpt) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerOptKey, Opt).isFailure());}
347  if (m_doDsp) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerDspKey, Dsp).isFailure());}
348  if (m_doOF1) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerOF1Key, OF1).isFailure());}
349  if (m_doMF) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerMFKey, MF).isFailure());}
350 
351 
352  if (empty) {ATH_MSG_ERROR( "Error in execute " ); }
353  ++m_evtNr;
354 
355  return StatusCode::SUCCESS;
356 }

◆ 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.

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

◆ fillCell()

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

Definition at line 863 of file TileRawChNoiseCalibAlg.cxx.

863  {
864  /*---------------------------------------------------------*/
865 
866  int index, pmt;
867  Identifier cell_id = rch->cell_ID_index(index, pmt);
868  if (index > -1) { //disconnect channel index is -1/ MBTS cell index is -2 and they don't have an idhash
869  unsigned int ros(0), drawer(0), channel(0), gain(0);
870  m_tileIdTrans->getIndices(rch->adc_HWID(), ros, drawer, channel, gain);
871  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
872 
873  if (m_maskBadChannels && m_tileBadChanTool->getAdcStatus(drawerIdx, channel, gain).isBad()) {
874  ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
875  << " channel: " << channel
876  << " ADC: " << gain
877  << " in fillCell() because channel is bad in DB." );
878  return;
879  }
880 
881  int sample = m_tileID->sample(cell_id);
882  int tower = m_tileID->tower(cell_id);
883  int side = m_tileID->side(cell_id);
884 
885  if (side == 1) side = 0; //A side
886  else if (side == -1) side = 1; //C side
887  else side = 0; //D0 cell? we put it in LBA
888 
889  if (m_evtNr < 1) { //first event
890  m_ecell_hash[side][drawer][sample][tower] = m_tileID->cell_hash(cell_id);
891  }
892 
893  int g, gg;
894  if (gain == 0) {
895  gg = 0;
896  if (pmt == 0) g = 1; //in most cases even channels on side A AND odd channels on side C
897  else g = 2; //are the first channels of the cells
898  } else {
899  gg = 3;
900  if (pmt == 0) g = 4; //pmt tells us which is the first and second channel of the cells!!
901  else g = 5;
902  }
903 
904  //not needed anymore if (channel==0 && ros==2) g++; //D0 second channel is special : move from first to second channel
905 
906  double amp = rch->amplitude();
907  amp = m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, amp, RChUnit, TileRawChannelUnit::MegaElectronVolts);
908  int nch = 1;
909 
910  if (m_cabling->isRun2PlusCabling() && (ros > 2)) { // Ext.barrel modules
911 
912  if (channel == E1_CHANNEL) { // Raw channel -> E1 cell.
913  int drawer2 = m_cabling->E1_merged_with_run2plus(ros, drawer);
914  if (drawer2 != 0) { // Raw channel splitted into two E1 cells for Run 2.
915  amp /= 2.0F;
916  m_ecell_ene[side][drawer2][sample][tower][gg / 3] += amp;
917  ++m_cell_nch[side][drawer2][sample][tower][gg / 3];
918 
919  if (TMath::Abs(amp) > 1.e-5) {
920  m_histCellAmp[side][drawer2][sample][tower][g]->Fill(amp);
921  }
922  }
923 
924  } else if (!TileCablingService::C10_connected(drawer)) { // modules with special C10
925  if (channel == OUTER_MBTS_CHANNEL) {
926  amp = 0.0; // ignore MBTS completely
927  nch = 0;
928  } else if (channel == SPECIAL_C10_CHANNEL) {
929  nch = 2; // count this channel twice - needed for correct bad-channel masking
930  }
931  }
932  }
933 
934  m_ecell_ene[side][drawer][sample][tower][gg / 3] += amp;
935  m_cell_nch[side][drawer][sample][tower][gg / 3] += nch;
936 
937  if (TMath::Abs(amp) > 1.e-5) {
938  m_histCellAmp[side][drawer][sample][tower][g]->Fill(amp);
939  }
940 
941  } // is a connected channel
942 }

◆ fillCellHist()

void TileRawChNoiseCalibAlg::fillCellHist ( )
private

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

Definition at line 1087 of file TileRawChNoiseCalibAlg.cxx.

1087  {
1088 /*---------------------------------------------------------*/
1089 
1090  for (int side = 0; side < 2; ++side) {
1091  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1092  for (int sample = 0; sample < 4; ++sample) {
1093  for (int tower = 0; tower < 17; ++tower) {
1094  for (unsigned int gg = 0; gg < TileCalibUtils::MAX_GAIN; ++gg) {
1095 
1096  float ene = m_ecell_ene[side][drawer][sample][tower][gg];
1097  if (m_cell_nch[side][drawer][sample][tower][gg] == 1 && sample != 3) ene *= 2; // one good channel in normal cell - multiply energy by 2
1098 
1099  if (TMath::Abs(ene) > 1.e-5) {
1100  m_histCellAmp[side][drawer][sample][tower][gg * 3]->Fill(ene);
1101  }
1102 
1103  }
1104  }
1105  }
1106  }
1107  }
1108 
1109 }

◆ fillRawChannels()

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

Definition at line 711 of file TileRawChNoiseCalibAlg.cxx.

713  {
714 /*---------------------------------------------------------*/
715 
716  SG::ReadHandle<TileRawChannelContainer> rawChannelContainer(rawChannelContainerKey);
717  ATH_CHECK( rawChannelContainer.isValid() );
718 
719  if ((rctype == Dsp) && (m_trigType != Phys)) {
720  ATH_MSG_ERROR( "Removing DSP RawChannelContainer for non Phys run. TrigType is: " << m_trigType );
721  return StatusCode::FAILURE;
722  }
723 
724  TileRawChannelUnit::UNIT RChUnit = rawChannelContainer->get_unit();
725 
726  TileRawChannelContainer::const_iterator collItr = rawChannelContainer->begin();
727  TileRawChannelContainer::const_iterator lastColl = rawChannelContainer->end();
728 
729  for (; collItr != lastColl; ++collItr) {
730 
731  TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
732  TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
733 
734  for (; chItr != lastCh; ++chItr) {
735 
736  const TileRawChannel* rch = (*chItr);
737 
738  HWIdentifier adc_id = (*chItr)->adc_HWID();
739  unsigned int ros(0), drawer(0), channel(0), gain(0);
740  m_tileIdTrans->getIndices(adc_id, ros, drawer, channel, gain);
741  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
742 
743  if (dqStatus->isChEmpty(ros, drawer, channel)) continue;
744 
745  // If DQ problem, do not fill calib ntuple
746  if (m_calibMode == 1) { // Bigain: check indivual adc's
747 
748  if (!(dqStatus->isAdcDQgood(ros, drawer, channel, gain))) {
749  ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
750  << " channel: " << channel
751  << " ADC: " << gain << " due to DQ error found." );
752 
753  continue;
754  }
755  } else { // monogain, just check channel
756 
757  if (!(dqStatus->isChanDQgood(ros, drawer, channel))) {
758  ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
759  << " channel: " << channel << " due to DQ error found." );
760 
761  continue;
762  }
763  }
764 
765  // we fill the cell information now for selected method
766  // note that fillCell is called only for good channels
767  if (rctype == m_UseforCells) fillCell(RChUnit, rch);
768 
769  double amp = rch->amplitude();
770  if (RChUnit > TileRawChannelUnit::OnlineADCcounts) {
771  // go from online units to ADC counts
772  amp = m_tileToolEmscale->undoOnlCalib(drawerIdx, channel, gain, amp, RChUnit);
773  } else if (RChUnit == TileRawChannelUnit::OnlineADCcounts) {
774  // nothing to do
775  } else if (RChUnit > TileRawChannelUnit::ADCcounts) {
776  // go from offline units to ADC counts
777  amp /= m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, 1.0, TileRawChannelUnit::ADCcounts, RChUnit);
778  }
779 
780  // PMT-1 or channel index depending on jobOptions
781  unsigned int chan = (m_usePMT) ? digiChannel2PMT(ros, channel) : channel;
782 
783  m_evt[ros][drawer][chan][gain]++;
784  m_histAmp[rctype][ros][drawer][chan][gain]->Fill(amp);
785  }
786  }
787 
788  if (rctype == m_UseforCells) fillCellHist(); //we fill the cell histograms only at the end of the loop over the channels,
789  //when all the cells have been built
790 
791  return StatusCode::SUCCESS;
792 }

◆ finalCell()

void TileRawChNoiseCalibAlg::finalCell ( )
private

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

Definition at line 948 of file TileRawChNoiseCalibAlg.cxx.

948  {
949  /*---------------------------------------------------------*/
950 
951  for (int side = 0; side < 2; ++side) {
952  ATH_MSG_INFO( "Fitting cells side " << side );
953  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
954  for (int sample = 0; sample < 4; ++sample) {
955  for (int tower = 0; tower < 17; ++tower) {
956  for (int gg = 0; gg < 6; ++gg) {
957 
958  m_side[side][drawer][sample][tower][gg] = side;
959  m_phi[side][drawer][sample][tower][gg] = drawer;
960  m_sample[side][drawer][sample][tower][gg] = sample;
961  m_tower[side][drawer][sample][tower][gg] = tower;
962  m_gg[side][drawer][sample][tower][gg] = gg;
963 
964  if (m_histCellAmp[side][drawer][sample][tower][gg]->GetEntries() > 0) {
965 
966  m_ecell_av[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetMean();
967  m_ecell_rms[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetRMS();
968  doFit(m_histCellAmp[side][drawer][sample][tower][gg], m_ggpar[side][drawer][sample][tower][gg]);
969  m_gsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][0];
970  m_gsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][2];
971  m_gnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][1];
972  m_gchi2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][3];
973  m_gerrsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][4];
974  m_gerrnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][5];
975  m_gerrsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][6];
976  m_gcorrsigma1sigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][7];
977 // gcorrsigma1norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][8];
978 // gcorrsigma2norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][9];
979 
980  }
981 
982  }
983  }
984  }
985  }
986  }
987 
988 }

◆ finalize()

StatusCode TileRawChNoiseCalibAlg::finalize ( )
overridevirtual

The output ntuple is created in finalize method.

Definition at line 360 of file TileRawChNoiseCalibAlg.cxx.

360  {
361 
362  ATH_MSG_INFO( "Finalizing TileRawChNoiseCalibAlg" );
363 
364  if (m_doFit) finalRawCh(Fit);
365  if (m_doFixed) finalRawCh(Fixed);
366  if (m_doOpt) finalRawCh(Opt);
367  if (m_doDsp) finalRawCh(Dsp);
368  if (m_doOF1) finalRawCh(OF1);
369  if (m_doMF) finalRawCh(MF);
370 
371  if (m_UseforCells == 0) {
372  if (m_doFit) finalCell();
373  } else if (m_UseforCells == 1) {
374  if (m_doFixed) finalCell();
375  } else if (m_UseforCells == 2) {
376  if (m_doOpt) finalCell();
377  } else if (m_UseforCells == 3) {
378  if (m_doDsp) finalCell();
379  } else if (m_UseforCells == 4) {
380  if (m_doOF1) finalCell();
381  } else if (m_UseforCells == 5) {
382  if (m_doMF) finalCell();
383  } else {
384  ATH_MSG_WARNING( "unknown rawchannel type used for cells" << m_UseforCells );
385  }
386 
387  std::ostringstream sStr;
388  std::string trig_str;
389 
390  if (m_trigType == Phys) trig_str = "Phys";
391  else if (m_trigType == Las) trig_str = "Las";
392  else if (m_trigType == Ped) trig_str = "Ped";
393  else if (m_trigType == Cis) trig_str = "Cis";
394  else {
395  ATH_MSG_WARNING( "Unknown trigger type " << m_trigType );
396  trig_str = "Unk";
397  }
398 
399  sStr << m_file << "_" << m_run << "_" << trig_str << ".root";
400  m_file = sStr.str();
401  ATH_MSG_INFO( "Writing calibrations to file " << m_file );
402 
403  // Create output file: for now creating file for just this
404  // algorithm; want to add to ntuple file eventually??
405  TFile* fout = new TFile(m_file.c_str(), "recreate");
406 
407  // Create tree with branches
408  TTree* t = new TTree(m_ntupleID.c_str(), "Tile_RC_NoiseCalib-Ntuple");
409 
410  t->Branch("RunNumber", &m_run, "RunNumber/I");
411  t->Branch("TrigType", &m_trigType, "TrigType/I");
412  t->Branch("Time", &m_time, "Time/I");
413  t->Branch("Year", &m_year, "Year/I");
414  t->Branch("Month", &m_month, "Month/I");
415  t->Branch("Day", &m_day, "Day/I");
416  t->Branch("YDay", &m_yday, "YDay/I");
417  t->Branch("Hour", &m_hour, "Hour/I");
418  t->Branch("Min", &m_min, "Min/I");
419  t->Branch("nEvt", &m_evtNr, "nEvt/I"); // events processed
420  t->Branch("EvtNr", &m_evtNr, "EvtNr/I");
421  t->Branch("EvtGood", *m_evt, "Evt[5][64][48][2]/I"); // events used in the noise calculation for every channel
422 
423 
424  t->Branch("ros", *m_ros, "ros[5][64][48][2]/b");
425  t->Branch("drawer", *m_drawer, "drawer[5][64][48][2]/b");
426  t->Branch("channel", *m_channel, "channel[5][64][48][2]/b");
427  t->Branch("gain", *m_gain, "gain[5][64][48][2]/O");
428 
429  t->Branch("efit_mean",*(m_rc_mean[Fit]),"efit_mean[5][64][48][2]/F");
430  t->Branch("efit_av",*(m_rc_av[Fit]),"efit_av[5][64][48][2]/F");
431  t->Branch("efit_rms",*(m_rc_rms[Fit]),"efit_rms[5][64][48][2]/F");
432  t->Branch("efit_sigma",*(m_rc_sigma[Fit]),"efit_sigma[5][64][48][2]/F");
433  t->Branch("efit_mean_err",*(m_rc_mean_err[Fit]),"efit_mean_err[5][64][48][2]/F");
434  t->Branch("efit_sigma_err",*(m_rc_sigma_err[Fit]),"efit_sigma_err[5][64][48][2]/F");
435  t->Branch("efit_kurtosis",*(m_rc_kurtosis[Fit]),"efit_kurtosis[5][64][48][2]/F");
436  t->Branch("efit_skewness",*(m_rc_skewness[Fit]),"efit_skewness[5][64][48][2]/F");
437  t->Branch("efit_chi2",*(m_rc_chi2[Fit]),"efit_chi2[5][64][48][2]/F");
438  t->Branch("efit_ndf",*(m_rc_ndf[Fit]),"efit_ndf[5][64][48][2]/F");
439  t->Branch("efit_probC2",*(m_rc_probC2[Fit]),"efit_probC2[5][64][48][2]/F");
440 
441  t->Branch("efit_gsigma1",*(m_rc_gsigma1[Fit]),"efit_gsigma1[5][64][48][2]/F");
442  t->Branch("efit_gsigma2",*(m_rc_gsigma2[Fit]),"efit_gsigma2[5][64][48][2]/F");
443  t->Branch("efit_gnorm",*(m_rc_gnorm[Fit]),"efit_gnorm[5][64][48][2]/F");
444  t->Branch("efit_gchi2",*(m_rc_gchi2[Fit]),"efit_gchi2[5][64][48][2]/F");
445  t->Branch("efit_gerrsigma1",*(m_rc_gerrsigma1[Fit]),"efit_gerrsigma1[5][64][48][2]/F");
446  t->Branch("efit_gerrnorm",*(m_rc_gerrnorm[Fit]),"efit_gerrnorm[5][64][48][2]/F");
447  t->Branch("efit_gerrsigma2",*(m_rc_gerrsigma2[Fit]),"efit_gerrsigma2[5][64][48][2]/F");
448  t->Branch("efit_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Fit]),"efit_gcorrsigma1sigma2[5][64][48][2]/F");
449 
450 
451  t->Branch("efixed_mean",*(m_rc_mean[Fixed]),"efixed_mean[5][64][48][2]/F");
452  t->Branch("efixed_av",*(m_rc_av[Fixed]),"efixed_av[5][64][48][2]/F");
453  t->Branch("efixed_rms",*(m_rc_rms[Fixed]),"efixed_rms[5][64][48][2]/F");
454  t->Branch("efixed_sigma",*(m_rc_sigma[Fixed]),"efixed_sigma[5][64][48][2]/F");
455  t->Branch("efixed_mean_err",*(m_rc_mean_err[Fixed]),"efixed_mean_err[5][64][48][2]/F");
456  t->Branch("efixed_sigma_err",*(m_rc_sigma_err[Fixed]),"efixed_sigma_err[5][64][48][2]/F");
457  t->Branch("efixed_kurtosis",*(m_rc_kurtosis[Fixed]),"efixed_kurtosis[5][64][48][2]/F");
458  t->Branch("efixed_skewness",*(m_rc_skewness[Fixed]),"efixed_skewness[5][64][48][2]/F");
459  t->Branch("efixed_chi2",*(m_rc_chi2[Fixed]),"efixed_chi2[5][64][48][2]/F");
460  t->Branch("efixed_ndf",*(m_rc_ndf[Fixed]),"efixed_ndf[5][64][48][2]/F");
461  t->Branch("efixed_probC2",*(m_rc_probC2[Fixed]),"efixed_probC2[5][64][48][2]/F");
462 
463  t->Branch("efixed_gsigma1",*(m_rc_gsigma1[Fixed]),"efixed_gsigma1[5][64][48][2]/F");
464  t->Branch("efixed_gsigma2",*(m_rc_gsigma2[Fixed]),"efixed_gsigma2[5][64][48][2]/F");
465  t->Branch("efixed_gnorm",*(m_rc_gnorm[Fixed]),"efixed_gnorm[5][64][48][2]/F");
466  t->Branch("efixed_gchi2",*(m_rc_gchi2[Fixed]),"efixed_gchi2[5][64][48][2]/F");
467  t->Branch("efixed_gerrsigma1",*(m_rc_gerrsigma1[Fixed]),"efixed_gerrsigma1[5][64][48][2]/F");
468  t->Branch("efixed_gerrnorm",*(m_rc_gerrnorm[Fixed]),"efixed_gerrnorm[5][64][48][2]/F");
469  t->Branch("efixed_gerrsigma2",*(m_rc_gerrsigma2[Fixed]),"efixed_gerrsigma2[5][64][48][2]/F");
470  t->Branch("efixed_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Fixed]),"efixed_gcorrsigma1sigma2[5][64][48][2]/F");
471 
472 
473  t->Branch("eopt_mean",*(m_rc_mean[Opt]),"eopt_mean[5][64][48][2]/F");
474  t->Branch("eopt_av",*(m_rc_av[Opt]),"eopt_av[5][64][48][2]/F");
475  t->Branch("eopt_rms",*(m_rc_rms[Opt]),"eopt_rms[5][64][48][2]/F");
476  t->Branch("eopt_sigma",*(m_rc_sigma[Opt]),"eopt_sigma[5][64][48][2]/F");
477  t->Branch("eopt_mean_err",*(m_rc_mean_err[Opt]),"eopt_mean_err[5][64][48][2]/F");
478  t->Branch("eopt_sigma_err",*(m_rc_sigma_err[Opt]),"eopt_sigma_err[5][64][48][2]/F");
479  t->Branch("eopt_kurtosis",*(m_rc_kurtosis[Opt]),"eopt_kurtosis[5][64][48][2]/F");
480  t->Branch("eopt_skewness",*(m_rc_skewness[Opt]),"eopt_skewness[5][64][48][2]/F");
481  t->Branch("eopt_chi2",*(m_rc_chi2[Opt]),"eopt_chi2[5][64][48][2]/F");
482  t->Branch("eopt_ndf",*(m_rc_ndf[Opt]),"eopt_ndf[5][64][48][2]/F");
483  t->Branch("eopt_probC2",*(m_rc_probC2[Opt]),"eopt_probC2[5][64][48][2]/F");
484 
485  t->Branch("eopt_gsigma1",*(m_rc_gsigma1[Opt]),"eopt_gsigma1[5][64][48][2]/F");
486  t->Branch("eopt_gsigma2",*(m_rc_gsigma2[Opt]),"eopt_gsigma2[5][64][48][2]/F");
487  t->Branch("eopt_gnorm",*(m_rc_gnorm[Opt]),"eopt_gnorm[5][64][48][2]/F");
488  t->Branch("eopt_gchi2",*(m_rc_gchi2[Opt]),"eopt_gchi2[5][64][48][2]/F");
489  t->Branch("eopt_gerrsigma1",*(m_rc_gerrsigma1[Opt]),"eopt_gerrsigma1[5][64][48][2]/F");
490  t->Branch("eopt_gerrnorm",*(m_rc_gerrnorm[Opt]),"eopt_gerrnorm[5][64][48][2]/F");
491  t->Branch("eopt_gerrsigma2",*(m_rc_gerrsigma2[Opt]),"eopt_gerrsigma2[5][64][48][2]/F");
492  t->Branch("eopt_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Opt]),"eopt_gcorrsigma1sigma2[5][64][48][2]/F");
493 
494 
495  t->Branch("edsp_mean",*(m_rc_mean[Dsp]),"edsp_mean[5][64][48][2]/F");
496  t->Branch("edsp_av",*(m_rc_av[Dsp]),"edsp_av[5][64][48][2]/F");
497  t->Branch("edsp_rms",*(m_rc_rms[Dsp]),"edsp_rms[5][64][48][2]/F");
498  t->Branch("edsp_sigma",*(m_rc_sigma[Dsp]),"edsp_sigma[5][64][48][2]/F");
499  t->Branch("edsp_mean_err",*(m_rc_mean_err[Dsp]),"edsp_mean_err[5][64][48][2]/F");
500  t->Branch("edsp_sigma_err",*(m_rc_sigma_err[Dsp]),"edsp_sigma_err[5][64][48][2]/F");
501  t->Branch("edsp_kurtosis",*(m_rc_kurtosis[Dsp]),"edsp_kurtosis[5][64][48][2]/F");
502  t->Branch("edsp_skewness",*(m_rc_skewness[Dsp]),"edsp_skewness[5][64][48][2]/F");
503  t->Branch("edsp_chi2",*(m_rc_chi2[Dsp]),"edsp_chi2[5][64][48][2]/F");
504  t->Branch("edsp_ndf",*(m_rc_ndf[Dsp]),"edsp_ndf[5][64][48][2]/F");
505  t->Branch("edsp_probC2",*(m_rc_probC2[Dsp]),"edsp_probC2[5][64][48][2]/F");
506 
507  t->Branch("edsp_gsigma1",*(m_rc_gsigma1[Dsp]),"edsp_gsigma1[5][64][48][2]/F");
508  t->Branch("edsp_gsigma2",*(m_rc_gsigma2[Dsp]),"edsp_gsigma2[5][64][48][2]/F");
509  t->Branch("edsp_gnorm",*(m_rc_gnorm[Dsp]),"edsp_gnorm[5][64][48][2]/F");
510  t->Branch("edsp_gchi2",*(m_rc_gchi2[Dsp]),"edsp_gchi2[5][64][48][2]/F");
511  t->Branch("edsp_gerrsigma1",*(m_rc_gerrsigma1[Dsp]),"edsp_gerrsigma1[5][64][48][2]/F");
512  t->Branch("edsp_gerrnorm",*(m_rc_gerrnorm[Dsp]),"edsp_gerrnorm[5][64][48][2]/F");
513  t->Branch("edsp_gerrsigma2",*(m_rc_gerrsigma2[Dsp]),"edsp_gerrsigma2[5][64][48][2]/F");
514  t->Branch("edsp_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Dsp]),"edsp_gcorrsigma1sigma2[5][64][48][2]/F");
515 
516 
517  t->Branch("eOF1_mean",*(m_rc_mean[OF1]),"eOF1_mean[5][64][48][2]/F");
518  t->Branch("eOF1_av",*(m_rc_av[OF1]),"eOF1_av[5][64][48][2]/F");
519  t->Branch("eOF1_rms",*(m_rc_rms[OF1]),"eOF1_rms[5][64][48][2]/F");
520  t->Branch("eOF1_sigma",*(m_rc_sigma[OF1]),"eOF1_sigma[5][64][48][2]/F");
521  t->Branch("eOF1_mean_err",*(m_rc_mean_err[OF1]),"eOF1_mean_err[5][64][48][2]/F");
522  t->Branch("eOF1_sigma_err",*(m_rc_sigma_err[OF1]),"eOF1_sigma_err[5][64][48][2]/F");
523  t->Branch("eOF1_kurtosis",*(m_rc_kurtosis[OF1]),"eOF1_kurtosis[5][64][48][2]/F");
524  t->Branch("eOF1_skewness",*(m_rc_skewness[OF1]),"eOF1_skewness[5][64][48][2]/F");
525  t->Branch("eOF1_chi2",*(m_rc_chi2[OF1]),"eOF1_chi2[5][64][48][2]/F");
526  t->Branch("eOF1_ndf",*(m_rc_ndf[OF1]),"eOF1_ndf[5][64][48][2]/F");
527  t->Branch("eOF1_probC2",*(m_rc_probC2[OF1]),"eOF1_probC2[5][64][48][2]/F");
528 
529  t->Branch("eOF1_gsigma1",*(m_rc_gsigma1[OF1]),"eOF1_gsigma1[5][64][48][2]/F");
530  t->Branch("eOF1_gsigma2",*(m_rc_gsigma2[OF1]),"eOF1_gsigma2[5][64][48][2]/F");
531  t->Branch("eOF1_gnorm",*(m_rc_gnorm[OF1]),"eOF1_gnorm[5][64][48][2]/F");
532  t->Branch("eOF1_gchi2",*(m_rc_gchi2[OF1]),"eOF1_gchi2[5][64][48][2]/F");
533  t->Branch("eOF1_gerrsigma1",*(m_rc_gerrsigma1[OF1]),"eOF1_gerrsigma1[5][64][48][2]/F");
534  t->Branch("eOF1_gerrnorm",*(m_rc_gerrnorm[OF1]),"eOF1_gerrnorm[5][64][48][2]/F");
535  t->Branch("eOF1_gerrsigma2",*(m_rc_gerrsigma2[OF1]),"eOF1_gerrsigma2[5][64][48][2]/F");
536  t->Branch("eOF1_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[OF1]),"eOF1_gcorrsigma1sigma2[5][64][48][2]/F");
537 
538 
539  t->Branch("eMF_mean",*(m_rc_mean[MF]),"eMF_mean[5][64][48][2]/F");
540  t->Branch("eMF_av",*(m_rc_av[MF]),"eMF_av[5][64][48][2]/F");
541  t->Branch("eMF_rms",*(m_rc_rms[MF]),"eMF_rms[5][64][48][2]/F");
542  t->Branch("eMF_sigma",*(m_rc_sigma[MF]),"eMF_sigma[5][64][48][2]/F");
543  t->Branch("eMF_mean_err",*(m_rc_mean_err[MF]),"eMF_mean_err[5][64][48][2]/F");
544  t->Branch("eMF_sigma_err",*(m_rc_sigma_err[MF]),"eMF_sigma_err[5][64][48][2]/F");
545  t->Branch("eMF_kurtosis",*(m_rc_kurtosis[MF]),"eMF_kurtosis[5][64][48][2]/F");
546  t->Branch("eMF_skewness",*(m_rc_skewness[MF]),"eMF_skewness[5][64][48][2]/F");
547  t->Branch("eMF_chi2",*(m_rc_chi2[MF]),"eMF_chi2[5][64][48][2]/F");
548  t->Branch("eMF_ndf",*(m_rc_ndf[MF]),"eMF_ndf[5][64][48][2]/F");
549  t->Branch("eMF_probC2",*(m_rc_probC2[MF]),"eMF_probC2[5][64][48][2]/F");
550 
551  t->Branch("eMF_gsigma1",*(m_rc_gsigma1[MF]),"eMF_gsigma1[5][64][48][2]/F");
552  t->Branch("eMF_gsigma2",*(m_rc_gsigma2[MF]),"eMF_gsigma2[5][64][48][2]/F");
553  t->Branch("eMF_gnorm",*(m_rc_gnorm[MF]),"eMF_gnorm[5][64][48][2]/F");
554  t->Branch("eMF_gchi2",*(m_rc_gchi2[MF]),"eMF_gchi2[5][64][48][2]/F");
555  t->Branch("eMF_gerrsigma1",*(m_rc_gerrsigma1[MF]),"eMF_gerrsigma1[5][64][48][2]/F");
556  t->Branch("eMF_gerrnorm",*(m_rc_gerrnorm[MF]),"eMF_gerrnorm[5][64][48][2]/F");
557  t->Branch("eMF_gerrsigma2",*(m_rc_gerrsigma2[MF]),"eMF_gerrsigma2[5][64][48][2]/F");
558  t->Branch("eMF_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[MF]),"eMF_gcorrsigma1sigma2[5][64][48][2]/F");
559 
560 
561  t->Branch("ecell_av",*(m_ecell_av),"ecell_av[2][64][4][17][6]/F");
562  t->Branch("ecell_rms",*(m_ecell_rms),"ecell_rms[2][64][4][17][6]/F");
563  t->Branch("ecell_hash",*(m_ecell_hash),"ecell_hash[2][64][4][17]/i");
564  t->Branch("ecell_gsigma1",*(m_gsigma1),"ecell_gsigma1[2][64][4][17][6]/F");
565  t->Branch("ecell_gsigma2",*(m_gsigma2),"ecell_gsigma2[2][64][4][17][6]/F");
566  t->Branch("ecell_gnorm",*(m_gnorm),"ecell_gnorm[2][64][4][17][6]/F");
567  t->Branch("ecell_gchi2",*(m_gchi2),"ecell_gchi2[2][64][4][17][6]/F");
568  t->Branch("ecell_gerrsigma1",*(m_gerrsigma1),"ecell_gerrsigma1[2][64][4][17][6]/F");
569  t->Branch("ecell_gerrnorm",*(m_gerrnorm),"ecell_gerrnorm[2][64][4][17][6]/F");
570  t->Branch("ecell_gerrsigma2",*(m_gerrsigma2),"ecell_gerrsigma2[2][64][4][17][6]/F");
571  t->Branch("ecell_gcorrsigma1sigma2",*(m_gcorrsigma1sigma2),"ecell_gcorrsigma1sigma2[2][64][4][17][6]/F");
572 // t->Branch("ecell_gcorrsigma1norm",*(gcorrsigma1norm),"ecell_gcorrsigma1norm[2][64][4][17][6]/F");
573 // t->Branch("ecell_gcorrsigma2norm",*(gcorrsigma2norm),"ecell_gcorrsigma2norm[2][64][4][17][6]/F");
574  t->Branch("side", *m_side, "side[2][64][4][17][6]/O");
575  t->Branch("phi", *m_phi, "phi[2][64][4][17][6]/b");
576  t->Branch("sample", *m_sample, "sample[2][64][4][17][6]/b");
577  t->Branch("tower", *m_tower, "tower[2][64][4][17][6]/b");
578  t->Branch("gaingain", *m_gg, "gaingain[2][64][4][17][6]/b");
579 
580  // Fill with current values (i.e. tree will have only one entry for this whole run)
581 
582  t->Fill();
583  t->Write();
584 
585  if (m_saveHist) {
586 
587  for (int rc = 0; rc < RCnum; ++rc) {
588 
589  if ((m_doFit && rc == Fit)
590  || (m_doFixed && rc == Fixed)
591  || (m_doOpt && rc == Opt)
592  || (m_doDsp && rc == Dsp)
593  || (m_doOF1 && rc == OF1)
594  || (m_doMF && rc == MF)) {
595 
596  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
597  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
598  for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
599  for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
600  m_histAmp[rc][ros][drawer][ch][g]->Write();
601  }
602  }
603  }
604  }
605  }
606  }
607 
608  for (int side = 0; side < NSIDES; side++) {
609  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
610  for (int sample = 0; sample < NSAMPLES; ++sample) {
611  for (int tower = 0; tower < NTOWERS; ++tower) {
612  for (int gg = 0; gg < NCELLGAINS; ++gg) {
613  m_histCellAmp[side][drawer][sample][tower][gg]->Write();
614  }
615  }
616  }
617  }
618  }
619  }
620 
621  fout->Close();
622 
623 
624  deleteHist();
625 
626  return StatusCode::SUCCESS;
627 }

◆ finalRawCh()

void TileRawChNoiseCalibAlg::finalRawCh ( int  rctype)

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

Definition at line 797 of file TileRawChNoiseCalibAlg.cxx.

797  {
798  /*---------------------------------------------------------*/
799 
800  TF1 * fit_gaus = new TF1("g", "gaus");
801 
802  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
803  ATH_MSG_INFO( "Fitting RCh container " << rctype << " ROS " << ros );
804 
805  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
806  for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
807  for (unsigned int chan = 0; chan < TileCalibUtils::MAX_CHAN; ++chan) {
808 
809  if (!m_fillidx) {
810  m_fillidx = true;
811  m_ros[ros][drawer][chan][gain] = ros;
812  m_drawer[ros][drawer][chan][gain] = drawer;
813  m_channel[ros][drawer][chan][gain] = chan;
814  m_gain[ros][drawer][chan][gain] = gain;
815  }
816 
817  if (m_evt[ros][drawer][chan][gain] > 0) {
818 
819  m_histAmp[rctype][ros][drawer][chan][gain]->Fit("g", "NQ");
820 
821  m_rc_av[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetMean();
822  m_rc_rms[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetRMS();
823 
824  if (TMath::Abs(m_histAmp[rctype][ros][drawer][chan][gain]->GetSkewness()) < 1000.)
825  m_rc_skewness[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetSkewness();
826  if (TMath::Abs(m_histAmp[rctype][ros][drawer][chan][gain]->GetKurtosis()) < 1000.)
827  m_rc_kurtosis[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetKurtosis();
828 
829  m_rc_mean[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(1);
830  m_rc_mean_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(1);
831  m_rc_sigma[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(2);
832  m_rc_sigma_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(2);
833  m_rc_chi2[rctype][ros][drawer][chan][gain] = fit_gaus->GetChisquare();
834  m_rc_ndf[rctype][ros][drawer][chan][gain] = fit_gaus->GetNDF();
835  m_rc_probC2[rctype][ros][drawer][chan][gain] = fit_gaus->GetProb();
836 
837  doFit(m_histAmp[rctype][ros][drawer][chan][gain], m_rc_ggpar[rctype][ros][drawer][chan][gain], m_invertChanRatio);
838 
839  m_rc_gsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][0];
840  m_rc_gsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][2];
841  m_rc_gnorm[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][1];
842  m_rc_gchi2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][3];
843  m_rc_gerrsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][4];
844  m_rc_gerrnorm[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][5];
845  m_rc_gerrsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][6];
846  m_rc_gcorrsigma1sigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][7];
847 
848  } // end if evt>0
849 
850  }
851  }
852  }
853  } // end if ros
854 
855  delete fit_gaus;
856 
857 }

◆ 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 272 of file TileRawChNoiseCalibAlg.cxx.

272  {
273 
274 
275  // find TileCablingService
276  m_cabling = TileCablingService::getInstance();
277 
278  // retrieve TileID helper from det store
279  CHECK( detStore()->retrieve(m_tileID) );
280 
281  CHECK( detStore()->retrieve(m_tileHWID) );
282 
283  ATH_MSG_INFO( "calibMode " << m_calibMode );
284 
285 
286  // set event number to 0 before first event
287 
288  if ( m_evtNr < 0 ) {
289  m_evtNr = 0;
290  if (m_beamElemContainer.length() > 0) {
291  ServiceHandle<IConversionSvc> cnvSvc("ByteStreamCnvSvc","");
292  if (cnvSvc.retrieve().isFailure()) {
293  ATH_MSG_ERROR( " Can't get ByteStreamCnvSvc " );
294  m_beamCnv = nullptr;
295 
296  } else {
297 
298  m_beamCnv = dynamic_cast<TileBeamElemContByteStreamCnv *> ( cnvSvc->converter( ClassID_traits<TileBeamElemContainer>::ID() ) );
299 
300  if ( m_beamCnv == nullptr ) {
301  ATH_MSG_ERROR( " Can't get TileBeamElemContByteStreamCnv " );
302  }
303  }
304  } else {
305  m_beamCnv = nullptr;
306  }
307  }
308 
309  ATH_MSG_INFO( "initialization completed" );
310 
311  return StatusCode::SUCCESS;
312 
313 }

◆ initialize()

StatusCode TileRawChNoiseCalibAlg::initialize ( )
overridevirtual

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

Definition at line 197 of file TileRawChNoiseCalibAlg.cxx.

197  {
198 
199  int nbin = 151;
200  float binwidth[2] = { 0.125, 0.25 }; // in ADC
201  float xmax[2] = { (float) nbin * binwidth[0] / 2.F, (float) nbin * binwidth[1] / 2.F }; // in ADC
202 
203  std::ostringstream sStr;
204  std::string nam;
205 
206  for (int rc = 0; rc < RCnum; ++rc) {
207  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
208  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
209  for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
210  for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
211  sStr.str("");
212  sStr << "Amplitudes_RC_" << rc << "_Part_" << ros << "_Drawer_" << drawer << "_Ch_" << ch << "_Gain_" << g;
213  nam = sStr.str();
214  m_histAmp[rc][ros][drawer][ch][g] = new TH1F(nam.c_str(), nam.c_str(), nbin, -xmax[g], xmax[g]);
215  m_histAmp[rc][ros][drawer][ch][g]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
216  m_histAmp[rc][ros][drawer][ch][g]->SetDirectory(nullptr);
217  }
218  }
219  }
220  }
221  }
222 
223  nbin = 301;
224  float cellbin[2] = { 80., 2.5 }; //in MeV
225  float xcellmax[2] = { (float) nbin * cellbin[0] / 2.F, (float) nbin * cellbin[1] / 2.F }; //in MeV
226 
227  for (int side = 0; side < NSIDES; side++) {
228  for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
229  for (int sample = 0; sample < NSAMPLES; sample++) {
230  for (int tower = 0; tower < NTOWERS; tower++) {
231  for (int gg = 0; gg < NCELLGAINS; gg++) {
232  sStr.str("");
233  sStr << "CellAmplitude_Side_" << side << "_Drawer_" << drawer << "_Sample_" << sample << "_Tower_" << tower << "_Gains_" << gg;
234  nam = sStr.str();
235  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
236  m_histCellAmp[side][drawer][sample][tower][gg]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
237  m_histCellAmp[side][drawer][sample][tower][gg]->SetDirectory(nullptr);
238  }
239  }
240  }
241  }
242  }
243 
244 
245  //=== get TileCondToolEmscale
246  CHECK( m_tileToolEmscale.retrieve() );
247 
248  //=== get TileBadChanTool
249  CHECK( m_tileBadChanTool.retrieve() );
250 
251  //=== get TileCondIdTransforms
252  CHECK( m_tileIdTrans.retrieve() );
253 
254  CHECK( m_dqStatusKey.initialize() );
255 
256  ATH_CHECK( m_rawChannelContainerFitKey.initialize(m_doFit) );
257  ATH_CHECK( m_rawChannelContainerFixedKey.initialize(m_doFixed) );
258  ATH_CHECK( m_rawChannelContainerOptKey.initialize(m_doOpt) );
259  ATH_CHECK( m_rawChannelContainerDspKey.initialize(m_doDsp) );
260  ATH_CHECK( m_rawChannelContainerOF1Key.initialize(m_doOF1) );
261  ATH_CHECK( m_rawChannelContainerMFKey.initialize(m_doMF) );
262 
263  if (!m_eventInfoKey.key().empty()) {
264  ATH_CHECK( m_eventInfoKey.initialize() );
265  }
266 
267  return StatusCode::SUCCESS;
268 }

◆ 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() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ 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.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ 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.

364  {
365  handlesArray.renounce();
366  }

◆ StoreRunInfo()

void TileRawChNoiseCalibAlg::StoreRunInfo ( const TileDQstatus *  dqStatus)
private

StoreRunInfo is called only during the first event.

Definition at line 630 of file TileRawChNoiseCalibAlg.cxx.

630  {
631  if (not dqStatus){
632  m_time = 0;
633  m_year = 0;
634  m_month = 0;
635  m_day = 0;
636  m_yday = 0;
637  m_hour = 0;
638  m_min = 0;
639  m_trigType = 0;
640  ATH_MSG_WARNING("TileRawChNoiseCalibAlg::StoreRunInfo : dqStatus pointer is null");
641  return;
642  }
643  MsgStream log(msgSvc(), name());
644 
645  if (dqStatus->calibMode() == 1 && m_beamElemContainer.length() > 0) {// Bigain can use cispar
646 
647  if (m_beamCnv) {
648 
649  if (m_beamCnv->validBeamFrag()) {
650  m_run = m_beamCnv->robFragment()->rod_run_no(); // take it from beam ROD header
651  } else {
652  m_run = 0;
653  }
654  } else
655  m_run = 0;
656 
657  if (m_cispar) {
658  m_time = m_cispar[10]; //time in sc from 1970
659  m_trigType = m_cispar[12];
660  } else {
661  m_time = 0;
662  m_year = 0;
663  m_month = 0;
664  m_day = 0;
665  m_yday = 0;
666  m_hour = 0;
667  m_min = 0;
668  m_trigType = 0;
669  }
670  } else { // monogain can use eventinfo
671 
672  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
673  if ( !eventInfo.isValid() ) {
674  ATH_MSG_ERROR( "No EventInfo object found! Can't read run number!" );
675  m_run = 0;
676  m_time = 0;
677  m_trigType = 0;
678  } else {
679  m_run = eventInfo->runNumber();
680  m_time = eventInfo->timeStamp();
681  if (!(eventInfo->eventType(xAOD::EventInfo::IS_CALIBRATION))) // if not calibration, physics
682  m_trigType = 1;
683  else
684  m_trigType = 0;
685  }
686  }
687 
688  if (m_time != 0) {
689  struct tm t;
690  time_t t_time = m_time;
691  localtime_r(&t_time, &t);
692  m_year = t.tm_year + 1900;
693  m_month = t.tm_mon + 1;
694  m_day = t.tm_mday;
695  m_yday = t.tm_yday + 1;
696  m_hour = t.tm_hour;
697  m_min = t.tm_min;
698  } else {
699  m_year = 0;
700  m_month = 0;
701  m_day = 0;
702  m_yday = 0;
703  m_hour = 0;
704  m_min = 0;
705  }
706 }

◆ 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, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ 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.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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

constexpr int TileRawChNoiseCalibAlg::NCELLGAINS = 6
staticconstexpr

Definition at line 53 of file TileRawChNoiseCalibAlg.h.

◆ NPARS

constexpr int TileRawChNoiseCalibAlg::NPARS = 8
staticconstexpr

Definition at line 54 of file TileRawChNoiseCalibAlg.h.

◆ NSAMPLES

constexpr int TileRawChNoiseCalibAlg::NSAMPLES = 4
staticconstexpr

Definition at line 51 of file TileRawChNoiseCalibAlg.h.

◆ NSIDES

constexpr int TileRawChNoiseCalibAlg::NSIDES = 2
staticconstexpr

Definition at line 50 of file TileRawChNoiseCalibAlg.h.

◆ NTOWERS

constexpr int TileRawChNoiseCalibAlg::NTOWERS = 17
staticconstexpr

Definition at line 52 of file TileRawChNoiseCalibAlg.h.

The documentation for this class was generated from the following files:
TileBeamElemContByteStreamCnv::validBeamFrag
bool validBeamFrag() const
Definition: TileBeamElemContByteStreamCnv.h:67
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileRawChNoiseCalibAlg::m_usePMT
bool m_usePMT
Definition: TileRawChNoiseCalibAlg.h:110
TileRawChNoiseCalibAlg::m_rawChannelContainerDspKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerDspKey
Definition: TileRawChNoiseCalibAlg.h:140
TileRawChNoiseCalibAlg::NSIDES
static constexpr int NSIDES
Definition: TileRawChNoiseCalibAlg.h:50
TileRawChNoiseCalibAlg::m_fillidx
bool m_fillidx
Definition: TileRawChNoiseCalibAlg.h:112
TileRawChNoiseCalibAlg::m_rc_gsigma2
float(* m_rc_gsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:207
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
TileRawChNoiseCalibAlg::m_ecell_rms
float(* m_ecell_rms)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:228
TileRawChNoiseCalibAlg::m_rc_av
float(* m_rc_av)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:195
TileRawChNoiseCalibAlg::m_month
int m_month
Definition: TileRawChNoiseCalibAlg.h:183
TileRawChNoiseCalibAlg::m_gerrsigma2
float(* m_gerrsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:239
TileRawChNoiseCalibAlg::m_histCellAmp
TH1F *(* m_histCellAmp)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:171
TileRawChNoiseCalibAlg::m_maskBadChannels
bool m_maskBadChannels
Definition: TileRawChNoiseCalibAlg.h:107
TileRawChNoiseCalibAlg::m_gsigma2
float(* m_gsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:235
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
TileRawChNoiseCalibAlg::m_digitsContainer
std::string m_digitsContainer
Definition: TileRawChNoiseCalibAlg.h:159
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
TileRawChNoiseCalibAlg::fillCellHist
void fillCellHist()
fillCellHist is called during execute It fill the HGHG and LGLG combination of the cell energies
Definition: TileRawChNoiseCalibAlg.cxx:1087
TileRawChNoiseCalibAlg::m_rc_sigma
float(* m_rc_sigma)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:194
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
TileRawChNoiseCalibAlg::m_doOpt
bool m_doOpt
Definition: TileRawChNoiseCalibAlg.h:98
TileRawChNoiseCalibAlg::Fit
@ Fit
Definition: TileRawChNoiseCalibAlg.h:68
cellbin
Definition: CellClusterLinkTool.h:36
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileRawChNoiseCalibAlg::m_UseforCells
int m_UseforCells
Definition: TileRawChNoiseCalibAlg.h:105
TileDQstatus::isChanDQgood
bool isChanDQgood(int partition, int drawer, int ch) const
returns status of single channel (if bigain, returns AND of ADCs' status
Definition: TileDQstatus.cxx:240
TileRawChNoiseCalibAlg::m_doDsp
bool m_doDsp
Definition: TileRawChNoiseCalibAlg.h:99
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
TileRawChNoiseCalibAlg::m_gcorrsigma1sigma2
float(* m_gcorrsigma1sigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:241
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileRawChNoiseCalibAlg::m_beamElemContainer
std::string m_beamElemContainer
Definition: TileRawChNoiseCalibAlg.h:160
TileRawChNoiseCalibAlg::m_cispar
const uint32_t * m_cispar
Definition: TileRawChNoiseCalibAlg.h:127
TileRawChNoiseCalibAlg::OUTER_MBTS_CHANNEL
@ OUTER_MBTS_CHANNEL
Definition: TileRawChNoiseCalibAlg.h:243
ReadBchFromCool.pmt
pmt
Definition: ReadBchFromCool.py:62
TileRawChNoiseCalibAlg::StoreRunInfo
void StoreRunInfo(const TileDQstatus *dqStatus)
StoreRunInfo is called only during the first event.
Definition: TileRawChNoiseCalibAlg.cxx:630
TileRawChNoiseCalibAlg::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Definition: TileRawChNoiseCalibAlg.h:122
binwidth
bool binwidth
Definition: listroot.cxx:58
TileRawChNoiseCalibAlg::m_calibMode
bool m_calibMode
Definition: TileRawChNoiseCalibAlg.h:94
TileDQstatus::calibMode
uint32_t calibMode() const
Calibration mode.
Definition: TileDQstatus.h:148
TileRawChNoiseCalibAlg::m_beamCnv
TileBeamElemContByteStreamCnv * m_beamCnv
Definition: TileRawChNoiseCalibAlg.h:115
TileRawChNoiseCalibAlg::E1_CHANNEL
@ E1_CHANNEL
Definition: TileRawChNoiseCalibAlg.h:243
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
xAOD::EventInfo_v1::IS_CALIBRATION
@ IS_CALIBRATION
true: calibration, false: physics
Definition: EventInfo_v1.h:155
Tile_Base_ID::side
int side(const Identifier &id) const
Definition: Tile_Base_ID.cxx:153
TileRawChNoiseCalibAlg::m_drawer
uint8_t(* m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:177
TileRawChNoiseCalibAlg::NPARS
static constexpr int NPARS
Definition: TileRawChNoiseCalibAlg.h:54
TileBeamElemContByteStreamCnv::robFragment
const eformat::ROBFragment< const uint32_t * > * robFragment() const
Definition: TileBeamElemContByteStreamCnv.h:66
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
bin
Definition: BinsDiffFromStripMedian.h:43
TileRawChNoiseCalibAlg::deleteHist
void deleteHist()
deleteHist is called at finalize to ensure that no histogram goes into any output root file delete []...
Definition: TileRawChNoiseCalibAlg.cxx:1117
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TileRawChNoiseCalibAlg::m_side
bool(* m_side)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:221
TileRawChNoiseCalibAlg::Dsp
@ Dsp
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::m_tileID
const TileID * m_tileID
Definition: TileRawChNoiseCalibAlg.h:118
TileRawChNoiseCalibAlg::m_gchi2
float(* m_gchi2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:237
TileRawChNoiseCalibAlg::m_gerrsigma1
float(* m_gerrsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:238
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
TileRawChNoiseCalibAlg::m_rc_sigma_err
float(* m_rc_sigma_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:200
TileRawChNoiseCalibAlg::OF1
@ OF1
Definition: TileRawChNoiseCalibAlg.h:68
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileRawChNoiseCalibAlg::m_time
int m_time
Definition: TileRawChNoiseCalibAlg.h:181
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
TileRawChNoiseCalibAlg::m_gsigma1
float(* m_gsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:234
TileRawChNoiseCalibAlg::m_rc_mean_err
float(* m_rc_mean_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:199
TileRawChNoiseCalibAlg::m_run
int m_run
Definition: TileRawChNoiseCalibAlg.h:188
TileRawChNoiseCalibAlg::m_year
int m_year
Definition: TileRawChNoiseCalibAlg.h:182
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition: TileRawData.h:53
HWIdentifier
Definition: HWIdentifier.h:13
TileRawChNoiseCalibAlg::m_rawChannelContainerOF1Key
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOF1Key
Definition: TileRawChNoiseCalibAlg.h:143
TileDQstatus::isChEmpty
static int isChEmpty(int partition, int drawer, int ch)
True if channel is not fully implemented.
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
TileRawChNoiseCalibAlg::m_rc_gchi2
float(* m_rc_gchi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:209
TileRawChNoiseCalibAlg::fillCell
void fillCell(TileRawChannelUnit::UNIT RChUnit, const TileRawChannel *rch)
Definition: TileRawChNoiseCalibAlg.cxx:863
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileRawChNoiseCalibAlg::Ped
@ Ped
Definition: TileRawChNoiseCalibAlg.h:72
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TileRawChNoiseCalibAlg::m_cell_nch
int(* m_cell_nch)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:231
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileCalibUtils::MAX_DRAWER
static const unsigned int MAX_DRAWER
Number of drawers in ROS 1-4.
Definition: TileCalibUtils.h:139
TileRawChNoiseCalibAlg::NTOWERS
static constexpr int NTOWERS
Definition: TileRawChNoiseCalibAlg.h:52
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TileRawChNoiseCalibAlg::m_ecell_av
float(* m_ecell_av)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:227
TileRawChNoiseCalibAlg::m_rc_gnorm
float(* m_rc_gnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:208
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TileRawChNoiseCalibAlg::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: TileRawChNoiseCalibAlg.h:129
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
TileRawChNoiseCalibAlg::m_rc_probC2
float(* m_rc_probC2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:203
TileRawChNoiseCalibAlg::m_treeSize
int64_t m_treeSize
Definition: TileRawChNoiseCalibAlg.h:155
TileRawChNoiseCalibAlg::m_ntupleID
std::string m_ntupleID
Definition: TileRawChNoiseCalibAlg.h:153
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileCablingService::isRun2PlusCabling
bool isRun2PlusCabling() const
Definition: TileCablingService.h:278
PlotCalibFromCool.nentries
nentries
Definition: PlotCalibFromCool.py:798
TileRawChNoiseCalibAlg::finalRawCh
void finalRawCh(int rctype)
finalDigits is called during finalize Here the average Ped, lfn, hfn and covariance are calculated.
Definition: TileRawChNoiseCalibAlg.cxx:797
AthCommonDataStore
Definition: AthCommonDataStore.h:52
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition: TileRawChannel.h:101
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileRawChNoiseCalibAlg::m_rawChannelContainerMFKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerMFKey
Definition: TileRawChNoiseCalibAlg.h:146
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:100
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
TileRawChNoiseCalibAlg::m_hour
int m_hour
Definition: TileRawChNoiseCalibAlg.h:186
xmin
double xmin
Definition: listroot.cxx:60
TileRawChNoiseCalibAlg::m_rawChannelContainerOptKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOptKey
Definition: TileRawChNoiseCalibAlg.h:137
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileRawChNoiseCalibAlg::MF
@ MF
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::m_tileIdTrans
ToolHandle< TileCondIdTransforms > m_tileIdTrans
Definition: TileRawChNoiseCalibAlg.h:125
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
dqt_zlumi_alleff_HIST.fout
fout
Definition: dqt_zlumi_alleff_HIST.py:59
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TileRawChNoiseCalibAlg::m_rawChannelContainerFitKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFitKey
Definition: TileRawChNoiseCalibAlg.h:134
TileRawChNoiseCalibAlg::m_trigType
int m_trigType
Definition: TileRawChNoiseCalibAlg.h:189
TileRawChNoiseCalibAlg::m_file
std::string m_file
Definition: TileRawChNoiseCalibAlg.h:154
TileRawChNoiseCalibAlg::m_doFit
bool m_doFit
Definition: TileRawChNoiseCalibAlg.h:96
TileRawChNoiseCalibAlg::m_cabling
const TileCablingService * m_cabling
Definition: TileRawChNoiseCalibAlg.h:116
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
TileRawChNoiseCalibAlg::Fixed
@ Fixed
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
TileRawChNoiseCalibAlg::m_rawChannelContainerFixedKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFixedKey
Definition: TileRawChNoiseCalibAlg.h:131
TileRawChannel
Definition: TileRawChannel.h:35
TileRawChNoiseCalibAlg::Unknown
@ Unknown
Definition: TileRawChNoiseCalibAlg.h:72
TileRawChNoiseCalibAlg::m_rc_gerrsigma2
float(* m_rc_gerrsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:211
TileRawChNoiseCalibAlg::m_ecell_hash
uint32_t(* m_ecell_hash)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS]
Definition: TileRawChNoiseCalibAlg.h:229
TileRawChNoiseCalibAlg::m_gnorm
float(* m_gnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:236
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TileCalibUtils::MAX_ROS
static const unsigned int MAX_ROS
Number of ROSs
Definition: TileCalibUtils.h:138
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileRawChNoiseCalibAlg::m_doMF
bool m_doMF
Definition: TileRawChNoiseCalibAlg.h:101
TileRawChNoiseCalibAlg::m_ggpar
float(* m_ggpar)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]
Definition: TileRawChNoiseCalibAlg.h:233
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
TileRawChNoiseCalibAlg::m_day
int m_day
Definition: TileRawChNoiseCalibAlg.h:184
TileRawChNoiseCalibAlg::m_gerrnorm
float(* m_gerrnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:240
TileBeamElemContByteStreamCnv
This AthConstConverter class provides conversion from ByteStream to TileBeamElemContainer.
Definition: TileBeamElemContByteStreamCnv.h:48
TileRawChNoiseCalibAlg::m_rc_gsigma1
float(* m_rc_gsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:206
TileRawChNoiseCalibAlg::m_yday
int m_yday
Definition: TileRawChNoiseCalibAlg.h:185
TileRawChNoiseCalibAlg::Cis
@ Cis
Definition: TileRawChNoiseCalibAlg.h:72
TileDQstatus::isAdcDQgood
bool isAdcDQgood(int partition, int drawer, int ch, int gain) const
returns status of single ADC returns False if there are any errors
Definition: TileDQstatus.cxx:178
TileRawChNoiseCalibAlg::Opt
@ Opt
Definition: TileRawChNoiseCalibAlg.h:68
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TileRawChNoiseCalibAlg::RCnum
@ RCnum
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::Phys
@ Phys
Definition: TileRawChNoiseCalibAlg.h:72
TileRawChNoiseCalibAlg::SPECIAL_C10_CHANNEL
@ SPECIAL_C10_CHANNEL
Definition: TileRawChNoiseCalibAlg.h:243
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TileRawChNoiseCalibAlg::finalCell
void finalCell()
finalCell is called during finalize Here the cell variables of the ntuple are filled.
Definition: TileRawChNoiseCalibAlg.cxx:948
TileRawChNoiseCalibAlg::m_sample
uint8_t(* m_sample)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:223
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
TileRawChNoiseCalibAlg::fillRawChannels
StatusCode fillRawChannels(const TileDQstatus *dqStatus, const SG::ReadHandleKey< TileRawChannelContainer > &rawChannelContainerKey, RCtype rctype)
Definition: TileRawChNoiseCalibAlg.cxx:711
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
TileRawChNoiseCalibAlg::NCELLGAINS
static constexpr int NCELLGAINS
Definition: TileRawChNoiseCalibAlg.h:53
TileRawChNoiseCalibAlg::m_histAmp
TH1F *(* m_histAmp)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:170
TileRawChNoiseCalibAlg::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: TileRawChNoiseCalibAlg.h:120
TileRawChNoiseCalibAlg::m_rc_ndf
float(* m_rc_ndf)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:202
TileRawChNoiseCalibAlg::m_evt
int(* m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:175
TileRawChNoiseCalibAlg::m_saveHist
bool m_saveHist
Definition: TileRawChNoiseCalibAlg.h:102
TileRawChNoiseCalibAlg::digiChannel2PMT
int digiChannel2PMT(int ros, int chan)
Definition: TileRawChNoiseCalibAlg.h:89
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
TileRawChNoiseCalibAlg::m_phi
uint8_t(* m_phi)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:222
TileRawChNoiseCalibAlg::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition: TileRawChNoiseCalibAlg.h:124
TileRawChNoiseCalibAlg::m_ecell_ene
float(* m_ecell_ene)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:232
DeMoScan.index
string index
Definition: DeMoScan.py:362
TileRawChNoiseCalibAlg::m_tower
uint8_t(* m_tower)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:224
TileRawChNoiseCalibAlg::FirstEvt_initialize
StatusCode FirstEvt_initialize()
Initialization done at the first event.
Definition: TileRawChNoiseCalibAlg.cxx:272
TileRawChNoiseCalibAlg::m_doFixed
bool m_doFixed
Definition: TileRawChNoiseCalibAlg.h:97
TileCablingService::C10_connected
static bool C10_connected(int module)
Definition: TileCablingService.cxx:1779
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition: TileRawData.cxx:65
a
TList * a
Definition: liststreamerinfos.cxx:10
h
TH1F
Definition: rootspy.cxx:320
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileRawChNoiseCalibAlg::m_rc_gcorrsigma1sigma2
float(* m_rc_gcorrsigma1sigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:213
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
F
#define F(x, y, z)
Definition: MD5.cxx:112
generate::GetEntries
double GetEntries(TH1D *h, int ilow, int ihi)
Definition: rmsFrac.cxx:20
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
TileRawChNoiseCalibAlg::m_gg
uint8_t(* m_gg)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:225
xmax
double xmax
Definition: listroot.cxx:61
beamspotnt.rms
rms
Definition: bin/beamspotnt.py:1266
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
TileRawChNoiseCalibAlg::m_rc_rms
float(* m_rc_rms)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:196
TileRawChNoiseCalibAlg::NSAMPLES
static constexpr int NSAMPLES
Definition: TileRawChNoiseCalibAlg.h:51
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
TileRawChNoiseCalibAlg::m_gain
bool(* m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:179
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
TileRawChNoiseCalibAlg::doFit
static void doFit(TH1F *h, float *gp, bool invert=true)
doFit performs the double gaussian fit of the amplitude
Definition: TileRawChNoiseCalibAlg.cxx:992
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
Tile_Base_ID::cell_hash
IdentifierHash cell_hash(const Identifier &cell_id) const
fast conversion from ID to hash for cells
Definition: Tile_Base_ID.cxx:1030
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
TileAANtupleConfig.rawChannelContainer
rawChannelContainer
Definition: TileAANtupleConfig.py:120
TileRawChNoiseCalibAlg::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileRawChNoiseCalibAlg.h:119
TileCalibUtils::MAX_CHAN
static const unsigned int MAX_CHAN
Number of channels in drawer.
Definition: TileCalibUtils.h:141
TileRawChNoiseCalibAlg::m_rc_kurtosis
float(* m_rc_kurtosis)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:198
TileRawChNoiseCalibAlg::m_rc_ggpar
float(* m_rc_ggpar)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]
Definition: TileRawChNoiseCalibAlg.h:205
TileRawChNoiseCalibAlg::m_rc_chi2
float(* m_rc_chi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:201
TileRawChNoiseCalibAlg::Las
@ Las
Definition: TileRawChNoiseCalibAlg.h:72
TileRawChNoiseCalibAlg::m_evtNr
int m_evtNr
Definition: TileRawChNoiseCalibAlg.h:174
TileRawChNoiseCalibAlg::m_ros
uint8_t(* m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:176
TileRawChNoiseCalibAlg::m_doOF1
bool m_doOF1
Definition: TileRawChNoiseCalibAlg.h:100
TileRawChNoiseCalibAlg::m_rc_mean
float(* m_rc_mean)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:193
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileRawChNoiseCalibAlg::m_rc_gerrnorm
float(* m_rc_gerrnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:212
readCCLHist.float
float
Definition: readCCLHist.py:83
TileRawChNoiseCalibAlg::m_rc_skewness
float(* m_rc_skewness)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:197
TileCablingService::E1_merged_with_run2plus
int E1_merged_with_run2plus(int ros, int module) const
Definition: TileCablingService.cxx:2457
TileRawChNoiseCalibAlg::m_rc_gerrsigma1
float(* m_rc_gerrsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:210
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
python.trfValidateRootFile.rc
rc
Definition: trfValidateRootFile.py:357
TileRawChNoiseCalibAlg::m_min
int m_min
Definition: TileRawChNoiseCalibAlg.h:187
TileRawChNoiseCalibAlg::m_invertChanRatio
bool m_invertChanRatio
Definition: TileRawChNoiseCalibAlg.h:103
fitman.k
k
Definition: fitman.py:528
ServiceHandle< IConversionSvc >
TileCalibUtils::MAX_GAIN
static const unsigned int MAX_GAIN
Number of gains per channel
Definition: TileCalibUtils.h:142
TileRawChNoiseCalibAlg::m_channel
uint8_t(* m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:178
Generated on Fri Jul 5 2024 22:02:59 for ATLAS Offline Software by   doxygen 1.8.18