ATLAS Offline Software
Loading...
Searching...
No Matches
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.
virtual StatusCode execute () override
 Main method.
virtual StatusCode finalize () override
 The output ntuple is created in finalize method.
void finalRawCh (int rctype)
 finalDigits is called during finalize Here the average Ped, lfn, hfn and covariance are calculated.
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Static Public Attributes

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

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Private Types

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

Private Member Functions

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

Static Private Member Functions

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

Private Attributes

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

Detailed Description

Definition at line 47 of file TileRawChNoiseCalibAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ Tile

using TileRawChNoiseCalibAlg::Tile = TileCalibUtils
private

Definition at line 168 of file TileRawChNoiseCalibAlg.h.

Member Enumeration Documentation

◆ CELL_CHANNEL

enum TileRawChNoiseCalibAlg::CELL_CHANNEL
private
Enumerator
OUTER_MBTS_CHANNEL 
SPECIAL_C10_CHANNEL 
E1_CHANNEL 

Definition at line 243 of file TileRawChNoiseCalibAlg.h.

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}
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
TileCalibUtils::MAX_ROS
static const unsigned int MAX_ROS
Number of ROSs.
Definition TileCalibUtils.h:138
TileCalibUtils::MAX_GAIN
static const unsigned int MAX_GAIN
Number of gains per channel.
Definition TileCalibUtils.h:142
TileCalibUtils::MAX_DRAWER
static const unsigned int MAX_DRAWER
Number of drawers in ROS 1-4.
Definition TileCalibUtils.h:139
TileCalibUtils::MAX_CHAN
static const unsigned int MAX_CHAN
Number of channels in drawer.
Definition TileCalibUtils.h:141
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_rc_av
float(* m_rc_av)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:195
TileRawChNoiseCalibAlg::m_ros
uint8_t(* m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:176
TileRawChNoiseCalibAlg::m_ecell_hash
uint32_t(* m_ecell_hash)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS]
Definition TileRawChNoiseCalibAlg.h:229
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_side
bool(* m_side)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:221
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_sigma_err
float(* m_rc_sigma_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:200
TileRawChNoiseCalibAlg::m_rc_gsigma2
float(* m_rc_gsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:207
TileRawChNoiseCalibAlg::m_rc_mean
float(* m_rc_mean)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:193
TileRawChNoiseCalibAlg::m_drawer
uint8_t(* m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:177
TileRawChNoiseCalibAlg::m_gerrsigma1
float(* m_gerrsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:238
TileRawChNoiseCalibAlg::m_gg
uint8_t(* m_gg)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:225
TileRawChNoiseCalibAlg::m_beamCnv
TileBeamElemContByteStreamCnv * m_beamCnv
Definition TileRawChNoiseCalibAlg.h:115
TileRawChNoiseCalibAlg::m_rc_gerrsigma1
float(* m_rc_gerrsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:210
TileRawChNoiseCalibAlg::NSIDES
static constexpr int NSIDES
Definition TileRawChNoiseCalibAlg.h:50
TileRawChNoiseCalibAlg::m_sample
uint8_t(* m_sample)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:223
TileRawChNoiseCalibAlg::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition TileRawChNoiseCalibAlg.h:124
TileRawChNoiseCalibAlg::m_tower
uint8_t(* m_tower)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:224
TileRawChNoiseCalibAlg::m_phi
uint8_t(* m_phi)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:222
TileRawChNoiseCalibAlg::m_gerrnorm
float(* m_gerrnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:240
TileRawChNoiseCalibAlg::m_gain
bool(* m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:179
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::m_ecell_ene
float(* m_ecell_ene)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:232
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::m_rc_gerrnorm
float(* m_rc_gerrnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:212
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::m_rc_sigma
float(* m_rc_sigma)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:194
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_histAmp
TH1F *(* m_histAmp)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:170
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_rc_skewness
float(* m_rc_skewness)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:197
TileRawChNoiseCalibAlg::m_gcorrsigma1sigma2
float(* m_gcorrsigma1sigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:241
TileRawChNoiseCalibAlg::m_ecell_av
float(* m_ecell_av)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:227
TileRawChNoiseCalibAlg::m_gsigma1
float(* m_gsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:234
TileRawChNoiseCalibAlg::m_gnorm
float(* m_gnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:236
TileRawChNoiseCalibAlg::m_cabling
const TileCablingService * m_cabling
Definition TileRawChNoiseCalibAlg.h:116
TileRawChNoiseCalibAlg::m_ggpar
float(* m_ggpar)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]
Definition TileRawChNoiseCalibAlg.h:233
TileRawChNoiseCalibAlg::m_rc_gnorm
float(* m_rc_gnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:208
TileRawChNoiseCalibAlg::m_gsigma2
float(* m_gsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:235
TileRawChNoiseCalibAlg::NTOWERS
static constexpr int NTOWERS
Definition TileRawChNoiseCalibAlg.h:52
TileRawChNoiseCalibAlg::m_histCellAmp
TH1F *(* m_histCellAmp)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:171
TileRawChNoiseCalibAlg::m_rc_gcorrsigma1sigma2
float(* m_rc_gcorrsigma1sigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:213
TileRawChNoiseCalibAlg::NSAMPLES
static constexpr int NSAMPLES
Definition TileRawChNoiseCalibAlg.h:51
TileRawChNoiseCalibAlg::NCELLGAINS
static constexpr int NCELLGAINS
Definition TileRawChNoiseCalibAlg.h:53
TileRawChNoiseCalibAlg::m_gchi2
float(* m_gchi2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:237
TileRawChNoiseCalibAlg::m_channel
uint8_t(* m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:178
TileRawChNoiseCalibAlg::m_evt
int(* m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:175
TileRawChNoiseCalibAlg::m_cell_nch
int(* m_cell_nch)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:231
TileRawChNoiseCalibAlg::m_gerrsigma2
float(* m_gerrsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:239
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_gerrsigma2
float(* m_rc_gerrsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:211
TileRawChNoiseCalibAlg::m_ecell_rms
float(* m_ecell_rms)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:228
python.TrigEgammaMonitorHelper.TH1F
TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition TrigEgammaMonitorHelper.py:24
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127

◆ ~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()

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ 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}
rc
static Double_t rc
Definition LArPhysWaveHECTool.cxx:37
Example_ReadSampleNoise.drawer
drawer
Definition Example_ReadSampleNoise.py:39
FullCPAlgorithmsTest_eljob.sample
sample
Definition FullCPAlgorithmsTest_eljob.py:116
sendEI_SPB.ch
ch
Definition sendEI_SPB.py:35

◆ 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}
xmax
double xmax
Definition listroot.cxx:61
xmin
double xmin
Definition listroot.cxx:60

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

85{ 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}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
empty
static const Attributes_t empty
Definition XmlStreamer.cxx:16
TileDQstatus::calibMode
uint32_t calibMode() const
Calibration mode.
Definition TileDQstatus.h:148
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition TileDQstatus.h:152
TileRawChNoiseCalibAlg::m_rawChannelContainerMFKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerMFKey
Definition TileRawChNoiseCalibAlg.h:146
TileRawChNoiseCalibAlg::fillRawChannels
StatusCode fillRawChannels(const TileDQstatus *dqStatus, const SG::ReadHandleKey< TileRawChannelContainer > &rawChannelContainerKey, RCtype rctype)
Definition TileRawChNoiseCalibAlg.cxx:711
TileRawChNoiseCalibAlg::m_rawChannelContainerFixedKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFixedKey
Definition TileRawChNoiseCalibAlg.h:131
TileRawChNoiseCalibAlg::m_rawChannelContainerDspKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerDspKey
Definition TileRawChNoiseCalibAlg.h:140
TileRawChNoiseCalibAlg::m_rawChannelContainerOptKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOptKey
Definition TileRawChNoiseCalibAlg.h:137
TileRawChNoiseCalibAlg::m_rawChannelContainerOF1Key
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOF1Key
Definition TileRawChNoiseCalibAlg.h:143
TileRawChNoiseCalibAlg::FirstEvt_initialize
StatusCode FirstEvt_initialize()
Initialization done at the first event.
Definition TileRawChNoiseCalibAlg.cxx:272
TileRawChNoiseCalibAlg::StoreRunInfo
void StoreRunInfo(const TileDQstatus *dqStatus)
StoreRunInfo is called only during the first event.
Definition TileRawChNoiseCalibAlg.cxx:630
TileRawChNoiseCalibAlg::m_rawChannelContainerFitKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFitKey
Definition TileRawChNoiseCalibAlg.h:134
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:270

◆ 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}
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition AthAlgorithm.h:79

◆ 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}
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
TileCablingService::C10_connected
static bool C10_connected(int module)
Definition TileCablingService.cxx:1772
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition TileCalibUtils.cxx:145
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition TileCalibUtils.cxx:60
TileRawChNoiseCalibAlg::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Definition TileRawChNoiseCalibAlg.h:122
TileRawChNoiseCalibAlg::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition TileRawChNoiseCalibAlg.h:120
TileRawChNoiseCalibAlg::m_tileIdTrans
ToolHandle< TileCondIdTransforms > m_tileIdTrans
Definition TileRawChNoiseCalibAlg.h:125
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition TileRawChannel.h:101
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition TileRawData.cxx:65
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition TileRawData.h:53
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:109
DeMoScan.index
str index
Definition DeMoScan.py:362
plotting.yearwise_efficiency.channel
channel
Definition yearwise_efficiency.py:24

◆ 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}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
DataVector::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition DataVector.h:838
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
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
TileDQstatus::isChEmpty
static int isChEmpty(int partition, int drawer, int ch)
True if channel is not fully implemented.
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::fillCell
void fillCell(TileRawChannelUnit::UNIT RChUnit, const TileRawChannel *rch)
Definition TileRawChNoiseCalibAlg.cxx:863
TileRawChNoiseCalibAlg::digiChannel2PMT
int digiChannel2PMT(int ros, int chan)
Definition TileRawChNoiseCalibAlg.h:89

◆ 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}
GetEntries
TGraphErrors * GetEntries(TH2F *histo)
Definition TRTCalib_makeplots.cxx:4025
doFit
bool doFit
Definition dependence.cxx:57

◆ 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}
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
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
TileRawChNoiseCalibAlg::finalCell
void finalCell()
finalCell is called during finalize Here the cell variables of the ntuple are filled.
Definition TileRawChNoiseCalibAlg.cxx:948
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
fout
static TFile * fout
Definition listroot.cxx:40
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:5

◆ 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}
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition Control/AthenaKernel/AthenaKernel/errorcheck.h:422
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition TileCablingService.cxx:24
python.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110
ClassID_traits::ID
static CLID ID()
Definition Control/AthenaKernel/AthenaKernel/ClassID_traits.h:44

◆ 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}
TileRawChNoiseCalibAlg::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition TileRawChNoiseCalibAlg.h:129
binwidth
bool binwidth
Definition listroot.cxx:58

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ 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 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ 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}
xAOD::EventInfo_v1::IS_CALIBRATION
@ IS_CALIBRATION
true: calibration, false: physics
Definition EventInfo_v1.h:155
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition StdJOSetup.py:36

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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}
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition AthAlgorithm.cxx:66
AthCommonDataStore< AthCommonMsg< Algorithm > >::AthCommonDataStore
AthCommonDataStore(const std::string &name, T... args)
Definition AthCommonDataStore.h:55
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

◆ 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 }
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

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.

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

◆ m_evt

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

Definition at line 175 of file TileRawChNoiseCalibAlg.h.

◆ m_evtNr

int TileRawChNoiseCalibAlg::m_evtNr
private

Definition at line 174 of file TileRawChNoiseCalibAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_file

std::string TileRawChNoiseCalibAlg::m_file
private

Definition at line 154 of file TileRawChNoiseCalibAlg.h.

◆ m_fillidx

bool TileRawChNoiseCalibAlg::m_fillidx
private

Definition at line 112 of file TileRawChNoiseCalibAlg.h.

◆ m_fitRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_fitRawChannelContainer
private

Definition at line 162 of file TileRawChNoiseCalibAlg.h.

◆ m_fixedRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_fixedRawChannelContainer
private

Definition at line 161 of file TileRawChNoiseCalibAlg.h.

◆ m_gain

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

Definition at line 179 of file TileRawChNoiseCalibAlg.h.

◆ m_gchi2

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

Definition at line 237 of file TileRawChNoiseCalibAlg.h.

◆ m_gcorrsigma1sigma2

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

Definition at line 241 of file TileRawChNoiseCalibAlg.h.

◆ m_gerrnorm

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

Definition at line 240 of file TileRawChNoiseCalibAlg.h.

◆ m_gerrsigma1

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

Definition at line 238 of file TileRawChNoiseCalibAlg.h.

◆ m_gerrsigma2

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

Definition at line 239 of file TileRawChNoiseCalibAlg.h.

◆ m_gg

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

Definition at line 225 of file TileRawChNoiseCalibAlg.h.

◆ m_ggpar

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

Definition at line 233 of file TileRawChNoiseCalibAlg.h.

◆ m_gnorm

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

Definition at line 236 of file TileRawChNoiseCalibAlg.h.

◆ m_gsigma1

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

Definition at line 234 of file TileRawChNoiseCalibAlg.h.

◆ m_gsigma2

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

Definition at line 235 of file TileRawChNoiseCalibAlg.h.

◆ m_histAmp

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

Definition at line 170 of file TileRawChNoiseCalibAlg.h.

◆ m_histCellAmp

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

Definition at line 171 of file TileRawChNoiseCalibAlg.h.

◆ m_hour

int TileRawChNoiseCalibAlg::m_hour
private

Definition at line 186 of file TileRawChNoiseCalibAlg.h.

◆ m_invertChanRatio

bool TileRawChNoiseCalibAlg::m_invertChanRatio
private

Definition at line 103 of file TileRawChNoiseCalibAlg.h.

◆ m_maskBadChannels

bool TileRawChNoiseCalibAlg::m_maskBadChannels
private

Definition at line 107 of file TileRawChNoiseCalibAlg.h.

◆ m_MFRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_MFRawChannelContainer
private

Definition at line 166 of file TileRawChNoiseCalibAlg.h.

◆ m_min

int TileRawChNoiseCalibAlg::m_min
private

Definition at line 187 of file TileRawChNoiseCalibAlg.h.

◆ m_month

int TileRawChNoiseCalibAlg::m_month
private

Definition at line 183 of file TileRawChNoiseCalibAlg.h.

◆ m_ntupleID

std::string TileRawChNoiseCalibAlg::m_ntupleID
private

Definition at line 153 of file TileRawChNoiseCalibAlg.h.

◆ m_OF1RawChannelContainer

std::string TileRawChNoiseCalibAlg::m_OF1RawChannelContainer
private

Definition at line 165 of file TileRawChNoiseCalibAlg.h.

◆ m_optRawChannelContainer

std::string TileRawChNoiseCalibAlg::m_optRawChannelContainer
private

Definition at line 163 of file TileRawChNoiseCalibAlg.h.

◆ m_phi

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

Definition at line 222 of file TileRawChNoiseCalibAlg.h.

◆ m_rawChannelContainerDspKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerDspKey
private
Initial value:
{this,
"TileRawChannelContainerDsp", "TileRawChannelCnt",
"Input Tile raw channel container from DSP"}

Definition at line 140 of file TileRawChNoiseCalibAlg.h.

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

◆ m_rawChannelContainerFitKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerFitKey
private
Initial value:
{this,
"TileRawChannelContainerFit", "TileRawChannelFit",
"Input Tile raw channel container reconstructed with Fit method"}

Definition at line 134 of file TileRawChNoiseCalibAlg.h.

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

◆ m_rawChannelContainerFixedKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerFixedKey
private
Initial value:
{this,
"TileRawChannelContainerFixed", "TileRawChannelFixed",
"Input Tile raw channel container reconstructed with ATLAS method"}

Definition at line 131 of file TileRawChNoiseCalibAlg.h.

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

◆ m_rawChannelContainerMFKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerMFKey
private
Initial value:
{this,
"TileRawChannelContainerMF", "TileRawChannelMF",
"Input Tile raw channel container reconstructed with MF method"}

Definition at line 146 of file TileRawChNoiseCalibAlg.h.

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

◆ m_rawChannelContainerOF1Key

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerOF1Key
private
Initial value:
{this,
"TileRawChannelContainerOF1", "TileRawChannelOF1",
"Input Tile raw channel container reconstructed with OF1 method"}

Definition at line 143 of file TileRawChNoiseCalibAlg.h.

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

◆ m_rawChannelContainerOptKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChNoiseCalibAlg::m_rawChannelContainerOptKey
private
Initial value:
{this,
"TileRawChannelContainerOpt", "TileRawChannelOpt2",
"Input Tile raw channel container reconstructed with Opt method"}

Definition at line 137 of file TileRawChNoiseCalibAlg.h.

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

◆ m_rc_av

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

Definition at line 195 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_chi2

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

Definition at line 201 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gchi2

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

Definition at line 209 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gcorrsigma1sigma2

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

Definition at line 213 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gerrnorm

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

Definition at line 212 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gerrsigma1

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

Definition at line 210 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gerrsigma2

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

Definition at line 211 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_ggpar

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

Definition at line 205 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gnorm

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

Definition at line 208 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gsigma1

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

Definition at line 206 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_gsigma2

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

Definition at line 207 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_kurtosis

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

Definition at line 198 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_mean

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

Definition at line 193 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_mean_err

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

Definition at line 199 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_ndf

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

Definition at line 202 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_probC2

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

Definition at line 203 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_rms

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

Definition at line 196 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_sigma

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

Definition at line 194 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_sigma_err

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

Definition at line 200 of file TileRawChNoiseCalibAlg.h.

◆ m_rc_skewness

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

Definition at line 197 of file TileRawChNoiseCalibAlg.h.

◆ m_ros

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

Definition at line 176 of file TileRawChNoiseCalibAlg.h.

◆ m_run

int TileRawChNoiseCalibAlg::m_run
private

Definition at line 188 of file TileRawChNoiseCalibAlg.h.

◆ m_sample

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

Definition at line 223 of file TileRawChNoiseCalibAlg.h.

◆ m_saveHist

bool TileRawChNoiseCalibAlg::m_saveHist
private

Definition at line 102 of file TileRawChNoiseCalibAlg.h.

◆ m_side

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

Definition at line 221 of file TileRawChNoiseCalibAlg.h.

◆ m_tileBadChanTool

ToolHandle<ITileBadChanTool> TileRawChNoiseCalibAlg::m_tileBadChanTool
private
Initial value:
{this,
"TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"}

Definition at line 122 of file TileRawChNoiseCalibAlg.h.

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

◆ m_tileHWID

const TileHWID* TileRawChNoiseCalibAlg::m_tileHWID
private

Definition at line 119 of file TileRawChNoiseCalibAlg.h.

◆ m_tileID

const TileID* TileRawChNoiseCalibAlg::m_tileID
private

Definition at line 118 of file TileRawChNoiseCalibAlg.h.

◆ m_tileIdTrans

ToolHandle<TileCondIdTransforms> TileRawChNoiseCalibAlg::m_tileIdTrans
private
Initial value:
{this,
"TileCondIdTransforms", "TileCondIdTransforms", "Tile Id transforms tool"}

Definition at line 125 of file TileRawChNoiseCalibAlg.h.

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

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileRawChNoiseCalibAlg::m_tileToolEmscale
private
Initial value:
{this,
"TileCondToolEmscale", "TileCondToolEmscale", "Tile em scale tool"}

Definition at line 120 of file TileRawChNoiseCalibAlg.h.

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

◆ m_time

int TileRawChNoiseCalibAlg::m_time
private

Definition at line 181 of file TileRawChNoiseCalibAlg.h.

◆ m_tower

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

Definition at line 224 of file TileRawChNoiseCalibAlg.h.

◆ m_treeSize

int64_t TileRawChNoiseCalibAlg::m_treeSize
private

Definition at line 155 of file TileRawChNoiseCalibAlg.h.

◆ m_trigType

int TileRawChNoiseCalibAlg::m_trigType
private

Definition at line 189 of file TileRawChNoiseCalibAlg.h.

◆ m_UseforCells

int TileRawChNoiseCalibAlg::m_UseforCells
private

Definition at line 105 of file TileRawChNoiseCalibAlg.h.

◆ m_usePMT

bool TileRawChNoiseCalibAlg::m_usePMT
private

Definition at line 110 of file TileRawChNoiseCalibAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_yday

int TileRawChNoiseCalibAlg::m_yday
private

Definition at line 185 of file TileRawChNoiseCalibAlg.h.

◆ m_year

int TileRawChNoiseCalibAlg::m_year
private

Definition at line 182 of file TileRawChNoiseCalibAlg.h.

◆ NCELLGAINS

int TileRawChNoiseCalibAlg::NCELLGAINS = 6
staticconstexpr

Definition at line 53 of file TileRawChNoiseCalibAlg.h.

◆ NPARS

int TileRawChNoiseCalibAlg::NPARS = 8
staticconstexpr

Definition at line 54 of file TileRawChNoiseCalibAlg.h.

◆ NSAMPLES

int TileRawChNoiseCalibAlg::NSAMPLES = 4
staticconstexpr

Definition at line 51 of file TileRawChNoiseCalibAlg.h.

◆ NSIDES

int TileRawChNoiseCalibAlg::NSIDES = 2
staticconstexpr

Definition at line 50 of file TileRawChNoiseCalibAlg.h.

◆ NTOWERS

int TileRawChNoiseCalibAlg::NTOWERS = 17
staticconstexpr

Definition at line 52 of file TileRawChNoiseCalibAlg.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0