ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
TileTBAANtuple Class Reference

class to produce TileCal commissioning ntuples More...

#include <TileTBAANtuple.h>

Inheritance diagram for TileTBAANtuple:
Collaboration diagram for TileTBAANtuple:

Public Member Functions

 TileTBAANtuple (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TileTBAANtuple ()=default
 
StatusCode ntuple_initialize (const EventContext &ctx)
 Alg standard interface function LF TODO: We could have a problem with the new feature introduced by Sasha that quit empty fragments and therefore it can increase or decrease the number of RawChannels fragments dynamically. More...
 
StatusCode ntuple_clear ()
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

enum  { NOT_SETUP = -9999 }
 
enum  { MAX_MINIDRAWER = 4, MAX_CHAN = 48, MAX_DMU = 16 }
 
typedef std::map< unsigned int, unsigned int, std::less< unsigned int > >::iterator drawerMap_iterator
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode storeRawChannels (const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, bool calibMode, std::vector< std::array< float, MAX_CHAN >> *eneVec, std::vector< std::array< float, MAX_CHAN >> *timeVec, std::vector< std::array< float, MAX_CHAN >> *chi2Vec, std::vector< std::array< float, MAX_CHAN >> *pedVec, bool saveDQstatus=false)
 / Fill ntuple with data from TRC. More...
 
StatusCode storeDigits (const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey, const TileDQstatus *dqStatus=nullptr)
 / Fill Ntuple with info from TileDigits / Return true if the collection is empty, / which means that there are no RawChanels either. More...
 
StatusCode storeDigitsFlx (const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey)
 
StatusCode storeBeamElements (const EventContext &ctx)
 
StatusCode storeCells (const EventContext &ctx)
 
StatusCode storeLaser (const EventContext &ctx)
 
StatusCode storeHitVector (const EventContext &ctx)
 
StatusCode storeHitContainer (const EventContext &ctx)
 / Fill Ntuple with MC truth info from simulation / Namely, hit energies corrected by photoelectron statistics and Birks' law More...
 
void storeHit (const TileHit *hit, int fragType, int fragId, std::array< float, MAX_CHAN > &ehitVec, std::array< float, MAX_CHAN > &thitVec, const TileSamplingFraction *samplingFraction)
 
StatusCode initList (const EventContext &ctx)
 
StatusCode initListFlx (const EventContext &ctx)
 
StatusCode initNTuple (void)
 
void getEta (void)
 
void TRIGGER_addBranch (void)
 /////////////////////////////////////////////////////////////////////////// More...
 
void MUON_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add MUON variables to the Tree More...
 
void ECAL_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add ECAL variables to the Tree More...
 
void QDC_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add QDC variables to the Tree More...
 
void LASER_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree LASER variables Tree More...
 
void ADDER_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree ADDER variables Tree More...
 
void CISPAR_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variables Tree More...
 
void BEAM_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree BEAM variables Tree More...
 
void DIGI_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables Tree More...
 
void FELIX_addBranch (void)
 
void HIT_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree HIT variables Tree More...
 
void ENETOTAL_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree ENETOTAL variables Tree More...
 
void COINCBOARD_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree COINCBOARD variables Tree More...
 
void LASEROBJ_addBranch (void)
 
void TRIGGER_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER variables More...
 
void MUON_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree MUON variables More...
 
void ECAL_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree ECAL variables More...
 
void QDC_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree QDC variables More...
 
void LASER_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree LASER variables More...
 
void ADDER_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree ADDER variables More...
 
void CISPAR_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variables More...
 
void BEAM_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree BEAM variables More...
 
void DIGI_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variables //////////////////////////////////////////////////////////////////////////// More...
 
void FELIX_clearBranch (void)
 
void HIT_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Clear Tree HIT variables //////////////////////////////////////////////////////////////////////////// More...
 
void ENETOTAL_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree ENETOTAL variables More...
 
void COINCBOARD_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree COINCBOARD variables More...
 
void LASEROBJ_clearBranch (void)
 
template<typename T >
void clear_init_minus1 (std::vector< T > &vec)
 
template<typename T , size_t N>
void clear_init_minus1 (std::vector< std::array< T, N >> &vec)
 
template<typename T , size_t N>
void clear_init_zero (std::vector< std::array< T, N >> &vec)
 
void clear_samples (std::vector< std::unique_ptr< int[]>> &vec, const std::vector< int > &nsamples, int nchan=MAX_CHAN)
 
int digiChannel2PMT (int fragType, int chan)
 
short CheckDMUFormat (uint32_t header)
 bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0 More...
 
short CheckDMUParity (uint32_t header)
 Parity of the DMU header should be odd. More...
 
void checkIsPropertySetup (float property, const std::string &name)
 
void setupPropertyDefaultValue (float property, float defaultValue, const std::string &name)
 
void setupBeamChambersBeforeTB2015 (void)
 
void setupBeamChambersTB2015 (void)
 
void setupBeamChambersTB2016_2020 (void)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadCondHandleKey< TileSamplingFraction > m_samplingFractionKey
 Name of TileSamplingFraction in condition store. More...
 
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
 
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerFlxKey
 
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_flatRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_flxFitRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_flxOptRawChannelContainerKey
 
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
 
SG::ReadHandleKey< TileHitContainer > m_hitContainerKey
 
SG::ReadHandleKey< TileHitVector > m_hitVectorKey
 
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
 
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
 
ToolHandle< TileRawChannelBuilderFlatFilter > m_adderFilterAlgTool
 
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
 
Gaudi::Property< bool > m_calibrateEnergy {this, "CalibrateEnergy", true, "Calibrate energy"}
 
Gaudi::Property< bool > m_useDspUnits {this, "UseDspUnits", false, "Use DSP untis"}
 
Gaudi::Property< int > m_finalUnit {this, "OfflineUnits", TileRawChannelUnit::MegaElectronVolts, "Calibrate everything to this level"}
 
Gaudi::Property< bool > m_calibMode {this, "CalibMode", false, "If data should be put in calib mode"}
 
Gaudi::Property< bool > m_unpackAdder {this, "UnpackAdder", false, "Unpack adder"}
 
Gaudi::Property< bool > m_completeNtuple {this, "CompleteNtuple", true, "Complete the ntuple"}
 
Gaudi::Property< bool > m_bsInput {this, "BSInput", true, "Bytestream input"}
 
Gaudi::Property< bool > m_pmtOrder {this, "PMTOrder", true, "Change channel ordering to pmt ordering in the ntuple"}
 
Gaudi::Property< int > m_nSamples {this, "NSamples", NOT_SETUP, "Number of samples"}
 
Gaudi::Property< int > m_nSamplesFlx {this, "NSamplesFelix", NOT_SETUP, "Number of samples for FELIX"}
 
Gaudi::Property< unsigned int > m_nDrawers {this, "NDrawers", 6, "Number of drawers"}
 
Gaudi::Property< unsigned int > m_nDrawersFlx {this, "NDrawersFelix", 0, "Number of drawers for FELIX"}
 
Gaudi::Property< int > m_TBperiod {this, "TBperiod", 2016, "Tuned for 2016 testbeam by default"}
 
Gaudi::Property< int > m_eventsPerFile {this, "EventsPerFile", 200000, "Number of events per file"}
 
Gaudi::Property< Long64_t > m_treeSize {this, "TreeSize", 16000000000LL, "Size of tree"}
 
Gaudi::Property< std::string > m_streamName {this, "StreamName", "AANT", "Name of the output stream"}
 
Gaudi::Property< std::string > m_ntupleID {this, "NTupleID", "h1000", "Name of the ntuple ID"}
 
Gaudi::Property< std::vector< std::string > > m_rosName {this, "rosName", {"B", "A", "C", "D", "E"}, "Name of arrays in ntuple for different ROSes"}
 
Gaudi::Property< std::vector< std::string > > m_drawerList {this, "drawerList", {"-1"}, "List of frag IDs in correct order; Setup drawer list from data"}
 
Gaudi::Property< std::vector< int > > m_drawerType {this, "drawerType", {}, "Type of every drawer 1-4: B+, B-, EB+, EB-; Take drawer type from Frag ID (doesn't work for 2003)"}
 
Gaudi::Property< std::vector< std::string > > m_beamFragList {this, "beamFragList", {}, "List of beam frag IDs to store in the ntuple"}
 
Gaudi::Property< float > m_beamBN2X1 {this, "BN2X1", 0.0, "Params for Beam TDC: Beam chamber: -2"}
 
Gaudi::Property< float > m_beamBN2X2 {this, "BN2X2", 0.2, "Params for Beam TDC: Beam chamber: -2"}
 
Gaudi::Property< float > m_beamBN2Y1 {this, "BN2Y1", 0.0, "Params for Beam TDC: Beam chamber: -2"}
 
Gaudi::Property< float > m_beamBN2Y2 {this, "BN2Y2", 0.2, "Params for Beam TDC: Beam chamber: -2"}
 
Gaudi::Property< float > m_beamBN1X1 {this, "BN1X1", 0.0, "Params for Beam TDC: Beam chamber: -1"}
 
Gaudi::Property< float > m_beamBN1X2 {this, "BN1X2", 0.2, "Params for Beam TDC: Beam chamber: -1"}
 
Gaudi::Property< float > m_beamBN1Y1 {this, "BN1Y1", 0.0, "Params for Beam TDC: Beam chamber: -1"}
 
Gaudi::Property< float > m_beamBN1Y2 {this, "BN1Y2", 0.2, "Params for Beam TDC: Beam chamber: -1"}
 
Gaudi::Property< float > m_beamBC0X1 {this, "BC0X1", 0.0, "Params for Beam TDC: Beam chamber: 0"}
 
Gaudi::Property< float > m_beamBC0X2 {this, "BC0X2", 0.2, "Params for Beam TDC: Beam chamber: 0"}
 
Gaudi::Property< float > m_beamBC0Y1 {this, "BC0Y1", 0.0, "Params for Beam TDC: Beam chamber: 0"}
 
Gaudi::Property< float > m_beamBC0Y2 {this, "BC0Y2", 0.2, "Params for Beam TDC: Beam chamber: 0"}
 
Gaudi::Property< float > m_beamBC0Z {this, "BC0Z", 17138.0, "Params for Beam TDC: Beam chamber: 0"}
 
Gaudi::Property< float > m_beamBC1X1 {this, "BC1X1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC1X2 {this, "BC1X2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC1Y1 {this, "BC1Y1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC1Y2 {this, "BC1Y2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC1Z {this, "BC1Z", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC1Z_0 {this, "BC1Z_0", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC1Z_90 {this, "BC1Z_90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC1Z_min90 {this, "BC1Z_min90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
 
Gaudi::Property< float > m_beamBC2X1 {this, "BC2X1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_beamBC2X2 {this, "BC2X2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_beamBC2Y1 {this, "BC2Y1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_beamBC2Y2 {this, "BC2Y2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_beamBC2Z {this, "BC2Z", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_beamBC2Z_0 {this, "BC2Z_0", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_beamBC2Z_90 {this, "BC2Z_90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_beamBC2Z_min90 {this, "BC2Z_min90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
 
Gaudi::Property< float > m_radius {this, "Radius", 2280.0, "Inner radius of calo, for CTB 2004 only"}
 
Gaudi::Property< std::string > m_etaFileName {this, "EtaFileName", "TileEtaCTB.txt", "File name with ETA, for CTB 2004 only"}
 
ServiceHandle< ITHistSvc > m_thistSvc
 
TTree * m_ntuplePtr {nullptr}
 
bool m_ntupleCreated
 
int m_evtNr
 
int m_evTime
 
int m_run
 
int m_evt
 
int m_trigType
 
int m_dspFlags
 
std::vector< int > m_l1ID
 
std::vector< int > m_l1Type
 
std::vector< int > m_evBCID
 
std::vector< int > m_evType
 
std::vector< int > m_frBCID
 
float m_muBackHit
 
float m_muBackSum
 
std::array< float, 14 > m_muBack
 
std::array< float, 2 > m_muCalib
 
std::array< float, 8 > m_ecal
 
std::array< uint32_t, 33 > m_qdc
 
int m_las_BCID
 
int m_las_Filt
 
double m_las_ReqAmp
 
double m_las_MeasAmp
 
int m_las_D1_ADC
 
int m_las_D2_ADC
 
int m_las_D3_ADC
 
int m_las_D4_ADC
 
double m_las_D1_Ped
 
double m_las_D2_Ped
 
double m_las_D3_Ped
 
double m_las_D4_Ped
 
double m_las_D1_Ped_RMS
 
double m_las_D2_Ped_RMS
 
double m_las_D3_Ped_RMS
 
double m_las_D4_Ped_RMS
 
double m_las_D1_Alpha
 
double m_las_D2_Alpha
 
double m_las_D3_Alpha
 
double m_las_D4_Alpha
 
double m_las_D1_Alpha_RMS
 
double m_las_D2_Alpha_RMS
 
double m_las_D3_Alpha_RMS
 
double m_las_D4_Alpha_RMS
 
double m_las_D1_AlphaPed
 
double m_las_D2_AlphaPed
 
double m_las_D3_AlphaPed
 
double m_las_D4_AlphaPed
 
double m_las_D1_AlphaPed_RMS
 
double m_las_D2_AlphaPed_RMS
 
double m_las_D3_AlphaPed_RMS
 
double m_las_D4_AlphaPed_RMS
 
int m_las_PMT1_ADC
 
int m_las_PMT2_ADC
 
int m_las_PMT1_TDC
 
int m_las_PMT2_TDC
 
double m_las_PMT1_Ped
 
double m_las_PMT2_Ped
 
double m_las_PMT1_Ped_RMS
 
double m_las_PMT2_Ped_RMS
 
double m_las_Temperature
 
int m_lasFlag
 
float m_las0
 
float m_las1
 
float m_las2
 
float m_las3
 
std::array< float, 4 > m_lasExtra
 
int m_commonPU
 
int ** m_adder
 
std::array< float, 16 > m_eneAdd
 
std::array< float, 16 > m_timeAdd
 
int m_cispar [16]
 
uint32_t m_s1cou
 
uint32_t m_s2cou
 
uint32_t m_s3cou
 
uint32_t m_cher1
 
uint32_t m_cher2
 
uint32_t m_cher3
 
uint32_t m_muTag
 
uint32_t m_muHalo
 
uint32_t m_muVeto
 
int m_s2extra
 
int m_s3extra
 
int m_sc1
 
int m_sc2
 
std::array< int, 16 > m_tof
 
std::array< int, 16 > m_btdc1
 
std::array< int, 16 > m_btdc2
 
std::array< int, 16 > m_scaler
 
std::vector< std::vector< int > > * m_btdc
 
int m_tjitter
 
int m_tscTOF
 
int m_btdcNhit [16]
 
int m_btdcNchMultiHit [2]
 
float m_xChN2
 
float m_yChN2
 
float m_xChN1
 
float m_yChN1
 
float m_xCha0
 
float m_yCha0
 
float m_xCha1
 
float m_yCha1
 
float m_xCha2
 
float m_yCha2
 
float m_xCha1_0
 
float m_yCha1_0
 
float m_xCha2_0
 
float m_yCha2_0
 
float m_xImp
 
float m_yImp
 
float m_xImp_0
 
float m_yImp_0
 
float m_xImp_90
 
float m_yImp_90
 
float m_xImp_min90
 
float m_yImp_min90
 
std::vector< int > m_evtVec
 
std::vector< short > m_rodBCIDVec
 
std::vector< short > m_sizeVec
 
std::vector< int > m_evtflxVec
 
std::vector< short > m_rodBCIDflxVec
 
std::vector< short > m_sizeflxVec
 
std::vector< std::array< int, MAX_CHAN > > m_gainflxVec
 
std::vector< std::unique_ptr< int[]> > m_sampleflxVec
 
std::vector< std::array< int, MAX_DMU > > m_bcidVec
 
std::vector< std::array< uint32_t, MAX_DMU > > m_DMUheaderVec
 
std::vector< std::array< short, MAX_DMU > > m_DMUformatErrVec
 
std::vector< std::array< short, MAX_DMU > > m_DMUparityErrVec
 
std::vector< std::array< short, MAX_DMU > > m_DMUmemoryErrVec
 
std::vector< std::array< short, MAX_DMU > > m_DMUDstrobeErrVec
 
std::vector< std::array< short, MAX_DMU > > m_DMUSstrobeErrVec
 
std::vector< std::array< short, MAX_DMU > > m_DMUHeadparityErrVec
 
std::vector< std::array< short, MAX_DMU > > m_DMUDataparityErrVec
 
std::vector< std::array< int, 2 > > m_dmuMaskVec
 
std::vector< std::array< int, 2 > > m_slinkCRCVec
 
std::vector< std::array< int, MAX_CHAN > > m_gainVec
 
std::vector< std::unique_ptr< int[]> > m_sampleVec
 
std::vector< std::array< int, MAX_DMU > > m_feCRCVec
 
std::vector< std::array< int, MAX_DMU > > m_rodCRCVec
 
std::vector< std::array< float, MAX_CHAN > > m_eneVec
 
std::vector< std::array< float, MAX_CHAN > > m_timeVec
 
std::vector< std::array< float, MAX_CHAN > > m_pedFlatVec
 
std::vector< std::array< float, MAX_CHAN > > m_chi2FlatVec
 
std::vector< std::array< float, MAX_CHAN > > m_efitVec
 
std::vector< std::array< float, MAX_CHAN > > m_tfitVec
 
std::vector< std::array< float, MAX_CHAN > > m_pedfitVec
 
std::vector< std::array< float, MAX_CHAN > > m_chi2Vec
 
std::vector< std::array< float, MAX_CHAN > > m_efitcVec
 
std::vector< std::array< float, MAX_CHAN > > m_tfitcVec
 
std::vector< std::array< float, MAX_CHAN > > m_pedfitcVec
 
std::vector< std::array< float, MAX_CHAN > > m_chi2cVec
 
std::vector< std::array< float, MAX_CHAN > > m_eOptVec
 
std::vector< std::array< float, MAX_CHAN > > m_tOptVec
 
std::vector< std::array< float, MAX_CHAN > > m_pedOptVec
 
std::vector< std::array< float, MAX_CHAN > > m_chi2OptVec
 
std::vector< std::array< float, MAX_CHAN > > m_eDspVec
 
std::vector< std::array< float, MAX_CHAN > > m_tDspVec
 
std::vector< std::array< float, MAX_CHAN > > m_chi2DspVec
 
std::vector< std::array< float, MAX_CHAN > > m_eflxfitVec
 
std::vector< std::array< float, MAX_CHAN > > m_tflxfitVec
 
std::vector< std::array< float, MAX_CHAN > > m_chi2flxfitVec
 
std::vector< std::array< float, MAX_CHAN > > m_pedflxfitVec
 
std::vector< std::array< float, MAX_CHAN > > m_eflxoptVec
 
std::vector< std::array< float, MAX_CHAN > > m_tflxoptVec
 
std::vector< std::array< float, MAX_CHAN > > m_chi2flxoptVec
 
std::vector< std::array< float, MAX_CHAN > > m_pedflxoptVec
 
std::vector< short > m_ROD_GlobalCRCVec
 
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUBCIDVec
 
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUmemoryErrVec
 
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUSstrobeErrVec
 
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDstrobeErrVec
 
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUHeadformatErrVec
 
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDataformatErrVec
 
std::vector< std::array< short, 2 > > m_ROD_DMUMaskVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdL1idflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdBcidflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdModuleflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunTypeflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedLoflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedHiflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeTimeflxVec
 
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdCapacitorflxVec
 
std::array< float, 4 > m_LarEne
 
std::array< float, 3 > m_BarEne
 
std::array< float, 3 > m_ExtEne
 
std::array< float, 3 > m_GapEne
 
std::array< unsigned int, 96 > m_coincTrig1
 
std::array< unsigned int, 96 > m_coincTrig2
 
std::array< unsigned int, 96 > m_coincTrig3
 
std::array< unsigned int, 96 > m_coincTrig4
 
std::array< unsigned int, 96 > m_coincTrig5
 
std::array< unsigned int, 96 > m_coincTrig6
 
std::array< unsigned int, 96 > m_coincTrig7
 
std::array< unsigned int, 96 > m_coincTrig8
 
int m_coincFlag1
 
int m_coincFlag2
 
int m_coincFlag3
 
int m_coincFlag4
 
int m_coincFlag5
 
int m_coincFlag6
 
int m_coincFlag7
 
int m_coincFlag8
 
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerMap
 
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerFlxMap
 
bool m_beamIdList [32]
 
int m_runNumber
 
float m_eta
 
float m_theta
 
std::vector< std::array< float, MAX_CHAN > > m_ehitVec
 
std::vector< std::array< float, MAX_CHAN > > m_thitVec
 
std::vector< std::array< float, MAX_CHAN > > m_ehitCnt
 
std::vector< std::array< float, MAX_CHAN > > m_thitCnt
 
bool m_calibrateEnergyThisEvent
 
TileRawChannelUnit::UNIT m_rchUnit
 Unit for TileRawChannels (ADC, pCb, MeV) More...
 
TileRawChannelUnit::UNIT m_dspUnit
 Unit for TileRawChannels in DSP. More...
 
const TileID * m_tileID {nullptr}
 
const TileHWID * m_tileHWID {nullptr}
 
const TileCablingService * m_cabling {nullptr}
 
std::map< int, int > m_nSamplesInDrawerMap
 
std::map< int, int > m_nSamplesFlxInDrawerMap
 
std::vector< int > m_nSamplesInDrawer
 
std::vector< int > m_nSamplesFlxInDrawer
 
bool m_saveFelixData {false}
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

class to produce TileCal commissioning ntuples

Definition at line 89 of file TileTBAANtuple.h.

Member Typedef Documentation

◆ drawerMap_iterator

typedef std::map<unsigned int, unsigned int, std::less<unsigned int> >::iterator TileTBAANtuple::drawerMap_iterator
private

Definition at line 605 of file TileTBAANtuple.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
private
Enumerator
NOT_SETUP 

Definition at line 105 of file TileTBAANtuple.h.

105 {NOT_SETUP = -9999};

◆ anonymous enum

anonymous enum
private
Enumerator
MAX_MINIDRAWER 
MAX_CHAN 
MAX_DMU 

Definition at line 106 of file TileTBAANtuple.h.

106 {MAX_MINIDRAWER = 4, MAX_CHAN = 48, MAX_DMU = 16};

Constructor & Destructor Documentation

◆ TileTBAANtuple()

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

Definition at line 82 of file TileTBAANtuple.cxx.

83  : AthAlgorithm(name, pSvcLocator)
84  , m_thistSvc("THistSvc", name)
85  , m_ntupleCreated(false)
86  , m_evTime(0)
87  , m_run(0)
88  , m_evt(0)
89  , m_trigType(0)
90  , m_dspFlags(0)
91  , m_muBackHit(0.0F)
92  , m_muBackSum(0.0F)
93  , m_las_BCID(0)
94  , m_las_Filt(0)
95  , m_las_ReqAmp(0.0)
96  , m_las_MeasAmp(0.0)
97  , m_las_D1_ADC(0)
98  , m_las_D2_ADC(0)
99  , m_las_D3_ADC(0)
100  , m_las_D4_ADC(0)
101  , m_las_D1_Ped(0.0)
102  , m_las_D2_Ped(0.0)
103  , m_las_D3_Ped(0.0)
104  , m_las_D4_Ped(0.0)
105  , m_las_D1_Ped_RMS(0.0)
106  , m_las_D2_Ped_RMS(0.0)
107  , m_las_D3_Ped_RMS(0.0)
108  , m_las_D4_Ped_RMS(0.0)
109  , m_las_D1_Alpha(0.0)
110  , m_las_D2_Alpha(0.0)
111  , m_las_D3_Alpha(0.0)
112  , m_las_D4_Alpha(0.0)
113  , m_las_D1_Alpha_RMS(0.0)
114  , m_las_D2_Alpha_RMS(0.0)
115  , m_las_D3_Alpha_RMS(0.0)
116  , m_las_D4_Alpha_RMS(0.0)
117  , m_las_D1_AlphaPed(0.0)
118  , m_las_D2_AlphaPed(0.0)
119  , m_las_D3_AlphaPed(0.0)
120  , m_las_D4_AlphaPed(0.0)
121  , m_las_D1_AlphaPed_RMS(0.0)
122  , m_las_D2_AlphaPed_RMS(0.0)
123  , m_las_D3_AlphaPed_RMS(0.0)
124  , m_las_D4_AlphaPed_RMS(0.0)
125  , m_las_PMT1_ADC(0)
126  , m_las_PMT2_ADC(0)
127  , m_las_PMT1_TDC(0)
128  , m_las_PMT2_TDC(0)
129  , m_las_PMT1_Ped(0.0)
130  , m_las_PMT2_Ped(0.0)
131  , m_las_PMT1_Ped_RMS(0.0)
132  , m_las_PMT2_Ped_RMS(0.0)
133  , m_las_Temperature(0.0)
134  , m_lasFlag(0)
135  , m_las0(0.0F)
136  , m_las1(0.0F)
137  , m_las2(0.0F)
138  , m_las3(0.0F)
139  , m_commonPU(0)
140  , m_adder(0)
141  , m_s1cou(0)
142  , m_s2cou(0)
143  , m_s3cou(0)
144  , m_cher1(0)
145  , m_cher2(0)
146  , m_cher3(0)
147  , m_muTag(0)
148  , m_muHalo(0)
149  , m_muVeto(0)
150  , m_s2extra(0)
151  , m_s3extra(0)
152  , m_sc1(0)
153  , m_sc2(0)
154  , m_btdc(0)
155  , m_tjitter(0)
156  , m_tscTOF(0)
157  , m_xChN2(0.0F)
158  , m_yChN2(0.0F)
159  , m_xChN1(0.0F)
160  , m_yChN1(0.0F)
161  , m_xCha0(0.0F)
162  , m_yCha0(0.0F)
163  , m_xCha1(0.0F)
164  , m_yCha1(0.0F)
165  , m_xCha2(0.0F)
166  , m_yCha2(0.0F)
167  , m_xCha1_0(0.0F)
168  , m_yCha1_0(0.0F)
169  , m_xCha2_0(0.0F)
170  , m_yCha2_0(0.0F)
171  , m_xImp(0.0F)
172  , m_yImp(0.0F)
173  , m_xImp_0(0.0F)
174  , m_yImp_0(0.0F)
175  , m_xImp_90(0.0F)
176  , m_yImp_90(0.0F)
177  , m_xImp_min90(0.0F)
178  , m_yImp_min90(0.0F)
179  , m_coincFlag1(0)
180  , m_coincFlag2(0)
181  , m_coincFlag3(0)
182  , m_coincFlag4(0)
183  , m_coincFlag5(0)
184  , m_coincFlag6(0)
185  , m_coincFlag7(0)
186  , m_coincFlag8(0)
187  , m_calibrateEnergyThisEvent(false)
188  , m_rchUnit(TileRawChannelUnit::MegaElectronVolts)
189  , m_dspUnit(TileRawChannelUnit::ADCcounts)
190 {
191 
192  char frg[6] = "0x000";
193  m_beamFragList.clear();
194  for (unsigned int i=0; i<sizeof(m_beamIdList)/sizeof(bool); ++i) {
195  m_beamIdList[i] = false;
196  // no coins trig by default (this is the case for 2004)
197  if (i <= ECAL_ADC_FRAG || i >= COMMON_ADC1_FRAG ) {
198  sprintf(frg,"0x%3.3x",i);
199  m_beamFragList.value().push_back((std::string)frg);
200  }
201  }
202 
203  m_eta = 0.0;
204  m_theta = 0.0;
205  m_runNumber = 0;
206  m_evtNr = -1;
207 }

◆ ~TileTBAANtuple()

virtual TileTBAANtuple::~TileTBAANtuple ( )
virtualdefault

Member Function Documentation

◆ ADDER_addBranch()

void TileTBAANtuple::ADDER_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree ADDER variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2868 of file TileTBAANtuple.cxx.

2868  {
2869 
2870  if (m_unpackAdder) {
2871  if (m_beamIdList[ADD_FADC_FRAG]) {
2872  m_adder = (int**) malloc(16 * sizeof(int *));
2873  m_adder[0] = (int*) malloc(16 * 16 * sizeof(int));
2874  for (int j = 1; j < 16; j++) {
2875  m_adder[j] = m_adder[0] + j * 16;
2876  }
2877 
2878  m_ntuplePtr->Branch("Adder", *m_adder, "m_adder[16][16]/I");
2879  m_ntuplePtr->Branch("EneAdd", &m_eneAdd, "m_eneAdd[16]/F");
2880  m_ntuplePtr->Branch("TimeAdd", &m_timeAdd, "m_timeAdd[16]/F");
2881  }
2882  }
2883 }

◆ ADDER_clearBranch()

void TileTBAANtuple::ADDER_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree ADDER variables

////////////////////////////////////////////////////////////////////////////

Definition at line 2891 of file TileTBAANtuple.cxx.

2892 {
2893 
2894 
2895 }

◆ BEAM_addBranch()

void TileTBAANtuple::BEAM_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree BEAM variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2929 of file TileTBAANtuple.cxx.

2929  {
2930 
2931  if (((m_TBperiod >= 2015 || m_unpackAdder) && m_beamIdList[BEAM_ADC_FRAG])
2932  || ((!m_unpackAdder || m_TBperiod >= 2022) && m_beamIdList[COMMON_ADC1_FRAG])) {
2933 
2934  m_ntuplePtr->Branch("S1cou", &m_s1cou, "S1cou/S");
2935  m_ntuplePtr->Branch("S2cou", &m_s2cou, "S2cou/S");
2936  if (m_TBperiod >= 2016 && m_TBperiod < 2022) {
2937  m_ntuplePtr->Branch("Cher3", &m_s3cou, "Cher3/S"); // dropped S3 in favor of Cher3 in September 2016 TB
2938  // m_ntuplePtr->Branch("SpmFinger", &m_muVeto, "SmpFinger/S"); // muVeto replaced by SPM for testing
2939  m_ntuplePtr->Branch("SiPM1", &m_muTag, "SiPM1/S"); // muTag replaced by SiPM1 for testing
2940  m_ntuplePtr->Branch("SiPM2", &m_muHalo, "SiPM2/S");// muHalo repalce by SiPM1 for testing
2941  } else {
2942  m_ntuplePtr->Branch("S3cou", &m_s3cou, "S3cou/S");
2943  }
2944 
2945  m_ntuplePtr->Branch("Cher1", &m_cher1, "Cher1/S");
2946  m_ntuplePtr->Branch("Cher2", &m_cher2, "Cher2/S");
2947  if (m_TBperiod >= 2022) {
2948  m_ntuplePtr->Branch("Cher3", &m_cher3, "Cher3/S");
2949  }
2950 
2951  if (m_TBperiod < 2015) {
2952  m_ntuplePtr->Branch("MuTag", &m_muTag, "MuTag/S");
2953  m_ntuplePtr->Branch("MuHalo", &m_muHalo, "MuHalo/S");
2954  m_ntuplePtr->Branch("MuVeto", &m_muVeto, "MuVeto/S");
2955  //} else if (m_TBperiod == 2015) {
2956  // nothing
2957  } else if (m_TBperiod >= 2016) {
2958  m_ntuplePtr->Branch("SCalo1", &m_muTag, "SCalo1/S");
2959  m_ntuplePtr->Branch("SCalo2", &m_muHalo, "SCalo2/S");
2960  //m_ntuplePtr->Branch("SCalo3", &m_muVeto, "SCalo3/S");
2961  }
2962  }
2963 
2964  if (m_TBperiod >= 2015) {
2965  if (m_beamIdList[COMMON_TDC1_FRAG] || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2966  m_btdc = new std::vector<std::vector<int> >(16);
2967  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
2968  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
2969  m_ntuplePtr->Branch("btdc", &m_btdc);
2970  m_ntuplePtr->Branch("tjitter", &m_tjitter, "tjitter/I");
2971  m_ntuplePtr->Branch("tscTOF", &m_tscTOF, "tscTOF/I");
2972  m_ntuplePtr->Branch("btdcNhit", m_btdcNhit, "btdcNhit[16]/I");
2973  m_ntuplePtr->Branch("btdcNchMultiHit", m_btdcNchMultiHit, "btdcNchMultiHit[2]/I");
2974  }
2975  if (m_beamIdList[COMMON_TOF_FRAG]) {
2976  m_ntuplePtr->Branch("tof", &m_tof, "m_tof[16]/I");
2977  }
2978  if (m_beamIdList[COMMON_PTN_FRAG]) {
2979  m_ntuplePtr->Branch("scaler", &m_scaler, "m_scaler[16]/I");
2980  }
2981  } else if (!m_unpackAdder) {
2982  if (m_beamIdList[COMMON_ADC2_FRAG]) {
2983  m_ntuplePtr->Branch("S2extra", &m_s2extra, "S2extra/S");
2984  m_ntuplePtr->Branch("S2cou", &m_s3extra, "S3extra/S");
2985  }
2986  if (m_beamIdList[BEAM_ADC_FRAG]) {
2987  m_ntuplePtr->Branch("SC1", &m_sc1, "SC1/S");
2988  m_ntuplePtr->Branch("SC2", &m_sc2, "SC2/S");
2989  }
2990  if (m_beamIdList[COMMON_PTN_FRAG]) {
2991  m_ntuplePtr->Branch("pu", &m_commonPU, "pu/S");
2992  }
2993  if (m_beamIdList[COMMON_TOF_FRAG]) {
2994  m_ntuplePtr->Branch("tof", &m_tof, "m_tof[8]/I");
2995  }
2996  if (m_beamIdList[COMMON_TDC1_FRAG]) {
2997  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1/I");
2998  }
2999  if (m_beamIdList[COMMON_TDC2_FRAG]) {
3000  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2/I");
3001  }
3002 
3003  if (m_beamIdList[COMMON_TDC1_FRAG]) {
3004  m_ntuplePtr->Branch("XchN2", &m_xChN2, "XchN2/F");
3005  m_ntuplePtr->Branch("YchN2", &m_yChN2, "YchN2/F");
3006  m_ntuplePtr->Branch("XchN1", &m_xChN1, "XchN1/F");
3007  m_ntuplePtr->Branch("YchN1", &m_yChN1, "YchN1/F");
3008  }
3009  if (m_beamIdList[COMMON_TDC2_FRAG]) {
3010  m_ntuplePtr->Branch("Xcha0", &m_xCha0, "Xcha0/F");
3011  m_ntuplePtr->Branch("Ycha0", &m_yCha0, "Ycha0/F");
3012  }
3013  } else {
3014  if (m_beamIdList[BEAM_TDC_FRAG]) {
3015  m_ntuplePtr->Branch("btdc1", &m_btdc1, "m_btdc1[16]/I");
3016  m_ntuplePtr->Branch("btdc2", &m_btdc2, "m_btdc2[16]/I");
3017  }
3018  }
3019 
3020  if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
3021  || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
3022  || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
3023  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
3024 
3025  m_ntuplePtr->Branch("Xcha1", &m_xCha1, "Xcha1/F");
3026  m_ntuplePtr->Branch("Ycha1", &m_yCha1, "Ycha1/F");
3027  m_ntuplePtr->Branch("Xcha2", &m_xCha2, "Xcha2/F");
3028  m_ntuplePtr->Branch("Ycha2", &m_yCha2, "Ycha2/F");
3029  m_ntuplePtr->Branch("Xcha1_0", &m_xCha1_0, "Xcha1_0/F");
3030  m_ntuplePtr->Branch("Ycha1_0", &m_yCha1_0, "Ycha1_0/F");
3031  m_ntuplePtr->Branch("Xcha2_0", &m_xCha2_0, "Xcha2_0/F");
3032  m_ntuplePtr->Branch("Ycha2_0", &m_yCha2_0, "Ycha2_0/F");
3033  m_ntuplePtr->Branch("Ximp", &m_xImp, "Ximp/F");
3034  m_ntuplePtr->Branch("Yimp", &m_yImp, "Yimp/F");
3035  m_ntuplePtr->Branch("Ximp_0", &m_xImp_0, "Ximp_0/F");
3036  m_ntuplePtr->Branch("Yimp_0", &m_yImp_0, "Yimp_0/F");
3037  m_ntuplePtr->Branch("Ximp_90", &m_xImp_90, "Ximp_90/F");
3038  m_ntuplePtr->Branch("Yimp_90", &m_yImp_90, "Yimp_90/F");
3039  m_ntuplePtr->Branch("Ximp_min90", &m_xImp_min90, "Ximp_min90/F");
3040  m_ntuplePtr->Branch("Yimp_min90", &m_yImp_min90, "Yimp_min90/F");
3041  }
3042 
3043 }

◆ BEAM_clearBranch()

void TileTBAANtuple::BEAM_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree BEAM variables

////////////////////////////////////////////////////////////////////////////

Definition at line 3051 of file TileTBAANtuple.cxx.

3051  {
3052 
3053  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
3054  || (!m_unpackAdder && m_beamIdList[COMMON_ADC1_FRAG])) {
3055 
3056  m_s1cou = 0;
3057  m_s2cou = 0;
3058  m_s3cou = 0;
3059  m_cher1 = 0;
3060  m_cher2 = 0;
3061  m_cher3 = 0;
3062  m_muTag = 0;
3063  m_muHalo = 0;
3064  m_muVeto = 0;
3065  }
3066  if (!m_unpackAdder) {
3067  if (m_beamIdList[COMMON_ADC2_FRAG]) {
3068 
3069  m_s2extra = 0;
3070  m_s3extra = 0;
3071  }
3072  if (m_beamIdList[BEAM_ADC_FRAG]) {
3073  m_sc1 = 0;
3074  m_sc2 = 0;
3075  }
3076  if (m_beamIdList[COMMON_PTN_FRAG]) {
3077  m_commonPU = 0;
3078  }
3079  if (m_beamIdList[COMMON_TDC1_FRAG]) {
3080  m_xChN2 = 0.;
3081  m_yChN2 = 0.;
3082  m_xChN1 = 0.;
3083  m_yChN1 = 0.;
3084  }
3085  if (m_beamIdList[COMMON_TDC2_FRAG]) {
3086  m_xCha0 = 0.;
3087  m_yCha0 = 0.;
3088  }
3089  }
3090 
3091  if ((m_TBperiod >= 2015 && m_beamIdList[COMMON_TDC1_FRAG])
3092  || (m_unpackAdder && m_beamIdList[BEAM_TDC_FRAG])
3093  || (!m_unpackAdder && m_beamIdList[COMMON_TDC2_FRAG])
3094  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
3095 
3096  m_xCha1 = 0.;
3097  m_yCha1 = 0.;
3098  m_xCha2 = 0.;
3099  m_yCha2 = 0.;
3100  m_xCha1_0 = 0.;
3101  m_yCha1_0 = 0.;
3102  m_xCha2_0 = 0.;
3103  m_yCha2_0 = 0.;
3104  m_xImp = 0.;
3105  m_yImp = 0.;
3106  }
3107 
3108  m_muBack.fill(0.0F);
3109 
3110  for (int i=0; i<16; i+=2) {
3111  m_tof[i] = +0xFFFF;
3112  m_tof[i+1] = -0xFFFF;
3113  }
3114 
3115  for (int i=0; i<16; i+=2) {
3116  m_btdc1[i] = +0xFFFF;
3117  m_btdc1[i+1] = -0xFFFF;
3118  }
3119 
3120  for (int i=0; i<16; i+=2) {
3121  m_btdc2[i] = +0xFFFF;
3122  m_btdc2[i+1] = -0xFFFF;
3123  }
3124 
3125  if (m_btdc) {
3126  for (std::vector<int>& btdc_amplitudes : *m_btdc) {
3127  btdc_amplitudes.clear();
3128  }
3129  }
3130 
3131  memset(&m_scaler, 0, sizeof(m_scaler));
3132 
3133  memset(m_btdcNhit,0,sizeof(m_btdcNhit));
3134  memset(m_btdcNchMultiHit,0,sizeof(m_btdcNchMultiHit));
3135 }

◆ CheckDMUFormat()

short TileTBAANtuple::CheckDMUFormat ( uint32_t  header)
inlineprivate

bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0

Definition at line 302 of file TileTBAANtuple.h.

302  {
303  if (((header >> 31 & 0x1) == 1) && ((header >> 17 & 0x1) == 0))
304  return 0; // no error
305  else
306  return 1; //error
307  }

◆ CheckDMUParity()

short TileTBAANtuple::CheckDMUParity ( uint32_t  header)
inlineprivate

Parity of the DMU header should be odd.

Definition at line 311 of file TileTBAANtuple.h.

311  {
312  uint32_t parity(0);
313  for (int i = 0; i < 32; ++i)
314  parity += header >> i & 0x1;
315 
316  if ((parity % 2) == 1)
317  return 0; //no error
318  else
319  return 1; //error
320  }

◆ checkIsPropertySetup()

void TileTBAANtuple::checkIsPropertySetup ( float  property,
const std::string &  name 
)
inlineprivate

Definition at line 322 of file TileTBAANtuple.h.

322  {
323  if (property < NOT_SETUP) {
324  ATH_MSG_ERROR("The following property should be set up via JO: " << name);
325  }
326  }

◆ CISPAR_addBranch()

void TileTBAANtuple::CISPAR_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2903 of file TileTBAANtuple.cxx.

2903  {
2904 
2905  if (m_beamIdList[DIGI_PAR_FRAG & 0x1F]) {
2906 
2907  m_ntuplePtr->Branch("cispar", m_cispar, "cispar[16]/I");
2908  }
2909 }

◆ CISPAR_clearBranch()

void TileTBAANtuple::CISPAR_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variables

////////////////////////////////////////////////////////////////////////////

Definition at line 2917 of file TileTBAANtuple.cxx.

2918 {
2919  memset(m_cispar,-1,sizeof(m_cispar));
2920 }

◆ clear_init_minus1() [1/2]

template<typename T , size_t N>
void TileTBAANtuple::clear_init_minus1 ( std::vector< std::array< T, N >> &  vec)
private

Definition at line 3858 of file TileTBAANtuple.cxx.

3858  {
3859  for (std::array<T,N>& arr : vec) {
3860  std::fill(arr.begin(), arr.end(), static_cast<T>(-1));
3861  }
3862 }

◆ clear_init_minus1() [2/2]

template<typename T >
void TileTBAANtuple::clear_init_minus1 ( std::vector< T > &  vec)
private

Definition at line 3853 of file TileTBAANtuple.cxx.

3853  {
3854  std::fill(vec.begin(), vec.end(), static_cast<T>(-1));
3855 }

◆ clear_init_zero()

template<typename T , size_t N>
void TileTBAANtuple::clear_init_zero ( std::vector< std::array< T, N >> &  vec)
private

Definition at line 3865 of file TileTBAANtuple.cxx.

3865  {
3866  for (std::array<T,N>& arr : vec) {
3867  std::fill(arr.begin(), arr.end(), static_cast<T>(0));
3868  }
3869 }

◆ clear_samples()

void TileTBAANtuple::clear_samples ( std::vector< std::unique_ptr< int[]>> &  vec,
const std::vector< int > &  nsamples,
int  nchan = MAX_CHAN 
)
private

Definition at line 3871 of file TileTBAANtuple.cxx.

3872 {
3873  for (unsigned int i = 0; i < vec.size(); ++i) {
3874  std::fill(vec[i].get(), vec[i].get() + nsamples.at(i) * nchan, -1);
3875  }
3876 }

◆ COINCBOARD_addBranch()

void TileTBAANtuple::COINCBOARD_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree COINCBOARD variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 3171 of file TileTBAANtuple.cxx.

3171  {
3172  if (m_beamIdList[COIN_TRIG1_FRAG]) {
3173  m_ntuplePtr->Branch("CoincTrig1", &m_coincTrig1, "m_coincTrig1[96]/I");
3174  m_ntuplePtr->Branch("CoincFlag1", &m_coincFlag1, "CoincFlag1/I");
3175  }
3176 
3177  if (m_beamIdList[COIN_TRIG2_FRAG]) {
3178  m_ntuplePtr->Branch("CoincTrig2", &m_coincTrig2, "m_coincTrig2[96]/I");
3179  m_ntuplePtr->Branch("CoincFlag2", &m_coincFlag2, "CoincFlag2/I");
3180  }
3181 
3182  if (m_beamIdList[COIN_TRIG3_FRAG]) {
3183  m_ntuplePtr->Branch("CoincTrig3", &m_coincTrig3, "m_coincTrig3[96]/I");
3184  m_ntuplePtr->Branch("CoincFlag3", &m_coincFlag3, "CoincFlag3/I");
3185  }
3186 
3187  if (m_beamIdList[COIN_TRIG4_FRAG]) {
3188  m_ntuplePtr->Branch("CoincTrig4", &m_coincTrig4, "m_coincTrig4[96]/I");
3189  m_ntuplePtr->Branch("CoincFlag4", &m_coincFlag4, "CoincFlag4/I");
3190  }
3191  if (m_beamIdList[COIN_TRIG5_FRAG]) {
3192  m_ntuplePtr->Branch("CoincTrig5", &m_coincTrig5, "m_coincTrig5[96]/I");
3193  m_ntuplePtr->Branch("CoincFlag5", &m_coincFlag5, "CoincFlag5/I");
3194  }
3195 
3196  if (m_beamIdList[COIN_TRIG6_FRAG]) {
3197  m_ntuplePtr->Branch("CoincTrig6", &m_coincTrig6, "m_coincTrig6[96]/I");
3198  m_ntuplePtr->Branch("CoincFlag6", &m_coincFlag6, "CoincFlag6/I");
3199  }
3200 
3201  if (m_beamIdList[COIN_TRIG7_FRAG]) {
3202  m_ntuplePtr->Branch("CoincTrig7", &m_coincTrig7, "m_coincTrig7[96]/I");
3203  m_ntuplePtr->Branch("CoincFlag7", &m_coincFlag7, "CoincFlag7/I");
3204  }
3205 
3206  if (m_beamIdList[COIN_TRIG8_FRAG]) {
3207  m_ntuplePtr->Branch("CoincTrig8", &m_coincTrig8, "m_coincTrig8[96]/I");
3208  m_ntuplePtr->Branch("CoincFlag8", &m_coincFlag8, "CoincFlag8/I");
3209  }
3210 
3211 }

◆ COINCBOARD_clearBranch()

void TileTBAANtuple::COINCBOARD_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree COINCBOARD variables

////////////////////////////////////////////////////////////////////////////

Definition at line 3219 of file TileTBAANtuple.cxx.

3220 {
3221 
3222 
3223 
3224 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

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

◆ DIGI_addBranch()

void TileTBAANtuple::DIGI_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables Tree

////////////////////////////////////////////////////////////////////////////

Reserve is needed, because, if the vector is displaced, then the position declared in the Branch i not longer valid. Can be done a cleaner way?

Definition at line 3232 of file TileTBAANtuple.cxx.

3233 {
3234 
3235 
3238  m_bcidVec.reserve(MAX_DRAWERS);
3239  m_DMUheaderVec.reserve(MAX_DRAWERS);
3240  m_DMUformatErrVec.reserve(MAX_DRAWERS);
3241  m_DMUparityErrVec.reserve(MAX_DRAWERS);
3242  m_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3243  m_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3244  m_DMUHeadparityErrVec.reserve(MAX_DRAWERS);
3245  m_DMUDataparityErrVec.reserve(MAX_DRAWERS);
3246  m_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3247  m_dmuMaskVec.reserve(MAX_DRAWERS);
3248  m_slinkCRCVec.reserve(MAX_DRAWERS);
3249  m_gainVec.reserve(MAX_DRAWERS);
3250  m_sampleVec.reserve(MAX_DRAWERS);
3251  m_feCRCVec.reserve(MAX_DRAWERS);
3252  m_rodCRCVec.reserve(MAX_DRAWERS);
3253  m_eneVec.reserve(MAX_DRAWERS);
3254  m_timeVec.reserve(MAX_DRAWERS);
3255  m_pedFlatVec.reserve(MAX_DRAWERS);
3256  m_chi2FlatVec.reserve(MAX_DRAWERS);
3257  m_efitVec.reserve(MAX_DRAWERS);
3258  m_tfitVec.reserve(MAX_DRAWERS);
3259  m_pedfitVec.reserve(MAX_DRAWERS);
3260  m_chi2Vec.reserve(MAX_DRAWERS);
3261  m_efitcVec.reserve(MAX_DRAWERS);
3262  m_tfitcVec.reserve(MAX_DRAWERS);
3263  m_pedfitcVec.reserve(MAX_DRAWERS);
3264  m_chi2cVec.reserve(MAX_DRAWERS);
3265  m_eOptVec.reserve(MAX_DRAWERS);
3266  m_tOptVec.reserve(MAX_DRAWERS);
3267  m_pedOptVec.reserve(MAX_DRAWERS);
3268  m_chi2OptVec.reserve(MAX_DRAWERS);
3269  m_eDspVec.reserve(MAX_DRAWERS);
3270  m_tDspVec.reserve(MAX_DRAWERS);
3271  m_chi2DspVec.reserve(MAX_DRAWERS);
3272  m_ROD_GlobalCRCVec.reserve(MAX_DRAWERS);
3273  m_ROD_DMUBCIDVec.reserve(MAX_DRAWERS);
3274  m_ROD_DMUmemoryErrVec.reserve(MAX_DRAWERS);
3275  m_ROD_DMUSstrobeErrVec.reserve(MAX_DRAWERS);
3276  m_ROD_DMUDstrobeErrVec.reserve(MAX_DRAWERS);
3277  m_ROD_DMUHeadformatErrVec.reserve(MAX_DRAWERS);
3278  m_ROD_DMUDataformatErrVec.reserve(MAX_DRAWERS);
3279  m_ROD_DMUMaskVec.reserve(MAX_DRAWERS);
3280 
3281  std::ostringstream oss;
3282  oss << m_nSamples;
3283  std::string nSampStr=oss.str();
3284 
3285  unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3286 
3287  if (listSize > 0) {
3288 
3289  std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3290  std::vector<std::string> suffixArr;
3291  unsigned int length;
3292  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3293 
3294  if (m_calibMode) {
3295 
3296  length = 2 * m_nDrawers;
3297  suffixArr.resize(length);
3298 
3299  for (unsigned int i = 0; i < listSize; ++i) {
3300  unsigned int ros = m_drawerType[i];
3301  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3302  std::string digits;
3303  if (m_TBperiod >= 2010) {
3304  ++drawer; // count modules from 1
3305  digits = digit[drawer / 10] + digit[drawer % 10];
3306  } else if (testbeam) {
3307  digits = digit[drawer & 7];
3308  } else {
3309  ++drawer; // count modules from 1
3310  digits = digit[drawer / 10] + digit[drawer % 10];
3311  }
3312 
3313  if (ros == 0) {
3314  std::string suff = m_drawerList[i];
3315  suff.replace(suff.find("0x"), 2, "");
3316  suffixArr[i] = suff + "lo";
3317  suffixArr[i + m_nDrawers] = suff + "hi";
3318  } else {
3319  suffixArr[i] = m_rosName[ros] + digits + "lo";
3320  suffixArr[i + m_nDrawers] = m_rosName[ros] + digits + "hi";
3321  }
3322  }
3323  } else {
3324 
3325  length = m_nDrawers;
3326  suffixArr.resize(length);
3327 
3328  for (unsigned int i = 0; i < listSize; ++i) {
3329  unsigned int ros = m_drawerType[i];
3330  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3331  std::string digits;
3332  if (m_TBperiod >= 2010) {
3333  ++drawer; // count modules from 1
3334  digits = digit[drawer / 10] + digit[drawer % 10];
3335  } else if (testbeam) {
3336  digits = digit[drawer & 7];
3337  } else {
3338  ++drawer; // count modules from 1
3339  digits = digit[drawer / 10] + digit[drawer % 10];
3340  }
3341 
3342  if (ros == 0) {
3343  std::string suff = m_drawerList[i];
3344  suff.replace(suff.find("0x"), 2, "");
3345  suffixArr[i] = suff;
3346  } else {
3347  suffixArr[i] = m_rosName[ros] + digits;
3348  }
3349  }
3350  }
3351 
3352  m_nSamplesInDrawer.reserve(length);
3353 
3354  m_evtVec.resize(length);
3355  m_rodBCIDVec.resize(length);
3356  m_sizeVec.resize(length);
3357  m_ROD_GlobalCRCVec.resize(length);
3358 
3359  for (unsigned int i = 0; i < length; i++) {
3360 
3361  int nSamplesInDrawer(m_nSamples);
3362  int frag = std::stoi(m_drawerList[i%m_nDrawers], nullptr, 0);
3363 
3364  auto it = m_nSamplesInDrawerMap.find(frag);
3365  if (it != m_nSamplesInDrawerMap.end()) {
3366  nSamplesInDrawer = it->second;
3367  }
3368  m_nSamplesInDrawer.push_back(nSamplesInDrawer);
3369 
3370  m_bcidVec.push_back(std::array<int, MAX_DMU>()); // U
3371  m_DMUheaderVec.push_back(std::array<uint32_t, MAX_DMU>()); // U32
3372  m_DMUformatErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3373  m_DMUparityErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3374  m_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3375  m_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3376  m_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>()); // U32
3377  m_DMUHeadparityErrVec.push_back(std::array<short, MAX_DMU>());
3378  m_DMUDataparityErrVec.push_back(std::array<short, MAX_DMU>());
3379 
3380  m_dmuMaskVec.push_back(std::array<int, 2>()); // U(2)
3381  m_slinkCRCVec.push_back(std::array<int, 2>()); // U(2)
3382  m_gainVec.push_back(std::array<int, MAX_CHAN>()); // U(48/96)
3383  m_sampleVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3384  m_feCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3385  m_rodCRCVec.push_back(std::array<int, MAX_DMU>()); //U
3386 
3387  m_eneVec.push_back(std::array<float, MAX_CHAN>());
3388  m_timeVec.push_back(std::array<float, MAX_CHAN>());
3389  m_pedFlatVec.push_back(std::array<float, MAX_CHAN>());
3390  m_chi2FlatVec.push_back(std::array<float, MAX_CHAN>());
3391 
3392  m_efitVec.push_back(std::array<float, MAX_CHAN>());
3393  m_tfitVec.push_back(std::array<float, MAX_CHAN>());
3394  m_pedfitVec.push_back(std::array<float, MAX_CHAN>());
3395  m_chi2Vec.push_back(std::array<float, MAX_CHAN>());
3396 
3397  m_efitcVec.push_back(std::array<float, MAX_CHAN>());
3398  m_tfitcVec.push_back(std::array<float, MAX_CHAN>());
3399  m_pedfitcVec.push_back(std::array<float, MAX_CHAN>());
3400  m_chi2cVec.push_back(std::array<float, MAX_CHAN>());
3401 
3402  m_eOptVec.push_back(std::array<float, MAX_CHAN>());
3403  m_tOptVec.push_back(std::array<float, MAX_CHAN>());
3404  m_pedOptVec.push_back(std::array<float, MAX_CHAN>());
3405  m_chi2OptVec.push_back(std::array<float, MAX_CHAN>());
3406 
3407  m_eDspVec.push_back(std::array<float, MAX_CHAN>());
3408  m_tDspVec.push_back(std::array<float, MAX_CHAN>());
3409  m_chi2DspVec.push_back(std::array<float, MAX_CHAN>());
3410 
3411  m_ROD_DMUBCIDVec.push_back(std::array<short, MAX_DMU>());
3412  m_ROD_DMUmemoryErrVec.push_back(std::array<short, MAX_DMU>());
3413  m_ROD_DMUSstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3414  m_ROD_DMUDstrobeErrVec.push_back(std::array<short, MAX_DMU>());
3415  m_ROD_DMUHeadformatErrVec.push_back(std::array<short, MAX_DMU>());
3416  m_ROD_DMUDataformatErrVec.push_back(std::array<short, MAX_DMU>());
3417  m_ROD_DMUMaskVec.push_back(std::array<short, 2>());
3418 
3419  if (i % m_nDrawers < listSize) {
3420 
3421  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3422  // create ntuple layout
3423  if (m_bsInput) {
3424  m_ntuplePtr->Branch(("Evt"+suffixArr[i]).c_str(), &m_evtVec.data()[i], ("Evt"+suffixArr[i]+"/I").c_str()); // int
3425  m_ntuplePtr->Branch(("rodBCID"+suffixArr[i]).c_str(), &m_rodBCIDVec.data()[i], ("rodBCID"+suffixArr[i]+"/S").c_str());//int
3426  m_ntuplePtr->Branch(("Size"+suffixArr[i]).c_str(), &m_sizeVec.data()[i], ("Size"+suffixArr[i]+"/S").c_str()); // short
3427  m_ntuplePtr->Branch(("BCID"+suffixArr[i]).c_str(), &m_bcidVec.back(), ("bcid"+suffixArr[i]+"[16]/I").c_str()); // int
3428  m_ntuplePtr->Branch(("DMUheader"+suffixArr[i]).c_str(), &m_DMUheaderVec.back(), ("DMUheader"+suffixArr[i]+"[16]/i").c_str()); // uint32
3429  m_ntuplePtr->Branch(("DMUformatErr"+suffixArr[i]).c_str(), &m_DMUformatErrVec.back(), ("DMUformatErr"+suffixArr[i]+"[16]/S").c_str()); // short
3430  m_ntuplePtr->Branch(("DMUparityErr"+suffixArr[i]).c_str(), &m_DMUparityErrVec.back(), ("DMUparityErr"+suffixArr[i]+"[16]/S").c_str()); // short
3431  m_ntuplePtr->Branch(("DMUmemoryErr"+suffixArr[i]).c_str(), &m_DMUmemoryErrVec.back(), ("DMUmemoryErr"+suffixArr[i]+"[16]/S").c_str()); // short
3432  m_ntuplePtr->Branch(("DMUSstrobeErr"+suffixArr[i]).c_str(), &m_DMUSstrobeErrVec.back(), ("DMUSstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3433  m_ntuplePtr->Branch(("DMUDstrobeErr"+suffixArr[i]).c_str(), &m_DMUDstrobeErrVec.back(), ("DMUDstrobeErr"+suffixArr[i]+"[16]/S").c_str()); // short
3434  m_ntuplePtr->Branch(("DMUMask"+suffixArr[i]).c_str(), &m_dmuMaskVec.back(), ("dmumask"+suffixArr[i]+"[2]/I").c_str()); // int
3435  m_ntuplePtr->Branch(("SlinkCRC"+suffixArr[i]).c_str(), &m_slinkCRCVec.back(), ("crc"+suffixArr[i]+"[2]/I").c_str()); // int
3436  m_ntuplePtr->Branch(("DMUHeadparityErr"+suffixArr[i]).c_str(), &m_DMUHeadparityErrVec.back(), ("DMUHeadparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3437  m_ntuplePtr->Branch(("DMUDataparityErr"+suffixArr[i]).c_str(), &m_DMUDataparityErrVec.back(), ("DMUDataparityErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3438  }
3439 
3440  m_ntuplePtr->Branch(("Gain"+suffixArr[i]).c_str(),&m_gainVec.back(), ("gain"+suffixArr[i]+"[48]/I").c_str()); // int
3441 
3442  if (nSamplesInDrawer > 0) {
3443  nSampStr = std::to_string(nSamplesInDrawer);
3444  m_ntuplePtr->Branch(("Sample" + suffixArr[i]).c_str(), m_sampleVec.back().get(),
3445  ("sample" + suffixArr[i] + "[48]["+nSampStr+"]/I").c_str()); // size m_nsample and type int
3446  }
3447 
3448  if (m_bsInput) {
3449  m_ntuplePtr->Branch(("feCRC" + suffixArr[i]).c_str(), &m_feCRCVec.back(), ("fe_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3450  m_ntuplePtr->Branch(("rodCRC" + suffixArr[i]).c_str(), &m_rodCRCVec.back(), ("rod_crc" + suffixArr[i] + "[16]/I").c_str()); // int
3451  }
3452 
3453  if (!m_flatRawChannelContainerKey.empty()) {
3454 
3455  m_ntuplePtr->Branch(("Ene" + suffixArr[i]).c_str(), &m_eneVec.back(), ("ene" + suffixArr[i] + "[48]/F").c_str()); // float
3456  m_ntuplePtr->Branch(("Time" + suffixArr[i]).c_str(), &m_timeVec.back(), ("time" + suffixArr[i] + "[48]/F").c_str()); // float
3457  m_ntuplePtr->Branch(("Ped" + suffixArr[i]).c_str(), &m_pedFlatVec.back(), ("pedflat" + suffixArr[i] + "[48]/F").c_str()); // float
3458  m_ntuplePtr->Branch(("Chi2ene" + suffixArr[i]).c_str(), &m_chi2FlatVec.back(), ("chiflat" + suffixArr[i] + "[48]/F").c_str()); // float
3459 
3460  }
3461 
3462  if (!m_fitRawChannelContainerKey.empty()) {
3463 
3464  m_ntuplePtr->Branch(("Efit" + suffixArr[i]).c_str(), &m_efitVec.back(), ("efit" + suffixArr[i] + "[48]/F").c_str()); // float
3465  m_ntuplePtr->Branch(("Tfit" + suffixArr[i]).c_str(), &m_tfitVec.back(), ("tfit" + suffixArr[i] + "[48]/F").c_str()); // float
3466  m_ntuplePtr->Branch(("Pedfit" + suffixArr[i]).c_str(), &m_pedfitVec.back(), ("pedfit" + suffixArr[i] + "[48]/F").c_str()); // float
3467  m_ntuplePtr->Branch(("Chi2fit" + suffixArr[i]).c_str(), &m_chi2Vec.back(), ("chifit" + suffixArr[i] + "[48]/F").c_str()); // float
3468 
3469  }
3470 
3471  if (!m_fitcRawChannelContainerKey.empty()) {
3472 
3473  m_ntuplePtr->Branch(("Efitc" + suffixArr[i]).c_str(), &m_efitcVec.back(), ("efitc" + suffixArr[i] + "[48]/F").c_str()); // float
3474  m_ntuplePtr->Branch(("Tfitc" + suffixArr[i]).c_str(), &m_tfitcVec.back(), ("tfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3475  m_ntuplePtr->Branch(("Pedfitc" + suffixArr[i]).c_str(), &m_pedfitcVec.back(), ("pedfitc" + suffixArr[i] + "[48]/F").c_str()); // float
3476  m_ntuplePtr->Branch(("Chi2fitc" + suffixArr[i]).c_str(), &m_chi2cVec.back(), ("chifitc" + suffixArr[i] + "[48]/F").c_str()); // float
3477 
3478  }
3479 
3480  if (!m_optRawChannelContainerKey.empty()) {
3481 
3482  m_ntuplePtr->Branch(("Eopt"+suffixArr[i]).c_str(), &m_eOptVec.back(), ("eOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3483  m_ntuplePtr->Branch(("Topt"+suffixArr[i]).c_str(), &m_tOptVec.back(), ("tOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3484  m_ntuplePtr->Branch(("Pedopt"+suffixArr[i]).c_str(), &m_pedOptVec.back(), ("pedOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3485  m_ntuplePtr->Branch(("Chi2opt"+suffixArr[i]).c_str(), &m_chi2OptVec.back(), ("chiOpt"+suffixArr[i]+"[48]/F").c_str()); // float
3486 
3487  }
3488 
3489  if (!m_dspRawChannelContainerKey.empty()) {
3490 
3491  m_ntuplePtr->Branch(("Edsp"+suffixArr[i]).c_str(), &m_eDspVec.back(), ("eDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3492  m_ntuplePtr->Branch(("Tdsp"+suffixArr[i]).c_str(), &m_tDspVec.back(), ("tDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3493  m_ntuplePtr->Branch(("Chi2dsp"+suffixArr[i]).c_str(), &m_chi2DspVec.back(), ("chiDsp"+suffixArr[i]+"[48]/F").c_str()); // float
3494  m_ntuplePtr->Branch(("ROD_GlobalCRC"+suffixArr[i]).c_str(), &m_ROD_GlobalCRCVec.data()[i], ("ROD_GlobalCRC"+suffixArr[i]+"/s").c_str()); // unsigned short
3495  m_ntuplePtr->Branch(("ROD_DMUBCID"+suffixArr[i]).c_str(), &m_ROD_DMUBCIDVec.back(), ("ROD_DMUBCID"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3496  m_ntuplePtr->Branch(("ROD_DMUmemoryErr"+suffixArr[i]).c_str(), &m_ROD_DMUmemoryErrVec.back(), ("ROD_DMUmemoryErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3497  m_ntuplePtr->Branch(("ROD_DMUSstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUSstrobeErrVec.back(), ("ROD_DMUSstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3498  m_ntuplePtr->Branch(("ROD_DMUDstrobeErr"+suffixArr[i]).c_str(), &m_ROD_DMUDstrobeErrVec.back(), ("ROD_DMUDstrobeErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3499  m_ntuplePtr->Branch(("ROD_DMUHeadformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUHeadformatErrVec.back(), ("ROD_DMUHeadformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3500  m_ntuplePtr->Branch(("ROD_DMUDataformatErr"+suffixArr[i]).c_str(), &m_ROD_DMUDataformatErrVec.back(), ("ROD_DMUDataformatErr"+suffixArr[i]+"[16]/s").c_str()); // unsigned short
3501  m_ntuplePtr->Branch(("ROD_DMUMask"+suffixArr[i]).c_str(), &m_ROD_DMUMaskVec.back(), ("ROD_DMUMask"+suffixArr[i]+"[2]/s").c_str()); // unsigned short
3502 
3503  }
3504  }
3505  }
3506  }
3507 }

◆ DIGI_clearBranch()

void TileTBAANtuple::DIGI_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variables ////////////////////////////////////////////////////////////////////////////

Definition at line 3514 of file TileTBAANtuple.cxx.

3515 {
3516  clear_init_minus1(m_evtVec);
3517  clear_init_minus1(m_rodBCIDVec);
3518  clear_init_minus1(m_sizeVec);
3519 
3520  clear_init_minus1(m_bcidVec);
3521  clear_init_zero(m_DMUheaderVec);
3522  clear_init_minus1(m_DMUformatErrVec);
3523  clear_init_minus1(m_DMUparityErrVec);
3524  clear_init_minus1(m_DMUmemoryErrVec);
3525  clear_init_minus1(m_DMUDstrobeErrVec);
3526  clear_init_minus1(m_DMUSstrobeErrVec);
3527  clear_init_minus1(m_DMUDataparityErrVec);
3528  clear_init_minus1(m_DMUHeadparityErrVec);
3529 
3530  clear_init_minus1(m_ROD_GlobalCRCVec);
3531  clear_init_minus1(m_ROD_DMUBCIDVec);
3532  clear_init_minus1(m_ROD_DMUmemoryErrVec);
3533  clear_init_minus1(m_ROD_DMUSstrobeErrVec);
3534  clear_init_minus1(m_ROD_DMUDstrobeErrVec);
3535  clear_init_minus1(m_ROD_DMUHeadformatErrVec);
3536  clear_init_minus1(m_ROD_DMUDataformatErrVec);
3537  clear_init_minus1(m_ROD_DMUMaskVec);
3538 
3539  clear_init_minus1(m_dmuMaskVec);
3540  clear_init_minus1(m_slinkCRCVec);
3541  clear_init_minus1(m_gainVec);
3542  clear_samples(m_sampleVec, m_nSamplesInDrawer);
3543  clear_init_minus1(m_feCRCVec);
3544  clear_init_minus1(m_rodCRCVec);
3545 
3546  clear_init_zero(m_eneVec);
3547  clear_init_zero(m_timeVec);
3548  clear_init_zero(m_pedFlatVec);
3549  clear_init_zero(m_chi2FlatVec);
3550  clear_init_zero(m_efitVec);
3551  clear_init_zero(m_tfitVec);
3552  clear_init_zero(m_pedfitVec);
3553  clear_init_zero(m_chi2Vec);
3554  clear_init_zero(m_efitcVec);
3555  clear_init_zero(m_tfitcVec);
3556  clear_init_zero(m_pedfitcVec);
3557  clear_init_zero(m_chi2cVec);
3558  clear_init_zero(m_eOptVec);
3559  clear_init_zero(m_tOptVec);
3560  clear_init_zero(m_pedOptVec);
3561  clear_init_zero(m_chi2OptVec);
3562  clear_init_zero(m_eDspVec);
3563  clear_init_zero(m_tDspVec);
3564  clear_init_zero(m_chi2DspVec);
3565 
3566 }

◆ digiChannel2PMT()

int TileTBAANtuple::digiChannel2PMT ( int  fragType,
int  chan 
)
inlineprivate

Definition at line 296 of file TileTBAANtuple.h.

296  {
297  return (abs(m_cabling->channel2hole(fragType, chan)) - 1);
298  }

◆ ECAL_addBranch()

void TileTBAANtuple::ECAL_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add ECAL variables to the Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2646 of file TileTBAANtuple.cxx.

2647 {
2648 
2649  if (m_beamIdList[ECAL_ADC_FRAG]) {
2650  m_ntuplePtr->Branch("Ecal",&m_ecal,"m_ecal[8]/F");
2651  }
2652 
2653 }

◆ ECAL_clearBranch()

void TileTBAANtuple::ECAL_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree ECAL variables

////////////////////////////////////////////////////////////////////////////

Definition at line 2712 of file TileTBAANtuple.cxx.

2713 {
2714 
2715 }

◆ ENETOTAL_addBranch()

void TileTBAANtuple::ENETOTAL_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree ENETOTAL variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 3143 of file TileTBAANtuple.cxx.

3144 {
3145  if (m_completeNtuple) {
3146  m_ntuplePtr->Branch("LarSmp", &m_LarEne, "m_LarEne[4]/F");
3147  m_ntuplePtr->Branch("BarSmp", &m_BarEne, "m_BarEne[3]/F");
3148  m_ntuplePtr->Branch("ExtSmp", &m_ExtEne, "m_ExtEne[3]/F");
3149  m_ntuplePtr->Branch("GapSmp", &m_GapEne, "m_GapEne[3]/F");
3150  }
3151 }

◆ ENETOTAL_clearBranch()

void TileTBAANtuple::ENETOTAL_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree ENETOTAL variables

////////////////////////////////////////////////////////////////////////////

Definition at line 3159 of file TileTBAANtuple.cxx.

3160 {
3161 
3162 
3163 }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode TileTBAANtuple::execute ( )
overridevirtual

Definition at line 468 of file TileTBAANtuple.cxx.

468  {
469 
470  const EventContext& ctx = Gaudi::Hive::currentContext();
471  const TileDQstatus* dqStatus = (!m_dqStatusKey.empty()) ? SG::makeHandle(m_dqStatusKey, ctx).get() : nullptr;
472 
473  if (m_evtNr < 0) {
474 
475  //bool calibMode = (m_beamInfo->calibMode() == 1);
476  //if ( calibMode != m_calibMode ) {
477  // ATH_MSG_INFO( "Calib mode from data is " << calibMode );
478  // ATH_MSG_INFO( " Overwriting calib mode " );
479  // m_calibMode = calibMode;
480  //}
481 
482  if (ntuple_initialize(ctx).isFailure()) {
483  ATH_MSG_ERROR( "ntuple_initialize failed" );
484  }
485 
486  }
487 
488  m_dspFlags = 0;
489  if (ntuple_clear().isFailure()) {
490  ATH_MSG_ERROR( "ntuple_clear failed" );
491  }
492 
493  if (m_evtNr % 1000 == 0)
494  ATH_MSG_INFO( m_evtNr << " events processed so far" );
495 
496  m_run = ctx.eventID().run_number();
497  m_evt = ctx.eventID().event_number();
498 
499  //Get timestamp of the event
500  if (ctx.eventID().time_stamp() > 0) {
501  m_evTime = ctx.eventID().time_stamp();
502  }
503 
504  // store BeamElements
505  bool empty = storeBeamElements(ctx).isFailure();
506 
507  //store Laser Object
508  empty &= storeLaser(ctx).isFailure();
509 
510  if (m_drawerMap.size() > 0) {
511 
512  // store TileDigits
513  if (m_nSamples > 0) {
514  empty &= (storeDigits(ctx, m_digitsContainerKey, dqStatus).isFailure());
515  }
516  if (m_nSamplesFlx > 0) {
517  empty &= (storeDigitsFlx(ctx, m_digitsContainerFlxKey).isFailure());
518  }
519 
520  // store TileRawChannels
521  // start from DSP channels - so we can find out what is the DSP units
522  empty &= (storeRawChannels(ctx, m_dspRawChannelContainerKey, m_calibMode, &m_eDspVec, &m_tDspVec, &m_chi2DspVec, nullptr, true).isFailure());
523  empty &= (storeRawChannels(ctx, m_fitRawChannelContainerKey, m_calibMode, &m_efitVec, &m_tfitVec, &m_chi2Vec, &m_pedfitVec).isFailure());
524  empty &= (storeRawChannels(ctx, m_flxFitRawChannelContainerKey, true, &m_eflxfitVec, &m_tflxfitVec, &m_chi2flxfitVec, &m_pedflxfitVec).isFailure());
525  empty &= (storeRawChannels(ctx, m_optRawChannelContainerKey, m_calibMode, &m_eOptVec, &m_tOptVec, &m_chi2OptVec, &m_pedOptVec).isFailure());
526  empty &= (storeRawChannels(ctx, m_flxOptRawChannelContainerKey, true, &m_eflxoptVec, &m_tflxoptVec, &m_chi2flxoptVec, &m_pedflxoptVec).isFailure());
527  empty &= (storeRawChannels(ctx, m_fitcRawChannelContainerKey, m_calibMode, &m_efitcVec, &m_tfitcVec, &m_chi2cVec, &m_pedfitcVec).isFailure());
528  empty &= (storeRawChannels(ctx, m_flatRawChannelContainerKey, m_calibMode, &m_eneVec, &m_timeVec, &m_chi2FlatVec, &m_pedFlatVec).isFailure());
529 
530  empty &= (storeHitVector(ctx).isFailure());
531  empty &= (storeHitContainer(ctx).isFailure());
532  }
533 
534 
535  if (m_completeNtuple && m_TBperiod < 2015) {
536  // store energy per sampling from all calorimeters
537  empty &= (storeCells(ctx).isFailure());
538  }
539 
540  // increase event nr
541  // this number can be different from real event number if we skip events
542 
543  if (empty) {
544  ATH_MSG_WARNING( "Error in execute " );
545  }
546 
547  m_ntuplePtr->Fill();
548 
549  ++m_evtNr;
550 
551  // Execution completed.
552  ATH_MSG_DEBUG( "execute() completed successfully" );
553 
554  return StatusCode::SUCCESS;
555 }

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

◆ FELIX_addBranch()

void TileTBAANtuple::FELIX_addBranch ( void  )
private

Definition at line 3569 of file TileTBAANtuple.cxx.

3570 {
3571 
3572  m_rodBCIDflxVec.reserve(MAX_DRAWERS);
3573  m_sizeflxVec.reserve(MAX_DRAWERS);
3574  m_evtflxVec.reserve(MAX_DRAWERS);
3575 
3576  m_eflxfitVec.reserve(MAX_DRAWERS);
3577  m_tflxfitVec.reserve(MAX_DRAWERS);
3578  m_chi2flxfitVec.reserve(MAX_DRAWERS);
3579  m_pedflxfitVec.reserve(MAX_DRAWERS);
3580  m_eflxoptVec.reserve(MAX_DRAWERS);
3581  m_tflxoptVec.reserve(MAX_DRAWERS);
3582  m_chi2flxoptVec.reserve(MAX_DRAWERS);
3583  m_pedflxoptVec.reserve(MAX_DRAWERS);
3584  m_gainflxVec.reserve(MAX_DRAWERS);
3585  m_sampleflxVec.reserve(MAX_DRAWERS);
3586 
3587  m_mdL1idflxVec.reserve(MAX_DRAWERS);
3588  m_mdBcidflxVec.reserve(MAX_DRAWERS);
3589  m_mdModuleflxVec.reserve(MAX_DRAWERS);
3590  m_mdRunTypeflxVec.reserve(MAX_DRAWERS);
3591  m_mdPedLoflxVec.reserve(MAX_DRAWERS);
3592  m_mdPedHiflxVec.reserve(MAX_DRAWERS);
3593  m_mdRunflxVec.reserve(MAX_DRAWERS);
3594  m_mdChargeflxVec.reserve(MAX_DRAWERS);
3595  m_mdChargeTimeflxVec.reserve(MAX_DRAWERS);
3596  m_mdCapacitorflxVec.reserve(MAX_DRAWERS);
3597 
3598  std::string nSampStrFlx = std::to_string(m_nSamplesFlx);
3599  unsigned int listSize = std::min(m_nDrawersFlx.value(), static_cast<unsigned int>(m_drawerFlxMap.size()));
3600 
3601  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3602  std::vector<std::string> moduleNames(m_nDrawersFlx, "");
3603  unsigned int length = 2 * m_nDrawersFlx;
3604  std::vector<std::string> suffixArr(length, "");
3605  m_nSamplesFlxInDrawer.resize(length);
3606 
3607  for (const std::pair<const unsigned int, unsigned int>& fragAndDrawer : m_drawerFlxMap) {
3608  unsigned int frag = fragAndDrawer.first;
3609  unsigned int ros = frag >> 8;
3610  unsigned int drawer = frag & 0x3F;
3611  unsigned int drawerIndex = fragAndDrawer.second;
3612 
3613  std::ostringstream drawerName;
3614  drawerName << m_rosName[ros];
3615  if (testbeam) {
3616  drawerName << (drawer & 7);
3617  } else {
3618  ++drawer; // count modules from 1
3619  drawerName << std::setw(2) << std::setfill('0') << drawer;
3620  }
3621 
3622  moduleNames.at(drawerIndex) = drawerName.str();
3623  suffixArr.at(drawerIndex) = drawerName.str() + "lo";
3624  suffixArr.at(drawerIndex + m_nDrawersFlx) = drawerName.str() + "hi";
3625 
3626  int nSamples(m_nSamplesFlx);
3627  auto it = m_nSamplesFlxInDrawerMap.find(frag);
3628  if (it != m_nSamplesFlxInDrawerMap.end()) {
3629  nSamples = it->second;
3630  }
3631 
3632  m_nSamplesFlxInDrawer[drawerIndex] = nSamples;
3633  m_nSamplesFlxInDrawer[drawerIndex + m_nDrawersFlx] = nSamples;
3634  }
3635 
3636  m_rodBCIDflxVec.resize(m_nDrawersFlx);
3637  m_sizeflxVec.resize(m_nDrawersFlx);
3638  m_evtflxVec.resize(m_nDrawersFlx);
3639 
3640  for (unsigned int i = 0; i < length; ++i) {
3641 
3642  int nSamplesInDrawer = m_nSamplesFlxInDrawer[i];
3643 
3644  m_eflxfitVec.push_back(std::array<float, MAX_CHAN>());
3645  m_tflxfitVec.push_back(std::array<float, MAX_CHAN>());
3646  m_pedflxfitVec.push_back(std::array<float, MAX_CHAN>());
3647  m_chi2flxfitVec.push_back(std::array<float, MAX_CHAN>());
3648 
3649  m_eflxoptVec.push_back(std::array<float, MAX_CHAN>());
3650  m_tflxoptVec.push_back(std::array<float, MAX_CHAN>());
3651  m_pedflxoptVec.push_back(std::array<float, MAX_CHAN>());
3652  m_chi2flxoptVec.push_back(std::array<float, MAX_CHAN>());
3653 
3654  if (i < m_nDrawersFlx) {
3655  m_mdL1idflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3656  m_mdBcidflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3657  m_mdModuleflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3658  m_mdRunTypeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3659  m_mdPedLoflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3660  m_mdPedHiflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3661  m_mdRunflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3662  m_mdChargeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3663  m_mdChargeTimeflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3664  m_mdCapacitorflxVec.push_back(std::array<int, MAX_MINIDRAWER>());
3665 
3666  std::string suffix = moduleNames[i];
3667  ATH_MSG_DEBUG( "Adding items for " << suffix );
3668 
3669  if (m_bsInput) {
3670  m_ntuplePtr->Branch(("FlxEvt"+suffix).c_str(), &m_evtflxVec.data()[i]); // int
3671  m_ntuplePtr->Branch(("FlxRodBCID"+suffix).c_str(), &m_rodBCIDflxVec.data()[i]);//int
3672  m_ntuplePtr->Branch(("FlxSize"+suffix).c_str(), &m_sizeflxVec.data()[i]); // short
3673  }
3674 
3675  m_ntuplePtr->Branch(("FlxL1ID"+suffix).c_str(), &m_mdL1idflxVec.back()); // int
3676  m_ntuplePtr->Branch(("FlxBCID"+suffix).c_str(), &m_mdBcidflxVec.back()); // int
3677  m_ntuplePtr->Branch(("FlxModule"+suffix).c_str(), &m_mdModuleflxVec.back()); // int
3678  m_ntuplePtr->Branch(("FlxRun"+suffix).c_str(), &m_mdRunflxVec.back()); // int
3679  m_ntuplePtr->Branch(("FlxRunType"+suffix).c_str(), &m_mdRunTypeflxVec.back()); // int
3680  m_ntuplePtr->Branch(("FlxPedLo"+suffix).c_str(), &m_mdPedLoflxVec.back()); // int
3681  m_ntuplePtr->Branch(("FlxPedHi"+suffix).c_str(), &m_mdPedHiflxVec.back()); // int
3682  m_ntuplePtr->Branch(("FlxCharge"+suffix).c_str(), &m_mdChargeflxVec.back()); // int
3683  m_ntuplePtr->Branch(("FlxChargeTime"+suffix).c_str(), &m_mdChargeTimeflxVec.back()); // int
3684  m_ntuplePtr->Branch(("FlxCapacitor"+suffix).c_str(), &m_mdCapacitorflxVec.back()); // int
3685 
3686  }
3687 
3688  m_gainflxVec.push_back(std::array<int, MAX_CHAN>());
3689  m_sampleflxVec.push_back(std::make_unique<int[]>(MAX_CHAN * nSamplesInDrawer)); // U(48/96,9)
3690 
3691  if (i % m_nDrawersFlx < listSize) {
3692  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3693 
3694  m_ntuplePtr->Branch(("FlxGain"+suffixArr[i]).c_str(), &m_gainflxVec.back()); // int
3695 
3696  if (nSamplesInDrawer > 0) {
3697  nSampStrFlx = std::to_string(nSamplesInDrawer);
3698  m_ntuplePtr->Branch(("FlxSample" + suffixArr[i]).c_str(), m_sampleflxVec.back().get(),
3699  ("Flxsample" + suffixArr[i] + "[48]["+nSampStrFlx+"]/I").c_str()); // size m_nsample and type int
3700  }
3701 
3702  if (!m_flxFitRawChannelContainerKey.empty()) {
3703  m_ntuplePtr->Branch(("FlxEfit" + suffixArr[i]).c_str(), &m_eflxfitVec.back()); // float
3704  m_ntuplePtr->Branch(("FlxTfit" + suffixArr[i]).c_str(), &m_tflxfitVec.back()); // float
3705  m_ntuplePtr->Branch(("FlxPedfit" + suffixArr[i]).c_str(), &m_pedflxfitVec.back()); // float
3706  m_ntuplePtr->Branch(("FlxChi2fit" + suffixArr[i]).c_str(), &m_chi2flxfitVec.back()); // float
3707  }
3708 
3709  if (!m_flxOptRawChannelContainerKey.empty()) {
3710  m_ntuplePtr->Branch(("FlxEOpt" + suffixArr[i]).c_str(), &m_eflxoptVec.back()); // float
3711  m_ntuplePtr->Branch(("FlxTOpt" + suffixArr[i]).c_str(), &m_tflxoptVec.back()); // float
3712  m_ntuplePtr->Branch(("FlxPedOpt" + suffixArr[i]).c_str(), &m_pedflxoptVec.back()); // float
3713  m_ntuplePtr->Branch(("FlxChi2Opt" + suffixArr[i]).c_str(), &m_chi2flxoptVec.back()); // float
3714  }
3715  }
3716  }
3717 }

◆ FELIX_clearBranch()

void TileTBAANtuple::FELIX_clearBranch ( void  )
private

Definition at line 3721 of file TileTBAANtuple.cxx.

3722 {
3723  clear_init_minus1(m_evtflxVec);
3724  clear_init_minus1(m_rodBCIDflxVec);
3725  clear_init_minus1(m_sizeflxVec);
3726 
3727  clear_init_minus1(m_gainflxVec);
3728  clear_samples(m_sampleflxVec, m_nSamplesFlxInDrawer);
3729 
3730  clear_init_zero(m_eflxfitVec);
3731  clear_init_zero(m_tflxfitVec );
3732  clear_init_zero(m_chi2flxfitVec);
3733  clear_init_zero(m_pedflxfitVec);
3734 
3735  clear_init_zero(m_eflxoptVec);
3736  clear_init_zero(m_tflxoptVec);
3737  clear_init_zero(m_chi2flxoptVec);
3738  clear_init_zero(m_pedflxoptVec);
3739 
3740  clear_init_minus1(m_mdL1idflxVec);
3741  clear_init_minus1(m_mdBcidflxVec);
3742  clear_init_minus1(m_mdModuleflxVec);
3743  clear_init_minus1(m_mdRunTypeflxVec);
3744  clear_init_minus1(m_mdRunflxVec);
3745  clear_init_minus1(m_mdChargeflxVec);
3746  clear_init_minus1(m_mdChargeTimeflxVec);
3747  clear_init_minus1(m_mdCapacitorflxVec);
3748  clear_init_minus1(m_mdPedLoflxVec);
3749  clear_init_minus1(m_mdPedHiflxVec);
3750 }

◆ getEta()

void TileTBAANtuple::getEta ( void  )
private

Definition at line 2503 of file TileTBAANtuple.cxx.

2503  {
2504 
2505  // Get eta from an ASCII file with the following structure :
2506  // runnumber eta
2507 
2508  ATH_MSG_INFO( "Get eta for run " << m_runNumber );
2509 
2510  // Find the full path to filename:
2511  std::string fileName = PathResolver::find_file(m_etaFileName, "DATAPATH");
2512  ATH_MSG_INFO( "Reading file " << fileName );
2513 
2514  if (fileName.size() == 0) {
2515 
2516  ATH_MSG_WARNING( "Could not find input file " << m_etaFileName );
2517  ATH_MSG_WARNING( "Skip reading of eta value " );
2518 
2519  } else {
2520 
2521  std::ifstream etafile;
2522  etafile.open(fileName.c_str());
2523 
2524  if (etafile.good()) {
2525 
2526  int runNumber = 0;
2527  float eta = 0;
2528  while ((runNumber != m_runNumber) && (!etafile.eof())) {
2529  etafile >> runNumber >> eta;
2530  }
2531 
2532  if (runNumber != m_runNumber) {
2533  ATH_MSG_INFO( "Run " << m_runNumber << " has not been found, keep eta and theta at zero" );
2534 
2535  m_eta = m_theta = 0.0;
2536  } else {
2537  m_eta = eta;
2538  m_theta = (M_PI_2 - 2 * atan(exp(m_eta)));
2539  ATH_MSG_INFO( "Run " << m_runNumber << " has been found with eta=" << m_eta << ", theta =" << m_theta );
2540 
2541  }
2542 
2543  } else {
2544 
2545  ATH_MSG_WARNING( "Problem with file " << fileName );
2546  ATH_MSG_WARNING( "Skip reading of eta value " );
2547 
2548  }
2549 
2550  etafile.close();
2551  }
2552 }

◆ HIT_addBranch()

void TileTBAANtuple::HIT_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree HIT variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 3758 of file TileTBAANtuple.cxx.

3759 {
3760  m_ehitVec.clear();
3761  m_thitVec.clear();
3762  m_ehitCnt.clear();
3763  m_thitCnt.clear();
3764 
3765  m_ehitVec.reserve(MAX_DRAWERS);
3766  m_thitVec.reserve(MAX_DRAWERS);
3767  m_ehitCnt.reserve(MAX_DRAWERS);
3768  m_thitCnt.reserve(MAX_DRAWERS);
3769 
3770  unsigned int listSize = std::min(m_nDrawers.value(), static_cast<unsigned int>(m_drawerMap.size()));
3771 
3772  if (listSize > 0) {
3773 
3774  std::string digit[10] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
3775  std::vector<std::string> suffixArr;
3776  unsigned int length;
3777  bool testbeam = TileCablingService::getInstance()->getTestBeam();
3778 
3779  length = m_nDrawers;
3780  suffixArr.resize(length);
3781 
3782  for (unsigned int i = 0; i < listSize; ++i) {
3783  unsigned int ros = m_drawerType[i];
3784  unsigned int drawer = strtol(m_drawerList[i].data(), NULL, 0) & 0x3F;
3785  std::string digits;
3786  if (m_TBperiod >= 2010) {
3787  ++drawer; // count modules from 1
3788  digits = digit[drawer / 10] + digit[drawer % 10];
3789  } else if (testbeam) {
3790  digits = digit[drawer & 7];
3791  } else {
3792  ++drawer; // count modules from 1
3793  digits = digit[drawer / 10] + digit[drawer % 10];
3794  }
3795 
3796  if (ros == 0) {
3797  std::string suff = m_drawerList[i];
3798  suff.replace(suff.find("0x"), 2, "");
3799  suffixArr[i] = suff;
3800  } else {
3801  suffixArr[i] = m_rosName[ros] + digits;
3802  }
3803  }
3804 
3805  for (unsigned int i = 0; i < length; i++) {
3806 
3807  if (i % m_nDrawers < listSize)
3808  ATH_MSG_DEBUG( "Adding items for " << suffixArr[i] );
3809 
3810  m_ehitVec.push_back(std::array<float, MAX_CHAN>());
3811  m_thitVec.push_back(std::array<float, MAX_CHAN>());
3812  m_ehitCnt.push_back(std::array<float, MAX_CHAN>());
3813  m_thitCnt.push_back(std::array<float, MAX_CHAN>());
3814 
3815  if (i%m_nDrawers < listSize) {
3816 
3817  if (!m_hitVectorKey.empty()) {
3818 
3819  if (i % m_nDrawers < listSize)
3820  ATH_MSG_DEBUG( "Adding G4 hit info for " << suffixArr[i] );
3821 
3822  m_ntuplePtr->Branch(("EhitG4"+suffixArr[i]).c_str(),&m_ehitVec.back(),("eHitG4"+suffixArr[i]+"[48]/F").c_str());
3823  m_ntuplePtr->Branch(("ThitG4"+suffixArr[i]).c_str(),&m_thitVec.back(),("tHitG4"+suffixArr[i]+"[48]/F").c_str());
3824  }
3825 
3826  if (!m_hitContainerKey.empty()) {
3827 
3828  if (i % m_nDrawers < listSize)
3829  ATH_MSG_DEBUG( "Adding G4 corrected hit info for " << suffixArr[i] );
3830 
3831  m_ntuplePtr->Branch(("EhitSim"+suffixArr[i]).c_str(),&m_ehitCnt.back(),("eHitSim"+suffixArr[i]+"[48]/F").c_str());
3832  m_ntuplePtr->Branch(("ThitSim"+suffixArr[i]).c_str(),&m_thitCnt.back(),("tHitSim"+suffixArr[i]+"[48]/F").c_str());
3833  }
3834  }
3835  }
3836  }
3837 }

◆ HIT_clearBranch()

void TileTBAANtuple::HIT_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Clear Tree HIT variables ////////////////////////////////////////////////////////////////////////////

Definition at line 3844 of file TileTBAANtuple.cxx.

3845 {
3846  clear_init_zero(m_ehitVec);
3847  clear_init_zero(m_thitVec);
3848  clear_init_zero(m_ehitCnt);
3849  clear_init_zero(m_thitCnt);
3850 }

◆ initialize()

StatusCode TileTBAANtuple::initialize ( )
overridevirtual

Definition at line 209 of file TileTBAANtuple.cxx.

209  {
210  ATH_CHECK( m_samplingFractionKey.initialize(SG::AllowEmpty) );
211  m_saveFelixData = !(m_digitsContainerFlxKey.empty() && m_flxOptRawChannelContainerKey.empty() && m_flxFitRawChannelContainerKey.empty());
212 
213  ATH_CHECK( m_digitsContainerKey.initialize(SG::AllowEmpty) );
214  ATH_CHECK( m_digitsContainerFlxKey.initialize(SG::AllowEmpty) );
215  ATH_CHECK( m_beamElemContainerKey.initialize(SG::AllowEmpty) );
216  ATH_CHECK( m_flatRawChannelContainerKey.initialize(SG::AllowEmpty) );
217  ATH_CHECK( m_fitRawChannelContainerKey.initialize(SG::AllowEmpty) );
218  ATH_CHECK( m_optRawChannelContainerKey.initialize(SG::AllowEmpty) );
219  ATH_CHECK( m_dspRawChannelContainerKey.initialize(SG::AllowEmpty) );
220  ATH_CHECK( m_fitcRawChannelContainerKey.initialize(SG::AllowEmpty) );
221  ATH_CHECK( m_flxFitRawChannelContainerKey.initialize(SG::AllowEmpty) );
222  ATH_CHECK( m_flxOptRawChannelContainerKey.initialize(SG::AllowEmpty) );
223  ATH_CHECK( m_laserObjectKey.initialize(SG::AllowEmpty) );
224  ATH_CHECK( m_hitContainerKey.initialize(SG::AllowEmpty) );
225  ATH_CHECK( m_cellContainerKey.initialize(!m_cellContainerKey.empty() && m_completeNtuple && m_TBperiod < 2015) );
226 
227  ATH_CHECK( m_tileToolEmscale.retrieve() );
228  ATH_CHECK( m_adderFilterAlgTool.retrieve(EnableTool{m_unpackAdder}) );
229 
230  ATH_CHECK( m_dqStatusKey.initialize(SG::AllowEmpty) );
231 
232  return StatusCode::SUCCESS;
233 }

◆ initList()

StatusCode TileTBAANtuple::initList ( const EventContext &  ctx)
private

Definition at line 2295 of file TileTBAANtuple.cxx.

2295  {
2296 
2297  unsigned int size = m_drawerList.size();
2298 
2299  if (size > 0) {
2300 
2301  if (m_digitsContainerKey.empty()) { // empty name, nothing to do
2302 
2303  ATH_MSG_WARNING( "can't retrieve Digits from TDS" );
2304  ATH_MSG_WARNING( "can't set up fragment list for ntuple" );
2305 
2306  if (m_nSamples != 0) {
2307  ATH_MSG_WARNING( "Disable digit samples in ntuple" );
2308  m_nSamples = 0;
2309  }
2310 
2311  return StatusCode::SUCCESS;
2312  }
2313 
2314  // Read Digits from TES
2315  const TileDigitsContainer* digitsCnt = SG::makeHandle (m_digitsContainerKey, ctx).get();
2316 
2317  int frag = strtol(m_drawerList[0].data(), NULL, 0);
2318  if (frag < 0) { // setup frags IDs from the data
2319 
2320  std::vector<unsigned int> frags;
2321  // Go through all TileDigitsCollections
2322  for (const TileDigitsCollection* digitsCollection : *digitsCnt) {
2323  if (!digitsCollection->empty()) {
2324  // determine type of frag
2325  frags.push_back(digitsCollection->identify());
2326  }
2327  }
2328  size = frags.size();
2329 
2330  if (size > 0) {
2331 
2332  if (size < m_nDrawers) {
2333  ATH_MSG_INFO( "decreasing m_nDrawers from " << m_nDrawers << " to " << size );
2334  m_nDrawers = size;
2335  }
2336 
2337  unsigned int rosOrder[5] = { 2, 1, 3, 4, 0 };
2338  unsigned int dr = 0;
2339  char frg[6] = "0x000";
2340 
2341  m_drawerList.clear();
2342  // m_drawerType.clear();
2343  m_drawerMap.clear();
2344 
2345  msg(MSG::INFO) << "setting drawerList from data " << MSG::hex;
2346  for (unsigned int ir = 0; ir < 5; ++ir) {
2347  for (unsigned int i = 0; i < size; ++i) {
2348  unsigned int frag = frags[i];
2349  if (frag >> 8 == rosOrder[ir]) {
2350  sprintf(frg, "0x%3.3x", frag);
2351  m_drawerList.value().push_back((std::string) frg);
2352  if (dr == m_drawerType.size()) m_drawerType.value().push_back(frag >> 8);
2353  m_drawerMap[frag] = dr;
2354  msg(MSG::INFO) << " 0x" << frag;
2355  ++dr;
2356  }
2357  }
2358  }
2359 
2360  msg(MSG::INFO) << MSG::dec << endmsg;
2361 
2362  size = m_drawerType.size();
2363  if (size < m_nDrawers) {
2364  m_drawerType.value().resize(m_nDrawers);
2365  for (; size < m_nDrawers; ++size)
2366  m_drawerType[size] = 0;
2367  }
2368 
2369  msg(MSG::INFO) << MSG::INFO << "drawerType ";
2370  for (unsigned int dr = 0; dr < size; ++dr)
2371  msg(MSG::INFO) << " " << m_drawerType[dr];
2372  msg(MSG::INFO) << endmsg;
2373 
2374  if (size > m_nDrawers) {
2375  ATH_MSG_INFO( "increasing m_nDrawers from " << m_nDrawers << " to " << size );
2376  m_nDrawers = size;
2377  }
2378 
2379  if (size < 1) size = 1;
2380  if (m_eventsPerFile == 0) {
2381  m_eventsPerFile = static_cast<int>(200 / size) * 1000;
2382  ATH_MSG_INFO( "Number of events per file was 0, set it to 200k/" << size << " = " << m_eventsPerFile );
2383  }
2384 
2385  } else {
2386 
2387  ATH_MSG_ERROR( "can't find any TileDigits collections" );
2388  ATH_MSG_ERROR( "can't set up fragment list for ntuple" );
2389  }
2390  }
2391 
2392  // once again - check number of samples in the data
2393  // but do not print any ERRORs now
2394 
2395  // Go through all TileDigitsCollections
2396  for (const TileDigitsCollection* digitsCollection : *digitsCnt) {
2397  if (!digitsCollection->empty()) {
2398  int siz = digitsCollection->front()->samples().size();
2399  m_nSamplesInDrawerMap[digitsCollection->identify()] = siz;
2400  if (siz > m_nSamples && m_nSamples != 0) {
2401  ATH_MSG_WARNING( "Increasing number of digit samples in ntuple from " << m_nSamples << " to " << siz );
2402  m_nSamples = siz;
2403  }
2404  }
2405  }
2406  }
2407 
2408  return StatusCode::SUCCESS;
2409 }

◆ initListFlx()

StatusCode TileTBAANtuple::initListFlx ( const EventContext &  ctx)
private

Definition at line 2412 of file TileTBAANtuple.cxx.

2412  {
2413 
2414  unsigned int listSize = m_drawerList.size();
2415 
2416  if (listSize > 0) {
2417 
2418  if (m_digitsContainerFlxKey.empty()) { // empty name, nothing to do
2419 
2420  ATH_MSG_WARNING( "can't retrieve FELIX Digits from TDS" );
2421  ATH_MSG_WARNING( "can't set up FELIX fragment list for ntuple" );
2422 
2423  if (m_nSamples != 0) {
2424  ATH_MSG_WARNING( "Disable FELIX digit samples in ntuple" );
2425  m_nSamplesFlx = 0;
2426  }
2427 
2428  return StatusCode::SUCCESS;
2429  }
2430 
2431  // Read Digits from TES
2432  const TileDigitsContainer* digitsCntFlx = SG::makeHandle (m_digitsContainerFlxKey, ctx).get();
2433 
2434  if (listSize == m_nDrawers) {
2435  // Only legacy drawers in the list, setup FELIX frags IDs from the data
2436 
2437  std::vector<unsigned int> frags;
2438  // Go through all TileDigitsCollections
2439  for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
2440  if (!digitsCollection->empty()) {
2441  // Determine type of frag
2442  frags.push_back(digitsCollection->identify());
2443  }
2444  }
2445 
2446  unsigned int nFrags = frags.size();
2447 
2448  if (nFrags > 0) {
2449 
2450  if (nFrags != m_nDrawersFlx) {
2451  ATH_MSG_INFO( "changing m_nDrawersFlx from " << m_nDrawersFlx.value() << " to " << nFrags );
2452  m_nDrawersFlx = nFrags;
2453  }
2454 
2455  m_drawerFlxMap.clear();
2456 
2457  std::ostringstream os;
2458  os << "setting FELIX drawers from data " << std::hex;
2459  unsigned int drawerIndex = 0;
2460  for (unsigned int frag : frags) {
2461  m_drawerFlxMap[frag] = drawerIndex;
2462  os << " 0x" << frag;
2463  ++drawerIndex;
2464  }
2465  os << std::dec;
2466 
2467  ATH_MSG_INFO(os.str());
2468 
2469  if (m_eventsPerFile == 0) {
2470  int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
2471  m_eventsPerFile = static_cast<int>(200 / nDrawersAll) * 1000;
2472  ATH_MSG_INFO( "Number of events per file was 0, set it to 200k/" << nDrawersAll << " = " << m_eventsPerFile );
2473  }
2474 
2475  } else {
2476  ATH_MSG_ERROR( "can't find any FELIX TileDigits collections" );
2477  ATH_MSG_ERROR( "can't set up FELIX fragment list for ntuple" );
2478  }
2479  }
2480 
2481 
2482  // once again - check number of samples in the data
2483  // but do not print any ERRORs now
2484 
2485  for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
2486  if (!digitsCollection->empty()) {
2487  int siz = digitsCollection->front()->samples().size();
2488  m_nSamplesFlxInDrawerMap[digitsCollection->identify()] = siz;
2489  if (siz > m_nSamplesFlx && m_nSamplesFlx != 0) {
2490  ATH_MSG_WARNING( "Increasing number of FELIX digit samples in ntuple from " << m_nSamplesFlx << " to " << siz );
2491  m_nSamplesFlx = siz;
2492  }
2493  }
2494  }
2495  }
2496 
2497  return StatusCode::SUCCESS;
2498 }

◆ initNTuple()

StatusCode TileTBAANtuple::initNTuple ( void  )
private

Definition at line 2126 of file TileTBAANtuple.cxx.

2126  {
2127  MsgStream log(msgSvc(), name());
2128 
2129  m_evtVec.clear();
2130  m_bcidVec.clear();
2131  m_DMUheaderVec.clear();
2132  m_DMUformatErrVec.clear();
2133  m_DMUparityErrVec.clear();
2134  m_DMUmemoryErrVec.clear();
2135  m_DMUDstrobeErrVec.clear();
2136  m_DMUSstrobeErrVec.clear();
2137  m_DMUHeadparityErrVec.clear();
2138  m_DMUDataparityErrVec.clear();
2139  m_rodBCIDVec.clear();
2140  m_sizeVec.clear();
2141  m_dmuMaskVec.clear();
2142  m_slinkCRCVec.clear();
2143  m_gainVec.clear();
2144  m_sampleVec.clear();
2145  m_feCRCVec.clear();
2146  m_rodCRCVec.clear();
2147 
2148  m_evtflxVec.clear();
2149  m_rodBCIDflxVec.clear();
2150  m_sizeflxVec.clear();
2151  m_gainflxVec.clear();
2152  m_sampleflxVec.clear();
2153 
2154  m_eneVec.clear();
2155  m_timeVec.clear();
2156  m_pedFlatVec.clear();
2157  m_chi2FlatVec.clear();
2158 
2159  m_efitVec.clear();
2160  m_tfitVec.clear();
2161  m_pedfitVec.clear();
2162  m_chi2Vec.clear();
2163 
2164  m_efitcVec.clear();
2165  m_tfitcVec.clear();
2166  m_pedfitcVec.clear();
2167  m_chi2cVec.clear();
2168 
2169  m_eOptVec.clear();
2170  m_tOptVec.clear();
2171  m_pedOptVec.clear();
2172  m_chi2OptVec.clear();
2173 
2174  m_eflxfitVec.clear();
2175  m_tflxfitVec.clear();
2176  m_pedflxfitVec.clear();
2177  m_chi2flxfitVec.clear();
2178 
2179  m_eflxoptVec.clear();
2180  m_tflxoptVec.clear();
2181  m_pedflxoptVec.clear();
2182  m_chi2flxoptVec.clear();
2183 
2184  m_eDspVec.clear();
2185  m_tDspVec.clear();
2186  m_chi2DspVec.clear();
2187 
2188  m_ROD_GlobalCRCVec.clear();
2189  m_ROD_DMUBCIDVec.clear();
2190  m_ROD_DMUmemoryErrVec.clear();
2191  m_ROD_DMUSstrobeErrVec.clear();
2192  m_ROD_DMUDstrobeErrVec.clear();
2193  m_ROD_DMUHeadformatErrVec.clear();
2194  m_ROD_DMUDataformatErrVec.clear();
2195  m_ROD_DMUMaskVec.clear();
2196 
2197  //Ntuple creation
2198 
2199  auto tree = std::make_unique<TTree>(m_ntupleID.value().c_str(), "TileBEAM-Ntuple");
2200  tree->SetMaxTreeSize(m_treeSize);
2201  m_ntuplePtr = tree.get();
2202  if (m_thistSvc->regTree("/" + m_streamName + "/" + m_ntupleID, std::move(tree)).isFailure()) {
2203  ATH_MSG_ERROR( "Problem registering TileRec Tree" );
2204  m_ntupleCreated = false;
2205  } else {
2206  m_ntupleCreated = true;
2207  }
2208 
2209  TRIGGER_addBranch();
2210  MUON_addBranch();
2211 
2212  if (m_TBperiod < 2015) {
2213  ECAL_addBranch();
2214  LASER_addBranch();
2215  ADDER_addBranch();
2216  ENETOTAL_addBranch();
2217  COINCBOARD_addBranch();
2218  }
2219 
2220  if (m_TBperiod > 2015) {
2221  QDC_addBranch();
2222  }
2223 
2224  CISPAR_addBranch();
2225  BEAM_addBranch();
2226  DIGI_addBranch(); //working now
2227  if (m_saveFelixData) {
2228  FELIX_addBranch();
2229  }
2230 
2231  HIT_addBranch();
2232 
2233  return StatusCode::SUCCESS;
2234 }

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

◆ LASER_addBranch()

void TileTBAANtuple::LASER_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2735 of file TileTBAANtuple.cxx.

2735  {
2736 
2737  if (!m_laserObjectKey.empty() > 0) {
2738 
2739  m_ntuplePtr->Branch("LASER_BCID", &m_las_BCID, "LASER_BCID/I");
2740 
2741  m_ntuplePtr->Branch("LASER_FILTER", &m_las_Filt, "LASER_FILTER/I");
2742  m_ntuplePtr->Branch("LASER_REQAMP", &m_las_ReqAmp, "LASER_REQAMP/D");
2743  m_ntuplePtr->Branch("LASER_MEASAMP", &m_las_MeasAmp, "LASER_MEASAMP/D");
2744 
2745  m_ntuplePtr->Branch("LASER_Diode_1_ADC", &m_las_D1_ADC, "LASER_Diode_1_ADC/I");
2746  m_ntuplePtr->Branch("LASER_Diode_2_ADC", &m_las_D2_ADC, "LASER_Diode_2_ADC/I");
2747  m_ntuplePtr->Branch("LASER_Diode_3_ADC", &m_las_D3_ADC, "LASER_Diode_3_ADC/I");
2748  m_ntuplePtr->Branch("LASER_Diode_4_ADC", &m_las_D4_ADC, "LASER_Diode_4_ADC/I");
2749 
2750  m_ntuplePtr->Branch("LASER_Diode_1_Ped", &m_las_D1_Ped, "LASER_Diode_1_Ped/D");
2751  m_ntuplePtr->Branch("LASER_Diode_2_Ped", &m_las_D2_Ped, "LASER_Diode_2_Ped/D");
2752  m_ntuplePtr->Branch("LASER_Diode_3_Ped", &m_las_D3_Ped, "LASER_Diode_3_Ped/D");
2753  m_ntuplePtr->Branch("LASER_Diode_4_Ped", &m_las_D4_Ped, "LASER_Diode_4_Ped/D");
2754 
2755  m_ntuplePtr->Branch("LASER_Diode_1_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_1_Ped_RMS/D");
2756  m_ntuplePtr->Branch("LASER_Diode_2_Ped_RMS", &m_las_D2_Ped_RMS, "LASER_Diode_2_Ped_RMS/D");
2757  m_ntuplePtr->Branch("LASER_Diode_3_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_3_Ped_RMS/D");
2758  m_ntuplePtr->Branch("LASER_Diode_4_Ped_RMS", &m_las_D1_Ped_RMS, "LASER_Diode_4_Ped_RMS/D");
2759 
2760  m_ntuplePtr->Branch("LASER_Diode_1_Alpha", &m_las_D1_Alpha, "LASER_Diode_1_Alpha/D");
2761  m_ntuplePtr->Branch("LASER_Diode_2_Alpha", &m_las_D2_Alpha, "LASER_Diode_2_Alpha/D");
2762  m_ntuplePtr->Branch("LASER_Diode_3_Alpha", &m_las_D3_Alpha, "LASER_Diode_3_Alpha/D");
2763  m_ntuplePtr->Branch("LASER_Diode_4_Alpha", &m_las_D4_Alpha, "LASER_Diode_4_Alpha/D");
2764 
2765  m_ntuplePtr->Branch("LASER_Diode_1_Alpha_RMS", &m_las_D1_Alpha_RMS, "LASER_Diode_1_Alpha_RMS/D");
2766  m_ntuplePtr->Branch("LASER_Diode_2_Alpha_RMS", &m_las_D2_Alpha_RMS, "LASER_Diode_2_Alpha_RMS/D");
2767  m_ntuplePtr->Branch("LASER_Diode_3_Alpha_RMS", &m_las_D3_Alpha_RMS, "LASER_Diode_3_Alpha_RMS/D");
2768  m_ntuplePtr->Branch("LASER_Diode_4_Alpha_RMS", &m_las_D4_Alpha_RMS, "LASER_Diode_4_Alpha_RMS/D");
2769 
2770  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed", &m_las_D1_AlphaPed, "LASER_Diode_1_AlphaPed/D");
2771  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed", &m_las_D2_AlphaPed, "LASER_Diode_2_AlphaPed/D");
2772  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed", &m_las_D3_AlphaPed, "LASER_Diode_3_AlphaPed/D");
2773  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed", &m_las_D4_AlphaPed, "LASER_Diode_4_AlphaPed/D");
2774 
2775  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed_RMS", &m_las_D1_AlphaPed_RMS, "LASER_Diode_1_AlphaPed_RMS/D");
2776  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed_RMS", &m_las_D2_AlphaPed_RMS, "LASER_Diode_2_AlphaPed_RMS/D");
2777  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed_RMS", &m_las_D3_AlphaPed_RMS, "LASER_Diode_3_AlphaPed_RMS/D");
2778  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed_RMS", &m_las_D4_AlphaPed_RMS, "LASER_Diode_4_AlphaPed_RMS/D");
2779 
2780  m_ntuplePtr->Branch("LASER_PMT_1_ADC", &m_las_PMT1_ADC, "LASER_PMT_1_ADC/I");
2781  m_ntuplePtr->Branch("LASER_PMT_2_ADC", &m_las_PMT2_ADC, "LASER_PMT_2_ADC/I");
2782 
2783  m_ntuplePtr->Branch("LASER_PMT_1_TDC", &m_las_PMT1_TDC, "LASER_PMT_1_TDC/I");
2784  m_ntuplePtr->Branch("LASER_PMT_2_TDC", &m_las_PMT2_TDC, "LASER_PMT_2_TDC/I");
2785 
2786  m_ntuplePtr->Branch("LASER_PMT_1_Ped", &m_las_PMT1_Ped, "LASER_PMT_1_Ped/D");
2787  m_ntuplePtr->Branch("LASER_PMT_2_Ped", &m_las_PMT2_Ped, "LASER_PMT_2_Ped/D");
2788 
2789  m_ntuplePtr->Branch("LASER_PMT_1_Ped_RMS", &m_las_PMT1_Ped_RMS, "LASER_PMT_1_Ped_RMS/D");
2790  m_ntuplePtr->Branch("LASER_PMT_2_Ped_RMS", &m_las_PMT2_Ped_RMS, "LASER_PMT_2_Ped_RMS/D");
2791 
2792  m_ntuplePtr->Branch("LASER_HEAD_Temp", &m_las_Temperature, "LASER_HEAD_Temp/D");
2793  }
2794 
2795  if (m_beamIdList[LASE_PTN_FRAG]) {
2796  m_ntuplePtr->Branch("LasFlag", &m_lasFlag, "LasFlag/s");
2797  }
2798 
2799  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2800  || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2801  m_ntuplePtr->Branch("Las0", &m_las0, "Las0/F");
2802  m_ntuplePtr->Branch("Las1", &m_las1, "Las1/F");
2803  m_ntuplePtr->Branch("Las2", &m_las2, "Las2/F");
2804  m_ntuplePtr->Branch("Las3", &m_las3, "Las3/F");
2805  m_ntuplePtr->Branch("LasExtra", &m_lasExtra, "m_lasExtra[4]/F");
2806  }
2807 
2808 }

◆ LASER_clearBranch()

void TileTBAANtuple::LASER_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variables

////////////////////////////////////////////////////////////////////////////

Definition at line 2816 of file TileTBAANtuple.cxx.

2817 {
2818 
2819  if (!m_laserObjectKey.empty()) {
2820 
2821  m_las_BCID = 0;
2822  m_las_D1_ADC = 0;
2823  m_las_D2_ADC = 0;
2824  m_las_D3_ADC = 0;
2825  m_las_D4_ADC = 0;
2826 
2827  m_las_D1_Ped = 0;
2828  m_las_D2_Ped = 0;
2829  m_las_D3_Ped = 0;
2830  m_las_D4_Ped = 0;
2831 
2832  m_las_D1_Alpha = 0;
2833  m_las_D2_Alpha = 0;
2834  m_las_D3_Alpha = 0;
2835  m_las_D4_Alpha = 0;
2836 
2837  m_las_PMT1_ADC = 0;
2838  m_las_PMT2_ADC = 0;
2839 
2840  m_las_PMT1_TDC = 0;
2841  m_las_PMT2_TDC = 0;
2842 
2843  m_las_PMT1_Ped = 0;
2844  m_las_PMT2_Ped = 0;
2845  }
2846 
2847  if (m_beamIdList[LASE_PTN_FRAG]) {
2848  m_lasFlag=0;
2849  }
2850 
2851  if ((m_unpackAdder && m_beamIdList[BEAM_ADC_FRAG])
2852  || (!m_unpackAdder && m_beamIdList[LASE_ADC_FRAG])) {
2853 
2854  m_las0 = 0.;
2855  m_las1 = 0.;
2856  m_las2 = 0.;
2857  m_las3 = 0.;
2858 
2859  }
2860 }

◆ LASEROBJ_addBranch()

void TileTBAANtuple::LASEROBJ_addBranch ( void  )
private

◆ LASEROBJ_clearBranch()

void TileTBAANtuple::LASEROBJ_clearBranch ( void  )
private

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ MUON_addBranch()

void TileTBAANtuple::MUON_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add MUON variables to the Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2618 of file TileTBAANtuple.cxx.

2619 {
2620 
2621  if ( m_beamIdList[MUON_ADC_FRAG] ||
2622  m_beamIdList[ADDR_ADC_FRAG] )
2623  {
2624  m_ntuplePtr->Branch("MuBackHit",&m_muBackHit,"MuBackHit/F");
2625  m_ntuplePtr->Branch("MuBackSum",&m_muBackSum,"MuBackSum/F");
2626 
2627  if (m_TBperiod < 2015) {
2628  m_ntuplePtr->Branch("MuBack",&m_muBack,"m_muBack[14]");
2629  m_ntuplePtr->Branch("MuCalib",&m_muCalib,"m_muCalib[2]");
2630  } else if (m_TBperiod == 2015) {
2631  m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[8]/F");
2632  } else {
2633  m_ntuplePtr->Branch("MuBack",&m_muBack,"MuBack[12]/F");
2634  }
2635  }
2636 
2637 
2638 }

◆ MUON_clearBranch()

void TileTBAANtuple::MUON_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree MUON variables

////////////////////////////////////////////////////////////////////////////

Definition at line 2700 of file TileTBAANtuple.cxx.

2700  {
2701  m_muBackHit = 0.;
2702  m_muBackSum = 0.;
2703 
2704 }

◆ ntuple_clear()

StatusCode TileTBAANtuple::ntuple_clear ( )

Definition at line 2076 of file TileTBAANtuple.cxx.

2076  {
2077 
2078  TRIGGER_clearBranch();
2079 
2080  if (m_beamIdList[MUON_ADC_FRAG] || m_beamIdList[ADDR_ADC_FRAG]) {
2081  MUON_clearBranch();
2082  }
2083 
2084  if (m_beamIdList[ECAL_ADC_FRAG]) {
2085  ECAL_clearBranch();
2086  if (m_TBperiod > 2015) QDC_clearBranch();
2087  }
2088 
2089  LASER_clearBranch();
2090 
2091  if (m_unpackAdder) {
2092  if (m_beamIdList[ADD_FADC_FRAG]) {
2093  ADDER_clearBranch();
2094  }
2095  }
2096 
2097  if (m_beamIdList[DIGI_PAR_FRAG & 0x1F]) {
2098  CISPAR_clearBranch();
2099  }
2100 
2101  if (((m_TBperiod >= 2015 || m_unpackAdder) && m_beamIdList[BEAM_ADC_FRAG])
2102  || (!m_unpackAdder && m_beamIdList[COMMON_ADC1_FRAG])
2103  || (m_TBperiod >= 2022 && m_beamIdList[COMMON_TOF_FRAG])) {
2104  BEAM_clearBranch();
2105  ATH_MSG_VERBOSE( "clear branch");
2106  }
2107 
2108  if (m_completeNtuple && m_TBperiod < 2015) {
2109  ENETOTAL_clearBranch();
2110  }
2111 
2112  COINCBOARD_clearBranch();
2113 
2114  DIGI_clearBranch(); // working now
2115  if (m_saveFelixData) {
2116  FELIX_clearBranch();
2117  }
2118 
2119  HIT_clearBranch();
2120  ATH_MSG_DEBUG( "clear() successfully" );
2121 
2122  return StatusCode::SUCCESS;
2123 }

◆ ntuple_initialize()

StatusCode TileTBAANtuple::ntuple_initialize ( const EventContext &  ctx)

Alg standard interface function LF TODO: We could have a problem with the new feature introduced by Sasha that quit empty fragments and therefore it can increase or decrease the number of RawChannels fragments dynamically.

The code seems to be capable of react if a module is missing during a run, but if rawchans for a module appear after the beginning of a run (ntuple varialbes are branched af the beginnning of run), its quantities will not be in the ntuple.

if first event: determine mode (normal or calib) by examining the first TileDigitCollection initialize NTuple accordingly

Definition at line 241 of file TileTBAANtuple.cxx.

241  {
242 
243  CHECK( m_thistSvc.retrieve() );
244 
245  // find TileCablingService
246  m_cabling = TileCablingService::getInstance();
247 
248  // retrieve TileID helper from det store
249 
250  CHECK( detStore()->retrieve(m_tileID) );
251 
252  CHECK( detStore()->retrieve(m_tileHWID) );
253 
254  if (m_nSamples < 0) {
255  m_nSamples = 7;
256  }
257  if (m_nSamplesFlx < 0) {
258  m_nSamplesFlx = m_saveFelixData ? 32 : 0;
259  }
260 
261  if (m_TBperiod >= 2015) {
262  m_unpackAdder = false;
263 
264  if (m_TBperiod == 2015) {
265  m_nDrawers = 2;
266  m_drawerList.value().resize(m_nDrawers);
267  m_drawerType.value().resize(m_nDrawers);
268  m_drawerList[0] = "0x200"; m_drawerType[0] = 2; // barrel neg
269  m_drawerList[1] = "0x401"; m_drawerType[1] = 4; // ext.barrel neg
270  } else if (m_TBperiod == 2016 || m_TBperiod == 2018 || m_TBperiod == 2021 || m_TBperiod == 2022) {
271  m_nDrawers = 5;
272  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
273  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
274  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
275  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
276  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
277  m_drawerList[4] = "0x402"; m_drawerType[4] = 4; // ext.barrel neg
278  } else if (m_TBperiod == 2017) {
279  m_nDrawers = 6;
280  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
281  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
282  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
283  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
284  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
285  m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
286  m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
287  } else if (m_TBperiod == 2019) {
288  m_nDrawers = 7;
289  m_drawerList.value().resize(m_nDrawers); m_drawerType.value().resize(m_nDrawers);
290  m_drawerList[0] = "0x100"; m_drawerType[0] = 1; // M0 pos
291  m_drawerList[1] = "0x101"; m_drawerType[1] = 1; // barrel pos
292  m_drawerList[2] = "0x200"; m_drawerType[2] = 2; // M0 neg
293  m_drawerList[3] = "0x201"; m_drawerType[3] = 2; // barrel neg
294  m_drawerList[4] = "0x203"; m_drawerType[4] = 2; // barrel neg
295  m_drawerList[5] = "0x402"; m_drawerType[5] = 4; // ext.barrel neg
296  m_drawerList[6] = "0x405"; m_drawerType[6] = 4; // ext.barrel neg
297  }
298 
299  if (m_TBperiod < 2016) {
300  setupBeamChambersTB2015();
301  } else if (m_TBperiod < 2021) {
302  setupBeamChambersTB2016_2020();
303  } else {
304  // Strating from 2021 the following properties should be setup via JO
305  checkIsPropertySetup(m_beamBC1X1, "BC1X1");
306  checkIsPropertySetup(m_beamBC1X2, "BC1X2");
307  checkIsPropertySetup(m_beamBC1Y1, "BC1Y1");
308  checkIsPropertySetup(m_beamBC1Y2, "BC1Y2");
309  checkIsPropertySetup(m_beamBC1Z, "BC1Z");
310  checkIsPropertySetup(m_beamBC1Z_0, "BC1Z_0");
311  checkIsPropertySetup(m_beamBC1Z_90, "BC1Z_90");
312  checkIsPropertySetup(m_beamBC1Z_min90, "BC1Z_min90");
313 
314  checkIsPropertySetup(m_beamBC2X1, "BC2X1");
315  checkIsPropertySetup(m_beamBC2X2, "BC2X2");
316  checkIsPropertySetup(m_beamBC2Y1, "BC2Y1");
317  checkIsPropertySetup(m_beamBC2Y2, "BC2Y2");
318  checkIsPropertySetup(m_beamBC2Z, "BC2Z");
319  checkIsPropertySetup(m_beamBC2Z_0, "BC2Z_0");
320  checkIsPropertySetup(m_beamBC2Z_90, "BC2Z_90");
321  checkIsPropertySetup(m_beamBC2Z_min90, "BC2Z_min90");
322  }
323 
324  } else {
325  setupBeamChambersBeforeTB2015();
326  }
327 
328 
329  if (m_unpackAdder) {
330  // get TileRawChannelBuilderFlatFilter for adder energy calculation
331 
332  StatusCode sc;
333  sc &= m_adderFilterAlgTool->setProperty("TileRawChannelContainer", "TileAdderFlat");
334  sc &= m_adderFilterAlgTool->setProperty("calibrateEnergy", "true");
335 
336  sc &= m_adderFilterAlgTool->setProperty("PedStart", "0");
337  sc &= m_adderFilterAlgTool->setProperty("PedLength", "1");
338  sc &= m_adderFilterAlgTool->setProperty("PedOffset", "0");
339  sc &= m_adderFilterAlgTool->setProperty("SignalStart", "1");
340  sc &= m_adderFilterAlgTool->setProperty("SignalLength", "15");
341  sc &= m_adderFilterAlgTool->setProperty("FilterLength", "5");
342  sc &= m_adderFilterAlgTool->setProperty("FrameLength", "16");
343  sc &= m_adderFilterAlgTool->setProperty("DeltaCutLo", "9.5");
344  sc &= m_adderFilterAlgTool->setProperty("DeltaCutHi", "9.5");
345  sc &= m_adderFilterAlgTool->setProperty("RMSCutLo", "1.0");
346  sc &= m_adderFilterAlgTool->setProperty("RMSCutHi", "1.0");
347  if (sc.isFailure()) {
348  ATH_MSG_ERROR("Failure setting properties of " << m_adderFilterAlgTool);
349  return StatusCode::FAILURE;
350  }
351  }
352 
353  if (m_finalUnit < TileRawChannelUnit::ADCcounts
354  || m_finalUnit > TileRawChannelUnit::OnlineMegaElectronVolts) {
355 
356  m_finalUnit = -1;
357  if (!m_useDspUnits && m_calibrateEnergy) {
358  m_useDspUnits = true;
359  ATH_MSG_INFO( "Final offline units are not set, will use DSP units" );
360  }
361  }
362 
363  if (!m_calibrateEnergy) {
364  if (m_useDspUnits) {
365  ATH_MSG_INFO( "calibrateEnergy is disabled, don't want to use DSP units" );
366  m_useDspUnits = false;
367  }
368  }
369 
370  ATH_MSG_INFO( "TestBeam period " << m_TBperiod.value() );
371  ATH_MSG_INFO( "calibMode " << m_calibMode.value() );
372  ATH_MSG_INFO( "calibrateEnergy " << m_calibrateEnergy.value() );
373  ATH_MSG_INFO( "offlineUnits " << m_finalUnit.value() );
374  ATH_MSG_INFO( "useDspUnits " << m_useDspUnits.value() );
375  ATH_MSG_INFO( "number of samples " << m_nSamples.value() );
376 
377 
378  msg(MSG::INFO) << "drawerList " << MSG::hex;
379  unsigned int size = m_drawerList.size();
380  for (unsigned int dr = 0; dr < size; ++dr) {
381  int frag = strtol(m_drawerList[dr].data(), NULL, 0);
382  if (frag >= 0) {
383  m_drawerMap[frag] = dr;
384  if (dr == m_drawerType.size()) m_drawerType.value().push_back(frag >> 8);
385  msg(MSG::INFO) << " 0x" << frag;
386  } else {
387  msg(MSG::INFO) << " " << m_drawerList[dr];
388  // put negative number in first element (flag to read frag ID from data)
389  m_drawerList[0] = m_drawerList[dr];
390  m_drawerList.value().resize(1);
391  // m_drawerType.clear();
392  m_drawerMap.clear();
393  size = 0;
394  break;
395  }
396  }
397  if (size == 0) {
398  if (m_drawerList.size() > 0)
399  msg(MSG::INFO) << " - negative number, will read frag IDs from the data" << MSG::dec << endmsg;
400  else
401  msg(MSG::INFO) << "is empty, no drawer fragments in ntuple" << MSG::dec << endmsg;
402  } else {
403  msg(MSG::INFO) << MSG::dec << endmsg;
404 
405  size = m_drawerType.size();
406  if (size < m_nDrawers) {
407  m_drawerType.value().resize(m_nDrawers);
408  for (; size < m_nDrawers; ++size)
409  m_drawerType[size] = 0;
410  }
411 
412  msg(MSG::INFO) << MSG::INFO << "drawerType ";
413  for (unsigned int dr = 0; dr < size; ++dr)
414  msg(MSG::INFO) << " " << m_drawerType[dr];
415  msg(MSG::INFO) << endmsg;
416 
417  if (size > m_nDrawers) {
418  ATH_MSG_INFO( "increasing m_nDrawers from " << m_nDrawers << " to " << size );
419  m_nDrawers = size;
420  }
421  }
422 
423  msg(MSG::INFO) << MSG::INFO << "Beam Frag List " << MSG::hex;
424  size = m_beamFragList.size();
425  for (unsigned int dr = 0; dr < size; ++dr) {
426  int frag = strtol(m_beamFragList[dr].data(), NULL, 0);
427  if (frag >= 0) {
428  m_beamIdList[frag & 0x1F] = true;
429  msg(MSG::INFO) << " 0x" << frag;
430  }
431  }
432  if (size == 0) {
433  msg(MSG::INFO) << "is empty, no beam fragments in ntuple" << MSG::dec << endmsg;
434  } else {
435  msg(MSG::INFO) << MSG::dec << endmsg;
436  }
437 
438  // set event number to 0 before first event
439  m_evtNr = 0;
440  m_calibrateEnergyThisEvent = m_calibrateEnergy;
441 
442  // find event and beam ROD header, calib mode for digitizers
443 
447  if (m_evtNr == 0) {
448  if (m_unpackAdder) // in 2003 event number starts from 1
449  ++m_evtNr;
450  }
451 
452  if (initList(ctx).isFailure()) {
453  ATH_MSG_ERROR( " Error during drawer list initialization" );
454  }
455 
456  if (m_saveFelixData && initListFlx(ctx).isFailure()) {
457  ATH_MSG_ERROR( " Error during drawer list initialization" );
458  }
459 
460  if (initNTuple().isFailure()) {
461  ATH_MSG_ERROR( " Error during ntuple initialization" );
462  }
463 
464  ATH_MSG_INFO( "initialization completed" );
465  return StatusCode::SUCCESS;
466 }

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

◆ QDC_addBranch()

void TileTBAANtuple::QDC_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add QDC variables to the Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2661 of file TileTBAANtuple.cxx.

2662 {
2663 
2664  if (m_beamIdList[ECAL_ADC_FRAG]) {
2665  for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2666  m_ntuplePtr->Branch("qdc", &m_qdc, "qdc[33]/i");
2667  }
2668 
2669 }

◆ QDC_clearBranch()

void TileTBAANtuple::QDC_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree QDC variables

////////////////////////////////////////////////////////////////////////////

Definition at line 2723 of file TileTBAANtuple.cxx.

2724 {
2725  for(unsigned i=0; i<33; ++i){ m_qdc[i]=0.0; }
2726 }

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setupBeamChambersBeforeTB2015()

void TileTBAANtuple::setupBeamChambersBeforeTB2015 ( void  )
private

Definition at line 3878 of file TileTBAANtuple.cxx.

3878  {
3879  // Setup default value for the following properties, if they are not setup via JO
3880  setupPropertyDefaultValue(m_beamBC1X1, -0.938, "BC1X1");
3881  setupPropertyDefaultValue(m_beamBC1X2, 0.1747, "BC1X2");
3882  setupPropertyDefaultValue(m_beamBC1Y1, 0.125, "BC1Y1");
3883  setupPropertyDefaultValue(m_beamBC1Y2, 0.1765, "BC1Y2");
3884  setupPropertyDefaultValue(m_beamBC1Z, 13788.0, "BC1Z");
3885  setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3886  setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3887  setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3888 
3889  setupPropertyDefaultValue(m_beamBC2X1, -0.9369, "BC2X1");
3890  setupPropertyDefaultValue(m_beamBC2X2, 0.191, "BC2X2");
3891  setupPropertyDefaultValue(m_beamBC2Y1, -1.29, "BC2Y1");
3892  setupPropertyDefaultValue(m_beamBC2Y2, 0.187, "BC2Y2");
3893  setupPropertyDefaultValue(m_beamBC2Z, 9411.0, "BC2Z");
3894  setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3895  setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3896  setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3897 }

◆ setupBeamChambersTB2015()

void TileTBAANtuple::setupBeamChambersTB2015 ( void  )
private

Definition at line 3899 of file TileTBAANtuple.cxx.

3899  {
3900  setupPropertyDefaultValue(m_beamBC1X1, -0.0462586, "BC1X1");
3901  setupPropertyDefaultValue(m_beamBC1X2, -0.175666, "BC1X2");
3902  setupPropertyDefaultValue(m_beamBC1Y1, -0.051923, "BC1Y1");
3903  setupPropertyDefaultValue(m_beamBC1Y2, -0.176809, "BC1Y2");
3904  setupPropertyDefaultValue(m_beamBC1Z, 13000. + 2760, "BC1Z");
3905  setupPropertyDefaultValue(m_beamBC1Z_0, 13788.0, "BC1Z_0");
3906  setupPropertyDefaultValue(m_beamBC1Z_90, 13788.0, "BC1Z_90");
3907  setupPropertyDefaultValue(m_beamBC1Z_min90, 13788.0, "BC1Z_min90");
3908 
3909  setupPropertyDefaultValue(m_beamBC2X1, 0.25202, "BC2X1");
3910  setupPropertyDefaultValue(m_beamBC2X2, -0.18053, "BC2X2");
3911  setupPropertyDefaultValue(m_beamBC2Y1, 0.0431688, "BC2Y1");
3912  setupPropertyDefaultValue(m_beamBC2Y2, -0.181128, "BC2Y2");
3913  setupPropertyDefaultValue(m_beamBC2Z, 2760, "BC2Z");
3914  setupPropertyDefaultValue(m_beamBC2Z_0, 9411.0, "BC2Z_0");
3915  setupPropertyDefaultValue(m_beamBC2Z_90, 9411.0, "BC2Z_90");
3916  setupPropertyDefaultValue(m_beamBC2Z_min90, 9411.0, "BC2Z_min90");
3917 }

◆ setupBeamChambersTB2016_2020()

void TileTBAANtuple::setupBeamChambersTB2016_2020 ( void  )
private

Definition at line 3919 of file TileTBAANtuple.cxx.

3919  {
3920  // 2016 settings:
3921  //
3922  // https://pcata007.cern.ch/elog/TB2016/88
3923  //
3924  //
3925  // The calibration has been done with the following runs :
3926  // BC1:
3927  // Center : 610212
3928  // Left/up : 610210
3929  // Right/down : 610209
3930  //
3931  // BC2:
3932  // Center : 610256
3933  // Left/up : 610321
3934  // Right/down : 610320
3935  //
3936  // Here are the new constants :
3937  //
3938  // BC1
3939  // horizontal slope = -0.171928
3940  // horizontal offset = -0.047624
3941  //
3942  // vertical slope = -0.172942
3943  // vertical offset = -0.0958677
3944  //
3945  // BC2
3946  // horizontal slope = -0.175698
3947  // horizontal offset = -1.04599
3948  //
3949  // vertical slope = -0.174535
3950  // vertical offset = -3.10666
3951 
3952  // June 2016 calibration
3953  //m_beamBC1X1 = -0.047624;
3954  //m_beamBC1X2 = -0.171928;
3955  //m_beamBC1Y1 = -0.0958677;
3956  //m_beamBC1Y2 = -0.172942;
3957  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3958 
3959  //m_beamBC2X1 = -1.04599;
3960  //m_beamBC2X2 = -0.175698;
3961  //m_beamBC2Y1 = -3.10666;
3962  //m_beamBC2Y2 = -0.174535;
3963  //m_beamBC2Z = 2760 /* 2600. */;
3964 
3965  // September 2016 calibration, https://pcata007.cern.ch/elog/TB2016/300 (joakim.olsson@cern.ch)
3966  //m_beamBC1X1 = 0.100857923042;
3967  //m_beamBC1X2 = -0.172098;
3968  //m_beamBC1Y1 = -0.133045996607;
3969  //m_beamBC1Y2 = -0.172855178323;
3970  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3971  //
3972  //m_beamBC2X1 = 0.271555258578 ;
3973  //m_beamBC2X2 = -0.173463 ;
3974  //m_beamBC2Y1 = 0.305483228502;
3975  //m_beamBC2Y2 = -0.173805131744 ;
3976  //m_beamBC2Z = 2760 /* 2600. */;
3977 
3978  // June 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3979  //m_beamBC1X1 = 0.153584934082;
3980  //m_beamBC1X2 = -0.175220;
3981  //m_beamBC1Y1 = -0.493246053303;
3982  //m_beamBC1Y2 = -0.176567356723;
3983  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3984  //
3985  //m_beamBC2X1 = 0.414611893278;
3986  //m_beamBC2X2 = -0.176122;
3987  //m_beamBC2Y1 = 0.150807740888;
3988  //m_beamBC2Y2 = -0.173472808704;
3989  //m_beamBC2Z = 2760 /* 2600. */;
3990 
3991  // August 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
3992  //m_beamBC1X1 = 0.181797;
3993  //m_beamBC1X2 = -0.175657;
3994  //m_beamBC1Y1 = -0.128910;
3995  //m_beamBC1Y2 = -0.175965;
3996  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
3997  //
3998  //m_beamBC2X1 = 0.611502;
3999  //m_beamBC2X2 = -0.183116;
4000  //m_beamBC2Y1 = 0.541212;
4001  //m_beamBC2Y2 = -0.183115;
4002  //m_beamBC2Z = 2760 /* 2600. */;
4003 
4004  // September 2017 calibration, https://pcata007.cern.ch/elog/TB2017/550 (schae@cern.ch)
4005  //m_beamBC1X1 = 0.181797;
4006  //m_beamBC1X2 = -0.175657;
4007  //m_beamBC1Y1 = -0.128910;
4008  //m_beamBC1Y2 = -0.175965;
4009  //m_beamBC1Z = 13000. + 2760 /* 2600. */;
4010 
4011  //m_beamBC2X1 = 0.622896039922;
4012  //m_beamBC2X2 = -0.176735;
4013  //m_beamBC2Y1 = 0.195954125116;
4014  //m_beamBC2Y2 = -0.176182117624;
4015  //m_beamBC2Z = 2760 /* 2600. */;
4016 
4017  // September 2017 calibration with additional precision from Survey
4018  setupPropertyDefaultValue(m_beamBC1X1, 0.681797, "BC1X1");
4019  setupPropertyDefaultValue(m_beamBC1X2, -0.175657, "BC1X2");
4020  setupPropertyDefaultValue(m_beamBC1Y1, -2.02891, "BC1Y1");
4021  setupPropertyDefaultValue(m_beamBC1Y2, -0.175965, "BC1Y2");
4022  setupPropertyDefaultValue(m_beamBC1Z, 17348.8, "BC1Z");
4023  setupPropertyDefaultValue(m_beamBC1Z_0, 17348.8, "BC1Z_0");
4024  setupPropertyDefaultValue(m_beamBC1Z_90, 15594.05, "BC1Z_90");
4025  setupPropertyDefaultValue(m_beamBC1Z_min90, 15571.8, "BC1Z_min90");
4026 
4027  setupPropertyDefaultValue(m_beamBC2X1, -24.377104, "BC2X1");
4028  setupPropertyDefaultValue(m_beamBC2X2, -0.176735, "BC2X2");
4029  setupPropertyDefaultValue(m_beamBC2Y1, 17.895954, "BC2Y1");
4030  setupPropertyDefaultValue(m_beamBC2Y2, -0.176182117624, "BC2Y2");
4031  setupPropertyDefaultValue(m_beamBC2Z, 4404.2, "BC2Z");
4032  setupPropertyDefaultValue(m_beamBC2Z_0, 4420.7, "BC2Z_0");
4033  setupPropertyDefaultValue(m_beamBC2Z_90, 2649.45, "BC2Z_90");
4034  setupPropertyDefaultValue(m_beamBC2Z_min90, 2627.2, "BC2Z_min90");
4035 
4036 }

◆ setupPropertyDefaultValue()

void TileTBAANtuple::setupPropertyDefaultValue ( float  property,
float  defaultValue,
const std::string &  name 
)
inlineprivate

Definition at line 328 of file TileTBAANtuple.h.

328  {
329  if (property < NOT_SETUP) {
330  property = defaultValue;
331  ATH_MSG_INFO("The following property is not set up via JO, using default value: " << name << "=" << defaultValue);
332  }
333  }

◆ storeBeamElements()

StatusCode TileTBAANtuple::storeBeamElements ( const EventContext &  ctx)
private

Definition at line 632 of file TileTBAANtuple.cxx.

632  {
633 
634  if ( m_beamElemContainerKey.empty()) {
635  return StatusCode::SUCCESS;
636  }
637 
638  // Read Beam Elements from TES
639  const TileBeamElemContainer* beamElemCnt = SG::makeHandle (m_beamElemContainerKey, ctx).get();
640 
641  TileBeamElemContainer::const_iterator collItr = beamElemCnt->begin();
642  TileBeamElemContainer::const_iterator lastColl = beamElemCnt->end();
643 
644  if ( m_completeNtuple ) {
645  // Store ROD header info from collection (just from first one)
646  int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
647  if ( collItr!=lastColl ) {
648  m_l1ID.at(nDrawersAll) = (*collItr)->getLvl1Id();
649  m_l1Type.at(nDrawersAll) = (*collItr)->getLvl1Type();
650  m_evType.at(nDrawersAll) = (*collItr)->getDetEvType();
651  m_evBCID.at(nDrawersAll) = (*collItr)->getRODBCID();
652  } else {
653  m_l1ID.at(nDrawersAll) = 0xFFFFFFFF;
654  m_l1Type.at(nDrawersAll) = 0xFFFFFFFF;
655  m_evType.at(nDrawersAll) = 0xFFFFFFFF;
656  m_evBCID.at(nDrawersAll) = 0xFFFFFFFF;
657  }
658  }
659 
660 
661  m_trigType = 0;
662 
663  for(; collItr != lastColl; ++collItr) {
664 
665  TileBeamElemCollection::const_iterator beamItr=(*collItr)->begin();
666  TileBeamElemCollection::const_iterator lastBeam=(*collItr)->end();
667 
668  if (msgLvl(MSG::VERBOSE)) {
669 
670  for (; beamItr != lastBeam; ++beamItr) {
671  HWIdentifier id = (*beamItr)->adc_HWID();
672  std::vector<uint32_t> digits = (*beamItr)->get_digits();
673  msg(MSG::VERBOSE) << " --- TileBeamElem -- Identifier " << m_tileHWID->to_string(id)
674  << MSG::hex << " frag: 0x" << (*collItr)->identify()
675  << MSG::dec << " channel " << m_tileHWID->channel(id)
676  << " digits size " << digits.size() << endmsg;
677  msg(MSG::VERBOSE) << " --- TileBeamElem -- BeamElem : ";
678  for (unsigned int k = 0; k < digits.size(); k++)
679  msg(MSG::VERBOSE) << digits[k] << " ";
680  msg(MSG::VERBOSE) << endmsg;
681  }
682  //restore iterator
683  beamItr = (*collItr)->begin();
684  }
685 
686  int frag = (*collItr)->identify();
687  ATH_MSG_DEBUG( " frag: " << frag );
688  ATH_MSG_DEBUG( " trigType " << (*collItr)->getLvl1Type() );
689 
690  if ( m_trigType == 0 && (*collItr)->getLvl1Type() != 0 ) // take it from the ROD header
691  m_trigType = (*collItr)->getLvl1Type();
692 
693  // unpack only fragments which we want to store in ntuple
694  if ( m_beamIdList[frag&0x1F] ) {
695 
696  for (; beamItr != lastBeam; ++beamItr) {
697 
698  HWIdentifier id = (*beamItr)->adc_HWID();
699  std::vector<uint32_t> digits = (*beamItr)->get_digits();
700  int cha = m_tileHWID->channel(id);
701  int dsize = digits.size();
702 
703  if ( dsize <= 0 ) {
704 
705  WRONG_SAMPLE(frag,cha,dsize);
706 
707  } else if ( dsize != 16 && frag == ADD_FADC_FRAG ) {
708 
709  WRONG_SAMPLE(frag,cha,dsize);
710 
711  } else if ( dsize != 1 && frag != ADD_FADC_FRAG &&
712  frag != BEAM_TDC_FRAG && frag != COMMON_TDC1_FRAG &&
713  frag != COMMON_TOF_FRAG && frag != COMMON_TDC2_FRAG &&
714  !(frag == ECAL_ADC_FRAG)) {
715 
716  WRONG_SAMPLE(frag,cha,dsize);
717 
718  } else {
719 
720  uint32_t amplitude = digits[0];
721  SIGNAL_FOUND(frag, cha, amplitude);
722 
723  switch (frag) {
724 
725  case BEAM_TDC_FRAG:
726 
727  FRAG_FOUND(frag,cha,dsize);
728  if(cha < 8) m_btdc1[cha] = amplitude;
729  else if(cha < 16) m_btdc2[cha-8] = amplitude;
730  else WRONG_CHANNEL(frag,cha);
731  break;
732 
733  case BEAM_ADC_FRAG:
734 
735  if ( m_TBperiod >= 2015 ) {
736  switch(cha) {
737  // BEAM
738  case 0: m_s1cou = amplitude; break;
739  case 1: m_s2cou = amplitude; break;
740  case 2: m_s3cou = amplitude; break;
741  case 3: m_cher1 = amplitude; break; // ATH_MSG_VERBOSE("load beam adc " << m_cher1); break;
742  case 4: m_cher2 = amplitude; break;
743  case 5: m_muTag = amplitude; break;
744  case 6: m_muHalo= amplitude; break;
745  case 7: m_muVeto= amplitude; break;
746  default: WRONG_CHANNEL(frag, cha);
747  }
748  } else if ( m_unpackAdder ) {
749  switch(cha) {
750  // BEAM
751  case 0: m_s1cou = amplitude; break;
752  case 1: m_s2cou = amplitude; break;
753  case 2: m_s3cou = amplitude; break;
754  case 3: m_cher1 = amplitude; break; // swap of Cher1
755  case 4: m_muTag = amplitude; break; // and S4 in 2003 data
756  case 5: m_cher2 = amplitude; break;
757  case 6: m_muHalo= amplitude; break;
758  case 7: m_muVeto= amplitude; break;
759  // LASER
760  case 8: m_las0 = amplitude; break;
761  case 9: m_las1 = amplitude; break;
762  case 10: m_las2 = amplitude; break;
763  case 11: m_las3 = amplitude; break;
764  case 12: m_lasExtra[0] = amplitude; break;
765  case 13: m_lasExtra[1] = amplitude; break;
766  case 14: m_lasExtra[2] = amplitude; break;
767  case 15: m_lasExtra[3] = amplitude; break;
768  default: WRONG_CHANNEL(frag, cha);
769  }
770  } else { // 2004 data
771  switch(cha) {
772  // BEAM
773  case 0: m_sc1 = amplitude; break;
774  case 1: m_sc2 = amplitude; break;
775  case 2:
776  case 3:
777  case 4:
778  case 5:
779  case 6:
780  case 7: break;
781  default: WRONG_CHANNEL(frag, cha);
782  }
783  }
784  break;
785 
786  case MUON_ADC_FRAG:
787 
788  // first 14 are m_muBack
789  if(cha < 14) m_muBack[cha] = amplitude;
790  // last 2 are m_muCalib
791  else if (cha < 16) m_muCalib[cha - 14] = amplitude;
792  else WRONG_CHANNEL(frag, cha);
793  break;
794 
795  case ADDR_ADC_FRAG:
796 
797  // second half of Muon Wall in 2004
798  if(cha < 6) m_muBack[cha + 8] = amplitude;
799  // last 2 are m_muCalib
800  else if (cha < 8) m_muCalib[cha - 6] = amplitude;
801  else WRONG_CHANNEL(frag,cha);
802  break;
803 
804  case LASE_PTN_FRAG:
805 
806  if (cha == 0) {
807  // laser pattern unit
808  m_lasFlag = amplitude;
809  if (amplitude & 0xFF00) m_trigType = amplitude >> 8;
810  } else {
811  WRONG_CHANNEL(frag, cha);
812  }
813  break;
814 
815  case LASE_ADC_FRAG:
816 
817  // laser in 2004
818  switch(cha) {
819  case 0: m_las0 = amplitude; break;
820  case 1: m_las1 = amplitude; break;
821  case 2: m_las2 = amplitude; break;
822  case 3: m_las3 = amplitude; break;
823  case 4: m_lasExtra[0] = amplitude; break;
824  case 5: m_lasExtra[1] = amplitude; break;
825  case 6: m_lasExtra[2] = amplitude; break;
826  case 7: m_lasExtra[3] = amplitude; break;
827  default: WRONG_CHANNEL(frag,cha);
828  }
829  break;
830 
831  case ADD_FADC_FRAG:
832 
833  if (m_unpackAdder) {
834 
835  for (int k = 0; k < dsize; k++) {
836  //m_addx[k]=k;
837  //check how the matrix is filled
838  m_adder[cha][k] = digits[k];
839  }
840  // FlatFiler adders
841  double ene, tim;
842  m_adderFilterAlgTool->flatFilter(digits, 0, ene, tim);
843  m_eneAdd[cha] = ene;
844  m_timeAdd[cha] = tim;
845  }
846 
847  break;
848 
849  case ECAL_ADC_FRAG:
850 
851  if (m_TBperiod > 2015) {
852 
853  if(cha < 15) {
854  m_qdc[cha] = amplitude;
855  ATH_MSG_VERBOSE( "QDC: " << cha << " amp: " << amplitude);
856  } else if (cha == 15) {
857  for (int idx = 0; idx < dsize && idx < 18; ++idx) {
858  m_qdc[idx + 15] = digits[idx];
859  ATH_MSG_VERBOSE("QDC2: " << cha << " amp: " << amplitude);
860  }
861  } else {
862  WRONG_CHANNEL(frag, cha);
863  }
864 
865  } else {
866  if(cha < 8) m_ecal[cha] = amplitude;
867  else WRONG_CHANNEL(frag, cha);
868  }
869 
870  break;
871 
872  case DIGI_PAR_FRAG:
873 
874  if(cha < 16) m_cispar[cha] = amplitude; //m_cispar->at(cha)=amplitude;
875  else WRONG_CHANNEL(frag,cha);
876  break;
877 
878  case COMMON_ADC1_FRAG:
879  if (m_TBperiod > 2015) {
880  if (cha < 16) {
881  if (m_run > 2211444) {
882  switch(cha) {
883  // BEAM
884  case 0: m_s1cou = amplitude; break;
885  case 1: m_s2cou = amplitude; break;
886  case 2: {
887  if (m_run < 2310000) {
888  m_muBack[10] = amplitude;
889  } else {
890  m_s3cou = amplitude;
891  }
892  }
893  break;
894  case 3: m_cher1 = amplitude; break;
895  case 4: m_cher2 = amplitude; break;
896  case 5: m_cher3 = amplitude; break;
897  default: m_muBack[cha - 6] = amplitude;
898  }
899  } else {
900  switch(cha) {
901  // BEAM
902  case 0: m_s1cou = amplitude; break;
903  case 1: m_s2cou = amplitude; break;
904  case 2: m_s3cou = amplitude; break;
905  case 3: m_cher1 = amplitude; break;
906  case 4: m_cher2 = amplitude; break;
907  case 5: m_cher3 = amplitude; break;
908  }
909  }
910  } else {
911  WRONG_CHANNEL(frag, cha);
912  }
913  } else {
914  switch(cha) {
915  // BEAM
916  case 0: m_s1cou = amplitude; break;
917  case 1: m_s2cou = amplitude; break;
918  case 2: m_s3cou = amplitude; break;
919  case 3: m_muTag = amplitude; break;
920  case 4: m_cher1 = amplitude; break;
921  case 5: m_cher2 = amplitude; break;
922  case 6: m_muHalo= amplitude; break;
923  case 7: m_muVeto= amplitude; break;
924  default: WRONG_CHANNEL(frag, cha);
925  }
926  }
927  break;
928 
929  case COMMON_ADC2_FRAG:
930 
931  if (m_TBperiod > 2015) {
932  if(cha < 14) {
933  m_muBack[cha] = amplitude;
934  } else {
935  WRONG_CHANNEL(frag, cha);
936  }
937  } else {
938  if ( ! m_unpackAdder ) {
939  switch(cha) {
940  // BEAM
941  case 0: break;
942  case 1: m_s2extra = amplitude; break;
943  case 2: m_s3extra = amplitude; break;
944  case 3:
945  case 4:
946  case 5:
947  case 6:
948  case 7: break;
949  default: WRONG_CHANNEL(frag, cha);
950  }
951  }
952  }
953  break;
954 
955  case COMMON_PTN_FRAG:
956  if (m_run > 2310000 && cha < 16) {
957  m_scaler[cha] = amplitude;
958  } else if (cha == 0) {
959  m_commonPU = amplitude;
960  } else {
961  WRONG_CHANNEL(frag, cha);
962  }
963  break;
964 
965  case COMMON_TOF_FRAG:
966 
967  if (m_TBperiod >= 2022) {
968  if (cha > 11) { // The first 12 channels are (can be) connected to BC1 and BC2, the last 4 channels are supposed to be TOF
969  if(cha < 16) {
970  m_tof[cha] = amplitude;
971  ATH_MSG_VERBOSE( "TOF: " << cha << " amp: " << amplitude);
972  } else {
973  WRONG_CHANNEL(frag, cha);
974  }
975  break;
976  }
977  // Fall through to case COMMON_TDC1_FRAG to unpack the first 12 channels of BC1 and BC2
978  [[fallthrough]]; // silent the warning on fall through
979  } else if (m_TBperiod > 2015) {
980 
981  if(cha < 16) {
982  m_tof[cha] = amplitude;
983  ATH_MSG_VERBOSE( "TOF: " << cha << " amp: " << amplitude);
984  } else {
985  WRONG_CHANNEL(frag, cha);
986  }
987  break;
988  } else {
989  if(cha < 8) m_tof[cha] = amplitude;
990  else WRONG_CHANNEL(frag, cha);
991  break;
992  }
993 
994  case COMMON_TDC1_FRAG:
995 
996  FRAG_FOUND(frag,cha,dsize);
997  if ((cha > 11) && (cha < 16) && (m_run > 2211136)) {
998  m_tof[cha] = amplitude;
999  ATH_MSG_VERBOSE( "TOF: " << cha << " amp: " << amplitude);
1000  } if(cha < 16) {
1001  m_btdc1[cha] = amplitude;
1002  ATH_MSG_VERBOSE( "TDC: " << cha << " amp: " << amplitude);
1003  if (m_btdcNhit[cha]==0) {
1004  m_btdc2[cha] = amplitude;
1005  }
1006  (*m_btdc)[cha].push_back(amplitude);
1007  ++m_btdcNhit[cha];
1008  } else WRONG_CHANNEL(frag, cha);
1009  break;
1010 
1011  case COMMON_TDC2_FRAG:
1012 
1013  FRAG_FOUND(frag,cha,dsize);
1014  if(cha < 16) m_btdc2[cha] = amplitude;
1015  else WRONG_CHANNEL(frag, cha);
1016  break;
1017 
1018  case COIN_TRIG1_FRAG:
1019 
1020  if(cha < 3) {
1021  int idx = cha * 32;
1022  for (int ibit = 0; ibit < 32; ++ibit){
1023  m_coincTrig1[idx++] = (amplitude >> ibit) & 1;
1024  }
1025  } else if (cha == 3) {
1026  m_coincFlag1 = amplitude;
1027  } else WRONG_CHANNEL(frag, cha);
1028 
1029  break;
1030 
1031  case COIN_TRIG2_FRAG:
1032 
1033  if(cha < 3) {
1034  int idx = cha * 32;
1035  for (int ibit=0; ibit < 32; ++ibit){
1036  m_coincTrig2[idx++] = (amplitude >> ibit) & 1;
1037  }
1038  } else if (cha == 3) {
1039  m_coincFlag2 = amplitude;
1040  } else WRONG_CHANNEL(frag, cha);
1041 
1042  break;
1043 
1044  case COIN_TRIG3_FRAG:
1045 
1046  if(cha < 3) {
1047  int idx = cha * 32;
1048  for (int ibit = 0; ibit < 32; ++ibit){
1049  m_coincTrig3[idx++] = (amplitude >> ibit) & 1;
1050  }
1051  } else if (cha == 3) {
1052  m_coincFlag3 = amplitude;
1053  } else WRONG_CHANNEL(frag,cha);
1054 
1055  break;
1056 
1057  case COIN_TRIG4_FRAG:
1058 
1059  if(cha < 3) {
1060  int idx = cha * 32;
1061  for (int ibit = 0; ibit < 32; ++ibit){
1062  m_coincTrig4[idx++] = (amplitude >> ibit) & 1;
1063  }
1064  } else if (cha == 3) {
1065  m_coincFlag4 = amplitude;
1066  } else WRONG_CHANNEL(frag, cha);
1067 
1068  break;
1069 
1070  case COIN_TRIG5_FRAG:
1071 
1072  if(cha < 3) {
1073  int idx = cha * 32;
1074  for (int ibit = 0; ibit < 32; ++ibit){
1075  m_coincTrig5[idx++] = (amplitude >> ibit) & 1;
1076  }
1077  } else if (cha == 3) {
1078  m_coincFlag5 = amplitude;
1079  } else WRONG_CHANNEL(frag, cha);
1080 
1081  break;
1082 
1083  case COIN_TRIG6_FRAG:
1084 
1085  if(cha < 3) {
1086  int idx = cha * 32;
1087  for (int ibit = 0; ibit < 32; ++ibit){
1088  m_coincTrig6[idx++] = (amplitude >> ibit) & 1;
1089  }
1090  } else if (cha == 3) {
1091  m_coincFlag6 = amplitude;
1092  } else WRONG_CHANNEL(frag, cha);
1093 
1094  break;
1095 
1096  case COIN_TRIG7_FRAG:
1097 
1098  if(cha < 3) {
1099  int idx = cha * 32;
1100  for (int ibit = 0; ibit < 32; ++ibit){
1101  m_coincTrig7[idx++] = (amplitude >> ibit) & 1;
1102  }
1103  } else if (cha == 3) {
1104  m_coincFlag7 = amplitude;
1105  } else WRONG_CHANNEL(frag,cha);
1106 
1107  break;
1108 
1109  case COIN_TRIG8_FRAG:
1110 
1111  if(cha < 3) {
1112  int idx = cha * 32;
1113  for (int ibit = 0; ibit < 32; ++ibit){
1114  m_coincTrig8[idx++] = (amplitude >> ibit) & 1;
1115  }
1116  } else if (cha == 3) {
1117  m_coincFlag8 = amplitude;
1118  } else WRONG_CHANNEL(frag, cha);
1119 
1120  break;
1121 
1122  default:
1123  break;
1124  }
1125  }
1126  }
1127  }
1128  }
1129 
1130  for (int i=0; i<8; ++i) {
1131  if (m_btdcNhit[i] > 1) ++m_btdcNchMultiHit[i>>2];
1132  }
1133  // calculate beam coords in Beam Chambers
1134  if ( m_TBperiod >= 2015 ) {
1135 
1136 // For BC1
1137 // -------
1138 // m_xCha1 = -0.0462586 + (-0.175666)*(m_btdc1[1] - m_btdc1[0]);
1139 // m_yCha1 = -0.051923 + (-0.176809)*(m_btdc1[2] - m_btdc1[3]);
1140 //
1141 // For BC2
1142 // -------
1143 // m_xCha2 = 0.25202 + (-0.18053)*(m_btdc1[5] - m_btdc1[4]);
1144 // m_yCha2 = 0.0431688 + (-0.181128)*(m_btdc1[6] - m_btdc1[7]);
1145 
1146  if (m_run > 2211444) {
1147  m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc1[8] - m_btdc1[0]);
1148  m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc1[9] - m_btdc1[3]);
1149  } else {
1150  m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc1[1] - m_btdc1[0]);
1151  m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc1[2] - m_btdc1[3]);
1152  }
1153  if (m_run > 612543 && m_run< 614141) {
1154  m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc1[5] - m_btdc1[6]);
1155  m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc1[4] - m_btdc1[7]);
1156  } else {
1157  m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc1[5] - m_btdc1[4]);
1158  m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc1[6] - m_btdc1[7]);
1159  }
1160 
1161  // Using the first value from the TDC
1162  if (m_run > 2211444) {
1163  m_xCha1_0 = m_beamBC1X1 + m_beamBC1X2*(m_btdc2[8] - m_btdc2[0]);
1164  m_yCha1_0 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc2[9] - m_btdc2[3]);
1165  } else {
1166  m_xCha1_0 = m_beamBC1X1 + m_beamBC1X2*(m_btdc2[1] - m_btdc2[0]);
1167  m_yCha1_0 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc2[2] - m_btdc2[3]);
1168  }
1169  m_xCha2_0 = m_beamBC2X1 + m_beamBC2X2*(m_btdc2[5] - m_btdc2[4]);
1170  m_yCha2_0 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc2[6] - m_btdc2[7]);
1171 
1172  m_tjitter = m_btdc1[8];
1173  m_tscTOF = m_btdc1[14];
1174 
1175  m_xImp = m_xCha2 + (m_xCha2 - m_xCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1176  m_yImp = m_yCha2 + (m_yCha2 - m_yCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1177 
1178 // Work in progress
1179 
1180  m_xImp_0 = m_xCha2_0 + (m_xCha2_0 - m_xCha1_0)*m_beamBC2Z_0/(m_beamBC1Z_0 - m_beamBC2Z_0);
1181  m_yImp_0 = m_yCha2_0 + (m_yCha2_0 - m_yCha1_0)*m_beamBC2Z_0/(m_beamBC1Z_0 - m_beamBC2Z_0);
1182  m_xImp_90 = m_xCha2_0 + (m_xCha2_0 - m_xCha1_0)*m_beamBC2Z_90/(m_beamBC1Z_90 - m_beamBC2Z_90);
1183  m_yImp_90 = m_yCha2_0 + (m_yCha2_0 - m_yCha1_0)*m_beamBC2Z_90/(m_beamBC1Z_90 - m_beamBC2Z_90);
1184  m_xImp_min90 = m_xCha2_0 + (m_xCha2_0 - m_xCha1_0)*m_beamBC2Z_min90/(m_beamBC1Z_min90 - m_beamBC2Z_min90);
1185  m_yImp_min90 = m_yCha2_0 + (m_yCha2_0 - m_yCha1_0)*m_beamBC2Z_min90/(m_beamBC1Z_min90 - m_beamBC2Z_min90);
1187 
1188  if (m_run > 2211444) {
1189  ATH_MSG_DEBUG( "BC1x : ( "<< m_btdc1[0] <<" - "<< m_btdc1[8] <<" )\t" << m_xCha1 );
1190  ATH_MSG_DEBUG( "BC1y : ( "<< m_btdc1[2] <<" - "<< m_btdc1[9] <<" )\t" << m_yCha1 );
1191  } else {
1192  ATH_MSG_DEBUG( "BC1x : ( "<< m_btdc1[0] <<" - "<< m_btdc1[1] <<" )\t" << m_xCha1 );
1193  ATH_MSG_DEBUG( "BC1y : ( "<< m_btdc1[2] <<" - "<< m_btdc1[3] <<" )\t" << m_yCha1 );
1194  }
1195  ATH_MSG_DEBUG( "BC2x : ( "<< m_btdc1[4] <<" - "<< m_btdc1[5] <<" )\t" << m_xCha2 );
1196  ATH_MSG_DEBUG( "BC2y : ( "<< m_btdc1[6] <<" - "<< m_btdc1[7] <<" )\t" << m_yCha2 );
1197 
1198  } else if ( m_unpackAdder ) { // this is 2003 data
1199 
1200  if ( m_beamIdList[BEAM_TDC_FRAG] ) {
1201  m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc1[6] - m_btdc1[7]); // last two channels of TDC !!!
1202  m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc1[2] - m_btdc1[3]);
1203  m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc2[0] - m_btdc2[1]);
1204  m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc2[2] - m_btdc2[3]);
1205 
1206  m_xImp = m_xCha2 + (m_xCha2 - m_xCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1207  m_yImp = m_yCha2 + (m_yCha2 - m_yCha1)*m_beamBC2Z/(m_beamBC1Z - m_beamBC2Z);
1208  }
1209 
1210  } else { // this is 2004 data
1211 
1212  if ( m_beamIdList[COMMON_TDC1_FRAG] ) {
1213  m_yChN2 = m_beamBN2Y1 + m_beamBN2Y2*(m_btdc1[0] - m_btdc1[1]);
1214  m_xChN2 = m_beamBN2X1 + m_beamBN2X2*(m_btdc1[2] - m_btdc1[3]);
1215  m_yChN1 = m_beamBN1Y1 + m_beamBN1Y2*(m_btdc1[4] - m_btdc1[5]);
1216  m_xChN1 = m_beamBN1X1 + m_beamBN1X2*(m_btdc1[6] - m_btdc1[7]);
1217 
1218  m_yCha0 = m_beamBC0Y1 + m_beamBC0Y2*(m_btdc1[8] - m_btdc1[9]);
1219  m_xCha0 = m_beamBC0X1 + m_beamBC0X2*(m_btdc1[10]- m_btdc1[11]);
1220 
1221  ATH_MSG_DEBUG( "BC-2x : ( "<< m_btdc1[2] <<" - "<< m_btdc1[3] <<" )\t" <<m_xChN2 );
1222  ATH_MSG_DEBUG( "BC-2y : ( "<< m_btdc1[0] <<" - "<< m_btdc1[1] <<" )\t" <<m_yChN2 );
1223  ATH_MSG_DEBUG( "BC-1x : ( "<< m_btdc1[6] <<" - "<< m_btdc1[7] <<" )\t" <<m_xChN1 );
1224  ATH_MSG_DEBUG( "BC-1y : ( "<< m_btdc1[4] <<" - "<< m_btdc1[5] <<" )\t" <<m_yChN1 );
1225  ATH_MSG_DEBUG( "BC0x : ( "<< m_btdc1[10] <<" - "<< m_btdc1[11] <<" )\t" <<m_xCha0 );
1226  ATH_MSG_DEBUG( "BC0y : ( "<< m_btdc1[8] <<" - "<< m_btdc1[9] <<" )\t" <<m_yCha0 );
1227 
1228  }
1229 
1230  if ( m_beamIdList[COMMON_TDC2_FRAG] ) {
1231  m_yCha1 = m_beamBC1Y1 + m_beamBC1Y2*(m_btdc2[0] - m_btdc2[1]);
1232  m_xCha1 = m_beamBC1X1 + m_beamBC1X2*(m_btdc2[2] - m_btdc2[3]);
1233  m_yCha2 = m_beamBC2Y1 + m_beamBC2Y2*(m_btdc2[4] - m_btdc2[5]);
1234  m_xCha2 = m_beamBC2X1 + m_beamBC2X2*(m_btdc2[6] - m_btdc2[7]);
1235 
1236  m_xImp = 0.0;
1237  m_yImp = 0.0;
1238 
1239  ATH_MSG_DEBUG( "BC1x : ( "<< m_btdc2[2] <<" - "<< m_btdc2[3] <<" )\t" <<m_xCha1 );
1240  ATH_MSG_DEBUG( "BC1y : ( "<< m_btdc2[0] <<" - "<< m_btdc2[1] <<" )\t" <<m_yCha1 );
1241  ATH_MSG_DEBUG( "BC2x : ( "<< m_btdc2[6] <<" - "<< m_btdc2[7] <<" )\t" <<m_xCha2 );
1242  ATH_MSG_DEBUG( "BC2y : ( "<< m_btdc2[4] <<" - "<< m_btdc2[5] <<" )\t" <<m_yCha2 );
1243 
1244  }
1245 
1246  if ( m_beamIdList[COMMON_TDC1_FRAG] && m_beamIdList[COMMON_TDC2_FRAG] ) {
1247 
1249  // Get run number and eta
1250  if ( 0==m_runNumber ){
1251  const xAOD::EventInfo* eventInfo(0);
1252  if (evtStore()->retrieve(eventInfo).isFailure()){
1253  ATH_MSG_ERROR( "No EventInfo object found! Can't read run number!" );
1254  m_runNumber = -1;
1255  } else {
1256  m_runNumber = eventInfo->runNumber();
1257  getEta();
1258  }
1259  }
1261 
1262  // Computation of X,Y imp on TileCal/LAr front
1263  float tanBx = (m_xCha1-m_xCha0) / (m_beamBC0Z - m_beamBC1Z);
1264  float tanBy = (m_yCha1-m_yCha0) / (m_beamBC0Z - m_beamBC1Z);
1265 
1266  float Ximp = m_xCha1 + m_beamBC1Z * tanBx;
1267  float Yimp = m_yCha1 + m_beamBC1Z * tanBy;
1268 
1269  if ( 0.0 != cos(m_theta) * (1 + tanBx * tan(m_theta)) ){
1270  m_xImp = (Ximp + m_radius *(tanBx * (cos(m_theta) - 1) -sin(m_theta))) / (cos(m_theta) * (1 + tanBx * tan(m_theta)));
1271  m_yImp = Yimp + tanBy * (m_radius * (1 - cos(m_theta)) -Ximp * sin(m_theta)) / (cos(m_theta) * (1+tanBx * tan(m_theta)));
1272  }
1273  }
1274  }
1275 
1276 
1277  // do not apply Cesium and Laser calibration for CIS events
1278  // m_calibrateEnergyThisEvent = m_calibrateEnergy && (m_trigType != 8);
1279 
1280  return StatusCode::SUCCESS;
1281 }

◆ storeCells()

StatusCode TileTBAANtuple::storeCells ( const EventContext &  ctx)
private

Definition at line 2236 of file TileTBAANtuple.cxx.

2236  {
2237 
2238  if (m_cellContainerKey.empty()) { // empty name, nothing to do
2239  return StatusCode::FAILURE;
2240  }
2241 
2242  //Retrieve Cell collection from SG
2243  const CaloCellContainer* cellContainer = SG::makeHandle (m_cellContainerKey, ctx).get();
2244 
2245  //Loop over all cells in container. Sum up the Energy and fill 2DHistograms
2246  ATH_MSG_DEBUG( "succeeded retrieving cellContainer from SG" );
2247 
2248  ATH_MSG_DEBUG( "TileTBAANtuple : about to iterate over CaloCells" );
2249 
2250  m_LarEne[0] = m_LarEne[1] = m_LarEne[2] = m_LarEne[3] = 0.0;
2251  m_BarEne[0] = m_BarEne[1] = m_BarEne[2] = 0.0;
2252  m_ExtEne[0] = m_ExtEne[1] = m_ExtEne[2] = 0.0;
2253  m_GapEne[0] = m_GapEne[1] = m_GapEne[2] = 0.0;
2254 
2255  for (const CaloCell* cell : *cellContainer) {
2256  //Decode cell information
2257  const double energy = cell->energy();
2258  const CaloDetDescrElement* caloDDE = cell->caloDDE(); //pointer to the DetectorDescriptionElement
2259  const CaloCell_ID::CaloSample sampl = caloDDE->getSampling(); //To which sampling belongs this cell?
2260 
2261  if (sampl == CaloCell_ID::PreSamplerB) {
2262  m_LarEne[0] += energy;
2263  } else if (sampl == CaloCell_ID::EMB1) {
2264  m_LarEne[1] += energy;
2265  } else if (sampl == CaloCell_ID::EMB2) {
2266  m_LarEne[2] += energy;
2267  } else if (sampl == CaloCell_ID::EMB3) {
2268  m_LarEne[3] += energy;
2269  } else if (sampl == CaloCell_ID::TileBar0) {
2270  m_BarEne[0] += energy;
2271  } else if (sampl == CaloCell_ID::TileBar1) {
2272  m_BarEne[1] += energy;
2273  } else if (sampl == CaloCell_ID::TileBar2) {
2274  m_BarEne[2] += energy;
2275  } else if (sampl == CaloCell_ID::TileExt0) {
2276  m_ExtEne[0] += energy;
2277  } else if (sampl == CaloCell_ID::TileExt1) {
2278  m_ExtEne[1] += energy;
2279  } else if (sampl == CaloCell_ID::TileExt2) {
2280  m_ExtEne[2] += energy;
2281  } else if (sampl == CaloCell_ID::TileGap1) {
2282  m_GapEne[1] += energy;
2283  } else if (sampl == CaloCell_ID::TileGap2) {
2284  m_GapEne[2] += energy;
2285  } else if (sampl == CaloCell_ID::TileGap3) {
2286  m_GapEne[0] += energy;
2287  }
2288  }
2289 
2290  return StatusCode::SUCCESS;
2291 }

◆ storeDigits()

StatusCode TileTBAANtuple::storeDigits ( const EventContext &  ctx,
const SG::ReadHandleKey< TileDigitsContainer > &  containerKey,
const TileDQstatus *  dqStatus = nullptr 
)
private

/ Fill Ntuple with info from TileDigits / Return true if the collection is empty, / which means that there are no RawChanels either.

Store ROD header info from collection (should be just one per ROD, but we don't know how many RODs we have, so store it for every collection)

Full DMU header, stored for debugging

bit_31==1 and bit_17==0

parity must be an odd number

memory parity error bit_25

single strobe error bit_24 (it is recovered)

double strobe error bit_23 (cannot be recovered)

Full DMU header, stored for debugging

bit_31==1 and bit_17==0

parity must be an odd number

memory parity error bit_25

single strobe error bit_24 (it is recovered)

double strobe error bit_23 (cannot be recovered)

Full DMU header, stored for debugging

bit_31==1 and bit_17==0

parity must be an odd number

memory parity error bit_25

single strobe error bit_24 (it is recovered)

double strobe error bit_23 (cannot be recovered)

Definition at line 1451 of file TileTBAANtuple.cxx.

1451  {
1452 
1453  if (containerKey.empty()) { // empty name, nothing to do
1454  return StatusCode::FAILURE;
1455  }
1456 
1457  // Read Digits from TES
1458  const TileDigitsContainer* digitsCnt = SG::makeHandle (containerKey, ctx).get();
1459 
1460  bool emptyColl = true;
1461 
1462  // drawerIndex is 0 - m_nDrawers-1, fragType is 1-4 B+/B-/EB+/EB-
1463  int drawerIndex, fragType, channel;
1464 
1465  std::vector<float> sampleVec;
1466  std::vector<uint32_t> headerVec;
1467  std::vector<uint32_t> headerVecHi;
1468  uint32_t CRCmask;
1469  uint32_t fe_crc;
1470  uint32_t rod_crc;
1471 
1472  // Go through all TileDigitsCollections
1473  for (const TileDigitsCollection* digitsCollection : * digitsCnt) {
1474  // determine type of frag
1475  int fragId = digitsCollection->identify();
1476  int ros = (fragId >> 8);
1477  int drawer = fragId & 0x3F;
1478 
1479  drawerMap_iterator itr = m_drawerMap.find(fragId);
1480  if ( itr != m_drawerMap.end() ) {
1481  drawerIndex = (*itr).second;
1482  } else {
1483  drawerIndex= -1;
1484  }
1485 
1486  if (drawerIndex < 0) {
1487  if ( !digitsCollection->empty() )
1488  ATH_MSG_DEBUG( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing TRC!" );
1489 
1490  } else {
1491  fragType = m_drawerType[drawerIndex];
1492 
1493  ATH_MSG_DEBUG( "Event# " << m_evtNr
1494  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1495  << " index " << drawerIndex
1496  << " Calib " << m_calibMode );
1497 
1498  ATH_MSG_DEBUG( " Size=" << digitsCollection->getFragSize()
1499  << " BCID=" << digitsCollection->getFragBCID()<<MSG::hex
1500  << " CRC=0x" << (digitsCollection->getFragCRC()&0xffff)
1501  << " DMUMask=0x" << (digitsCollection->getFragDMUMask()&0xffff)<<MSG::dec );
1502 
1503  ATH_MSG_DEBUG( " Lvl1ID=" << digitsCollection->getLvl1Id()
1504  << " Lvl1Type=" << digitsCollection->getLvl1Type()
1505  << " EvBCID=" << digitsCollection->getRODBCID()
1506  << " EvType=" << digitsCollection->getDetEvType() );
1507 
1508  ATH_MSG_DEBUG( " Header=" << digitsCollection->getFragChipHeaderWords() );
1509 
1510  if (m_completeNtuple) {
1515  m_l1ID.at(drawerIndex) = digitsCollection->getLvl1Id();
1516  m_l1Type.at(drawerIndex) = digitsCollection->getLvl1Type();
1517  m_evType.at(drawerIndex) = digitsCollection->getDetEvType();
1518  m_evBCID.at(drawerIndex) = digitsCollection->getRODBCID();
1519  // store FrBCID
1520  m_frBCID.at(drawerIndex) = digitsCollection->getFragBCID();
1521  }
1522 
1523  if(m_calibMode) {
1524  // Digits in calib mode
1525  // check gain for first digits in collection
1526 
1527  int dcnt=0;
1528  int drawerIndexHi = drawerIndex + m_nDrawers;
1529  // non empty collection
1530  if (!digitsCollection->empty()) {
1531  // store evtnr, bcid,crc, size
1532  // Same for lo and hi, because they come from the same fragment
1533  m_rodBCIDVec.at(drawerIndex) = digitsCollection->getRODBCID();
1534  m_sizeVec.at(drawerIndex) = digitsCollection->getFragSize();
1535  m_sizeVec.at(drawerIndexHi) = digitsCollection->getFragSize();
1536  m_evtVec.at(drawerIndex) = m_evtNr;
1537  m_evtVec.at(drawerIndexHi) = m_evtNr;
1538 
1539  headerVec = digitsCollection->getFragChipHeaderWords();
1540  headerVecHi = digitsCollection->getFragChipHeaderWordsHigh();
1541  CRCmask = digitsCollection->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1542  fe_crc = CRCmask & 0xFFFF;
1543  rod_crc = CRCmask >> 16;
1544 
1545  unsigned int headsize = std::min(16U, static_cast<unsigned int>(headerVec.size()));
1546  unsigned int headsizehi = std::min(16U, static_cast<unsigned int>(headerVecHi.size()));
1547 
1548  for (unsigned int ih = 0; ih < headsize; ++ih) {
1549 
1550  m_bcidVec.at(drawerIndex)[ih] = (headerVec[ih] & 0xFFF);
1551  m_DMUheaderVec.at(drawerIndex)[ih] = headerVec[ih];
1552  m_DMUformatErrVec.at(drawerIndex)[ih] = CheckDMUFormat(headerVec[ih]);
1553  m_DMUparityErrVec.at(drawerIndex)[ih] = CheckDMUParity(headerVec[ih]);
1554  m_DMUmemoryErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 25 & 0x1);
1555  m_DMUSstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 24 & 0x1);
1556  m_DMUDstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 23 & 0x1);
1557  m_feCRCVec.at(drawerIndex)[ih] = (fe_crc >> ih & 0x1);
1558  m_rodCRCVec.at(drawerIndex)[ih] = (rod_crc >> ih & 0x1);
1559 
1560  if (dqStatus) {
1561  m_DMUHeadparityErrVec.at(drawerIndex)[ih] = dqStatus->checkHeaderParityErr(ros, drawer, ih, 0);
1562  m_DMUDataparityErrVec.at(drawerIndex)[ih] = dqStatus->checkSampleParityErr(ros, drawer, ih, 0);
1563  }
1564  }
1565 
1566  for (unsigned int ihhi = 0; ihhi < headsizehi; ++ihhi) {
1567  m_bcidVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] & 0xFFF);
1568  m_DMUheaderVec.at(drawerIndexHi)[ihhi] = headerVecHi[ihhi];
1569  m_DMUformatErrVec.at(drawerIndexHi)[ihhi] = CheckDMUFormat(headerVecHi[ihhi]);
1570  m_DMUparityErrVec.at(drawerIndexHi)[ihhi] = CheckDMUParity(headerVecHi[ihhi]);
1571  m_DMUmemoryErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 25 & 0x1);
1572  m_DMUSstrobeErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 24 & 0x1);
1573  m_DMUDstrobeErrVec.at(drawerIndexHi)[ihhi] = (headerVecHi[ihhi] >> 23 & 0x1);
1574  m_feCRCVec.at(drawerIndex)[ihhi] = -1; //Variables must be filled anyway, empty variables are not allowed
1575  m_rodCRCVec.at(drawerIndex)[ihhi] = -1; //Variables must be filled anyway, empty variables are not allowed
1576 
1577  if (dqStatus) {
1578  m_DMUHeadparityErrVec.at(drawerIndex)[ihhi] = dqStatus->checkHeaderParityErr(ros, drawer, ihhi, 1);
1579  m_DMUDataparityErrVec.at(drawerIndex)[ihhi] = dqStatus->checkSampleParityErr(ros, drawer, ihhi, 1);
1580  }
1581  }
1582 
1583  m_slinkCRCVec.at(drawerIndex)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1584  m_dmuMaskVec.at(drawerIndex)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1585  m_slinkCRCVec.at(drawerIndex)[1] = digitsCollection->getFragCRC() & 0xffff;
1586  m_dmuMaskVec.at(drawerIndex)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1587 
1588  m_slinkCRCVec.at(drawerIndexHi)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1589  m_dmuMaskVec.at(drawerIndexHi)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1590  m_slinkCRCVec.at(drawerIndexHi)[1] = digitsCollection->getFragCRC() & 0xffff;
1591  m_dmuMaskVec.at(drawerIndexHi)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1592 
1593  // go through all TileDigits in collection
1594  for (const TileDigits* tile_digits : *digitsCollection) {
1595 
1596  emptyColl = false;
1597 
1598  HWIdentifier hwid = tile_digits->adc_HWID();
1599  // determine gain
1600  int gain = m_tileHWID->adc(hwid);
1601  // add m_nDrawers to index if hi gain
1602  int index = (gain == 1) ? drawerIndexHi : drawerIndex;
1603  int nSamplesInDrawer = m_nSamplesInDrawer[index];
1604 
1605  // determine channel
1606  channel = m_tileHWID->channel(hwid);
1607  // cabling for testbeam (convert to pmt#-1)
1608 
1609  if ((m_TBperiod < 2015 ||
1610  (m_TBperiod==2015 && fragType<3) ||
1611  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1612  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1613  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1614  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1615  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1616  && fragType > 0 && m_pmtOrder)
1617 
1618  channel = digiChannel2PMT(fragType, channel);
1619 
1620 
1621  // gain determined for all digits in collection
1622  m_gainVec.at(index)[channel] = gain;
1623  ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1624  << " with gain " << m_tileHWID->adc(hwid)
1625  << " index " << index );
1626 
1627  // get digits
1628  sampleVec = tile_digits->samples();
1629  int siz = sampleVec.size();
1630 
1631  if (msgLvl(MSG::DEBUG)) {
1632  msg(MSG::DEBUG) << "Digits(" << siz << ")." << (dcnt++) << " {";
1633  for (int i = 0; i < siz; i++) {
1634  msg(MSG::DEBUG) << static_cast<int>(sampleVec[i]) << " ";
1635  }
1636 
1637  if (siz > nSamplesInDrawer) {
1638  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1639  } else {
1640  msg(MSG::DEBUG) << "}" << endmsg;
1641  }
1642  }
1643 
1644  if (siz > nSamplesInDrawer) siz = nSamplesInDrawer;
1645  std::transform(sampleVec.begin(), sampleVec.begin() + siz, &m_sampleVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1646  }
1647  }
1648  } else {
1649  // Digits in normal mode
1650  // store evtnr, bcid,crc, size
1651  m_rodBCIDVec.at(drawerIndex) = digitsCollection->getRODBCID();
1652  m_sizeVec.at(drawerIndex) = digitsCollection->getFragSize();
1653  m_evtVec.at(drawerIndex) = m_evtNr;
1654 
1655  headerVec = digitsCollection->getFragChipHeaderWords();
1656  CRCmask = digitsCollection->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1657  fe_crc = CRCmask & 0xFFFF;
1658  rod_crc = CRCmask >> 16;
1659 
1660  int headsize = headerVec.size();
1661 
1662  for (int ih = 0; ih < headsize; ++ih) {
1663  m_bcidVec.at(drawerIndex)[ih] = (headerVec[ih] & 0xFFF);
1664  m_DMUheaderVec.at(drawerIndex)[ih] = headerVec[ih];
1665  m_DMUformatErrVec.at(drawerIndex)[ih] = CheckDMUFormat(headerVec[ih]);
1666  m_DMUparityErrVec.at(drawerIndex)[ih] = CheckDMUParity(headerVec[ih]);
1667  m_DMUmemoryErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 25 & 0x1);
1668  m_DMUSstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 24 & 0x1);
1669  m_DMUDstrobeErrVec.at(drawerIndex)[ih] = (headerVec[ih] >> 23 & 0x1);
1670  m_feCRCVec.at(drawerIndex)[ih] = (fe_crc >> ih & 0x1);
1671  m_rodCRCVec.at(drawerIndex)[ih] = (rod_crc >> ih & 0x1);
1672 
1673  if (dqStatus) {
1674  m_DMUHeadparityErrVec.at(drawerIndex)[ih] = dqStatus->checkHeaderParityErr(ros, drawer, ih, 0);
1675  m_DMUDataparityErrVec.at(drawerIndex)[ih] = dqStatus->checkSampleParityErr(ros, drawer, ih, 0);
1676  }
1677  }
1678 
1679  m_slinkCRCVec.at(drawerIndex)[0] = (digitsCollection->getFragCRC() >> 16) & 0xffff;
1680  m_dmuMaskVec.at(drawerIndex)[0] = (digitsCollection->getFragDMUMask() >> 16) & 0xffff;
1681  m_slinkCRCVec.at(drawerIndex)[1] = digitsCollection->getFragCRC() & 0xffff;
1682  m_dmuMaskVec.at(drawerIndex)[1] = digitsCollection->getFragDMUMask() & 0xffff;
1683 
1684  int nSamplesInDrawer = m_nSamplesInDrawer[drawerIndex];
1685 
1686  int dcnt = 0;
1687  // go through all TileDigits in collection
1688  for (const TileDigits* tile_digits : *digitsCollection) {
1689  emptyColl = false;
1690 
1691  HWIdentifier hwid = tile_digits->adc_HWID();
1692  // determine channel
1693  channel = m_tileHWID->channel(hwid);
1694  // cabling for testbeam
1695  if ((m_TBperiod < 2015 ||
1696  (m_TBperiod==2015 && fragType<3) ||
1697  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1698  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1699  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1700  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1701  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1702  && fragType > 0 && m_pmtOrder)
1703  channel = digiChannel2PMT(fragType, channel);
1704 
1705  // gain
1706  m_gainVec.at(drawerIndex)[channel] = m_tileHWID->adc(hwid);
1707  ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1708  << " with gain " << m_tileHWID->adc(hwid) );
1709 
1710  // get digits
1711  sampleVec = tile_digits->samples();
1712  int siz = sampleVec.size();
1713  if (msgLvl(MSG::DEBUG)) {
1714  msg(MSG::DEBUG) << "Digits(" << siz << ")." << (dcnt++) << " {";
1715 
1716  for (int i = 0; i < siz; i++) {
1717  msg(MSG::DEBUG) << static_cast<int>(sampleVec[i]) << " ";
1718  }
1719 
1720  if (siz > nSamplesInDrawer) {
1721  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1722  } else {
1723  msg(MSG::DEBUG) << "}" << endmsg;
1724  }
1725  }
1726 
1727  if (siz > nSamplesInDrawer) siz = nSamplesInDrawer;
1728  std::transform(sampleVec.begin(), sampleVec.begin() + siz, &m_sampleVec.at(drawerIndex).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1729  }
1730  }
1731  }
1732  // next container
1733  }
1734 
1735  if (emptyColl)
1736  return StatusCode::FAILURE;
1737  else
1738  return StatusCode::SUCCESS;
1739 }

◆ storeDigitsFlx()

StatusCode TileTBAANtuple::storeDigitsFlx ( const EventContext &  ctx,
const SG::ReadHandleKey< TileDigitsContainer > &  containerKey 
)
private

Store ROD header info from collection (should be just one per ROD, but we don't know how many RODs we have, so store it for every collection)

Definition at line 1742 of file TileTBAANtuple.cxx.

1742  {
1743 
1744  if (containerKey.empty()) { // empty name, nothing to do
1745  return StatusCode::FAILURE;
1746  }
1747 
1748  // Read Digits from TES
1749  const TileDigitsContainer* digitsCntFlx = SG::makeHandle (containerKey, ctx).get();
1750 
1751  bool emptyColl = true;
1752 
1753  // drawerIndex is 0 - m_nDrawersFlx-1, fragType is 1-4 B+/B-/EB+/EB-
1754  int drawerIndex, channel;
1755 
1756  std::vector<float> sampleVecLo;
1757  std::vector<float> sampleVecHi;
1758  // Go through all TileDigitsCollections
1759  for (const TileDigitsCollection* digitsCollection : *digitsCntFlx) {
1760  // determine type of frag
1761  int fragId = digitsCollection->identify();
1762  drawerMap_iterator itr = m_drawerFlxMap.find(fragId);
1763  if ( itr != m_drawerFlxMap.end() ) {
1764  drawerIndex = (*itr).second;
1765  } else {
1766  drawerIndex = -1;
1767  }
1768 
1769  if (drawerIndex < 0) {
1770  if ( !digitsCollection->empty() )
1771  ATH_MSG_DEBUG( "FELIX frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing TRC!" );
1772 
1773  } else {
1774 
1775  ATH_MSG_DEBUG( "Event# " << m_evtNr
1776  << " FELIX Frag id 0x" << MSG::hex << fragId << MSG::dec
1777  << " index " << drawerIndex);
1778 
1779  ATH_MSG_DEBUG( " Size=" << digitsCollection->getFragSize());
1780 
1781  ATH_MSG_DEBUG( " Lvl1ID=" << digitsCollection->getLvl1Id()
1782  << " EvBCID=" << digitsCollection->getRODBCID()
1783  << " EvType=" << digitsCollection->getDetEvType() );
1784  ATH_MSG_DEBUG( " Headers = "<< digitsCollection->getFragExtraWords() );
1785 
1786  if (m_completeNtuple) {
1791  int index = drawerIndex + m_nDrawers;
1792  m_l1ID.at(index) = digitsCollection->getLvl1Id();
1793  m_l1Type.at(index) = digitsCollection->getLvl1Type();
1794  m_evType.at(index) = digitsCollection->getDetEvType();
1795  m_evBCID.at(index) = digitsCollection->getRODBCID();
1796  // store FrBCID
1797  m_frBCID.at(index) = digitsCollection->getFragBCID();
1798  }
1799 
1800  // Digits in calib mode
1801  // check gain for first digits in collection
1802 
1803 
1804  std::vector<uint32_t> extraWords = digitsCollection->getFragExtraWords();
1805  if (extraWords.size() >= 10 * MAX_MINIDRAWER) {
1806 
1807  std::reference_wrapper<std::array<int,MAX_MINIDRAWER>>
1808  md[] = {m_mdL1idflxVec.at(drawerIndex), m_mdBcidflxVec.at(drawerIndex),
1809  m_mdModuleflxVec.at(drawerIndex), m_mdRunTypeflxVec.at(drawerIndex),
1810  m_mdRunflxVec.at(drawerIndex), m_mdPedLoflxVec.at(drawerIndex),
1811  m_mdPedHiflxVec.at(drawerIndex), m_mdChargeflxVec.at(drawerIndex),
1812  m_mdChargeTimeflxVec.at(drawerIndex), m_mdCapacitorflxVec.at(drawerIndex)};
1813 
1814  auto it = extraWords.begin();
1815  for (int i = 0; i < 10; ++i) {
1816  std::copy(it + i * MAX_MINIDRAWER, it + (i + 1) * MAX_MINIDRAWER, &md[i].get()[0]);
1817  }
1818 
1819  }
1820 
1821  int dcnt=0;
1822  // non empty collection
1823  if(!digitsCollection->empty()) {
1824  int drawerIndexHi = drawerIndex + m_nDrawersFlx;
1825  // store evtnr, bcid,crc, size
1826  if (m_bsInput) {
1827  m_rodBCIDflxVec.at(drawerIndex) = digitsCollection->getRODBCID();
1828  m_sizeflxVec.at(drawerIndex) = digitsCollection->getFragSize();
1829  m_evtflxVec.at(drawerIndex) = m_evtNr;
1830  }
1831 
1832  // go through all TileDigits in collection
1833  for (const TileDigits* tile_digits : *digitsCollection) {
1834  emptyColl = false;
1835  HWIdentifier hwid = tile_digits->adc_HWID();
1836  // determine gain
1837  int gain = m_tileHWID->adc(hwid);
1838  // add m_nDrawersFlx to index if hi gain
1839  int index = (gain == 1) ? drawerIndexHi : drawerIndex;
1840 
1841  // determine channel
1842  channel = m_tileHWID->channel(hwid);
1843  // cabling for testbeam (convert to pmt#-1)
1844 
1845  // gain determined for all digits in collection
1846  m_gainflxVec.at(index)[channel] = gain;
1847  ATH_MSG_DEBUG( "Storing TD for channel: " << channel
1848  << " with gain " << m_tileHWID->adc(hwid)
1849  << " index " << index );
1850 
1851  // get digits
1852  if (gain == 0) {
1853  sampleVecLo = tile_digits->samples();
1854  } else if (gain == 1) {
1855  sampleVecHi = tile_digits->samples();
1856  }
1857 
1858  int sizLo = sampleVecLo.size();
1859  int sizHi = sampleVecHi.size();
1860 
1861  int nSamplesInDrawer = m_nSamplesFlxInDrawer[index];
1862 
1863  if (msgLvl(MSG::DEBUG)) {
1864  if (sizLo > 0 ){
1865  msg(MSG::DEBUG) << "Low gain Digits(" << sizLo << ")." << (dcnt++) << " {";
1866  for (int i = 0; i < sizLo; i++) {
1867  msg(MSG::DEBUG) << static_cast<int>(sampleVecLo[i]) << " ";
1868  }
1869 
1870  if (sizLo > nSamplesInDrawer) {
1871  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1872  } else {
1873  msg(MSG::DEBUG) << "}" << endmsg;
1874  }
1875  }
1876 
1877  if (sizHi > 0 ){
1878  msg(MSG::DEBUG) << "High gain Digits(" << sizHi << ")." << (dcnt++) << " {";
1879  for (int i = 0; i < sizHi; i++) {
1880  msg(MSG::DEBUG) << static_cast<int>(sampleVecHi[i]) << " ";
1881  }
1882 
1883  if (sizHi > nSamplesInDrawer) {
1884  msg(MSG::DEBUG) << "} ONLY " << nSamplesInDrawer << " digits saved to ntuple" << endmsg;
1885  } else {
1886  msg(MSG::DEBUG) << "}" << endmsg;
1887  }
1888  }
1889 
1890 
1891  }
1892  if (sizLo > nSamplesInDrawer) sizLo = nSamplesInDrawer;
1893  if (sizHi > nSamplesInDrawer) sizHi = nSamplesInDrawer;
1894  std::transform(sampleVecLo.begin(), sampleVecLo.begin() + sizLo, &m_sampleflxVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1895  std::transform(sampleVecHi.begin(), sampleVecHi.begin() + sizHi, &m_sampleflxVec.at(index).get()[0] + nSamplesInDrawer * channel, [] (float v) {return static_cast<int>(v);});
1896  sampleVecLo.clear();
1897  sampleVecHi.clear();
1898  }
1899  }
1900  }
1901  // next container
1902  }
1903 
1904  if (emptyColl)
1905  return StatusCode::FAILURE;
1906  else
1907  return StatusCode::SUCCESS;
1908 }

◆ storeHit()

void TileTBAANtuple::storeHit ( const TileHit *  hit,
int  fragType,
int  fragId,
std::array< float, MAX_CHAN > &  ehitVec,
std::array< float, MAX_CHAN > &  thitVec,
const TileSamplingFraction *  samplingFraction 
)
private

Definition at line 2007 of file TileTBAANtuple.cxx.

2010  {
2011 
2012  // determine channel
2013  HWIdentifier hwid = cinp->pmt_HWID();
2014  int channel = m_tileHWID->channel(hwid);
2015 
2016  int size = cinp->size();
2017  if (msgLvl(MSG::VERBOSE)) {
2018  msg(MSG::VERBOSE) << "hit hwid="
2019  << m_tileHWID->to_string(hwid, -1) << " ener=";
2020 
2021  for (int i = 0; i < size; ++i)
2022  msg(MSG::VERBOSE) << cinp->energy(i) << " ";
2023 
2024  msg(MSG::VERBOSE) << "time=";
2025  for (int i = 0; i < size; ++i)
2026  msg(MSG::VERBOSE) << cinp->time(i) << " ";
2027 
2028  msg(MSG::VERBOSE) << endmsg;
2029  }
2030 
2031  double ehit=0.0, thit=0.0;
2032  for(int i=0;i<size;++i) {
2033 
2034  double e = cinp->energy(i);
2035  double t = cinp->time(i);
2036 
2037  if (-75.<t && t<75.) {
2038  ehit += e;
2039  thit += e*t;
2040  }
2041  }
2042 
2043  if (ehit!=0) {
2044  thit /= ehit;
2045  // conversion factor from hit energy to final energy units
2046  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
2047  ehit *= samplingFraction->getSamplingFraction(drawerIdx, channel);
2048  if (m_rchUnit != TileRawChannelUnit::MegaElectronVolts) {
2049  ehit /= m_tileToolEmscale->channelCalib(drawerIdx, channel, TileID::HIGHGAIN, 1.,
2050  m_rchUnit, TileRawChannelUnit::MegaElectronVolts);
2051  }
2052  } else {
2053  thit=0.0;
2054  }
2055 
2056  // cabling for testbeam
2057  if ((m_TBperiod < 2015 ||
2058  (m_TBperiod==2015 && fragType<3) ||
2059  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
2060  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
2061  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
2062  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
2063  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
2064  && fragType > 0 && m_pmtOrder)
2065  channel = digiChannel2PMT(fragType, channel);
2066 
2067  ehitVec[channel] = ehit;
2068  thitVec[channel] = thit;
2069 
2070  ATH_MSG_DEBUG( "HIT ene=" << ehit
2071  << " time=" << thit
2072  << " pmt-1=" << channel
2073  << " index " << m_drawerMap.find(fragId)->second );
2074 
2075 }

◆ storeHitContainer()

StatusCode TileTBAANtuple::storeHitContainer ( const EventContext &  ctx)
private

/ Fill Ntuple with MC truth info from simulation / Namely, hit energies corrected by photoelectron statistics and Birks' law

Definition at line 1960 of file TileTBAANtuple.cxx.

1960  {
1961 
1962  if (m_hitContainerKey.empty()) { // empty name, nothing to do
1963  return StatusCode::FAILURE;
1964  }
1965 
1966  // Read Hit Vector from TDS
1967  const TileHitContainer* hitCnt = SG::makeHandle (m_hitContainerKey, ctx).get();
1968 
1969  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
1970  ATH_CHECK( samplingFraction.isValid() );
1971 
1972  bool emptyColl = true;
1973 
1974  // Go through all TileHitCollections
1975  for (const TileHitCollection* hitCollection : *hitCnt) {
1976 
1977  // determine type of frag
1978  int fragId = hitCollection->identify();
1979  drawerMap_iterator itr = m_drawerMap.find(fragId);
1980  int drawerIndex = ( itr != m_drawerMap.end() ) ? (*itr).second : -1;
1981 
1982  if (drawerIndex < 0) {
1983  if ( !hitCollection->empty() )
1984  ATH_MSG_WARNING( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing HITS!" );
1985 
1986  } else {
1987  int fragType = m_drawerType[drawerIndex];
1988 
1989  ATH_MSG_DEBUG( "Event# " << m_evtNr
1990  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1991  << " index " << drawerIndex );
1992 
1993  if (emptyColl) emptyColl = hitCollection->empty();
1994  // go through all TileHit in collection
1995  for (const TileHit* cinp : *hitCollection) {
1996  storeHit(cinp,fragType,fragId,m_ehitCnt.at(drawerIndex),m_thitCnt.at(drawerIndex),*samplingFraction);
1997  }
1998  }
1999  }
2000 
2001  if (emptyColl)
2002  return StatusCode::FAILURE;
2003  else
2004  return StatusCode::SUCCESS;
2005 }

◆ storeHitVector()

StatusCode TileTBAANtuple::storeHitVector ( const EventContext &  ctx)
private

Definition at line 1915 of file TileTBAANtuple.cxx.

1915  {
1916 
1917  if (m_hitVectorKey.empty()) { // empty name, nothing to do
1918  return StatusCode::FAILURE;
1919  }
1920 
1921  // Read Hit Vector from TDS
1922  const TileHitVector* hitVec = SG::makeHandle (m_hitVectorKey, ctx).get();
1923 
1924  ATH_MSG_DEBUG( "Event# " << m_evtNr << " reading Hit Vector");
1925 
1926  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
1927  ATH_CHECK( samplingFraction.isValid() );
1928 
1929  // Go through all TileHit
1930  for (const TileHit& cinp : *hitVec) {
1931 
1932  // get hits
1933  HWIdentifier hwid = cinp.pmt_HWID();
1934 
1935  // determine type of frag
1936  int fragId = m_tileHWID->frag(hwid);
1937  drawerMap_iterator itr = m_drawerMap.find(fragId);
1938  int drawerIndex = ( itr != m_drawerMap.end() ) ? (*itr).second : -1;
1939 
1940  if (drawerIndex < 0) {
1941  ATH_MSG_WARNING( "frag id 0x" << MSG::hex << fragId << MSG::dec <<" was not found among valid frag IDs when storing HITS!" );
1942 
1943  } else {
1944  int fragType = m_drawerType[drawerIndex];
1945  storeHit(&cinp,fragType,fragId,m_ehitVec.at(drawerIndex),m_thitVec.at(drawerIndex), *samplingFraction);
1946  }
1947  }
1948 
1949  if (hitVec->empty())
1950  return StatusCode::FAILURE;
1951  else
1952  return StatusCode::SUCCESS;
1953 }

◆ storeLaser()

StatusCode TileTBAANtuple::storeLaser ( const EventContext &  ctx)
private

Definition at line 562 of file TileTBAANtuple.cxx.

562  {
563 
564  if (m_laserObjectKey.empty()) { // empty name, nothing to do
565  return StatusCode::FAILURE;
566  }
567 
568  // Read Hit Vector from TDS
569  const TileLaserObject* laserObj = SG::makeHandle (m_laserObjectKey, ctx).get();
570 
571  m_las_BCID = laserObj->getBCID();
572 
573  m_las_Filt = laserObj->getFiltNumber();
574  m_las_ReqAmp = laserObj->getDiodeCurrOrd();
575  m_las_MeasAmp = laserObj->getDiodeCurrMeas();
576 
577 
578  m_las_D1_ADC = laserObj->getDiodeADC(0);
579  m_las_D2_ADC = laserObj->getDiodeADC(1);
580  m_las_D3_ADC = laserObj->getDiodeADC(2);
581  m_las_D4_ADC = laserObj->getDiodeADC(3);
582 
583  m_las_D1_Ped = laserObj->getDiodePedestal(0);
584  m_las_D2_Ped = laserObj->getDiodePedestal(1);
585  m_las_D3_Ped = laserObj->getDiodePedestal(2);
586  m_las_D4_Ped = laserObj->getDiodePedestal(3);
587 
588  m_las_D1_Ped_RMS = laserObj->getDiodeSigmaPedestal(0);
589  m_las_D2_Ped_RMS = laserObj->getDiodeSigmaPedestal(1);
590  m_las_D3_Ped_RMS = laserObj->getDiodeSigmaPedestal(2);
591  m_las_D4_Ped_RMS = laserObj->getDiodeSigmaPedestal(3);
592 
593  m_las_D1_Alpha = laserObj->getAlpha(0);
594  m_las_D2_Alpha = laserObj->getAlpha(1);
595  m_las_D3_Alpha = laserObj->getAlpha(2);
596  m_las_D4_Alpha = laserObj->getAlpha(3);
597 
598  m_las_D1_Alpha_RMS = laserObj->getSigmaAlpha(0);
599  m_las_D2_Alpha_RMS = laserObj->getSigmaAlpha(1);
600  m_las_D3_Alpha_RMS = laserObj->getSigmaAlpha(2);
601  m_las_D4_Alpha_RMS = laserObj->getSigmaAlpha(3);
602 
603  m_las_D1_AlphaPed = laserObj->getPedestalAlpha(0);
604  m_las_D2_AlphaPed = laserObj->getPedestalAlpha(1);
605  m_las_D3_AlphaPed = laserObj->getPedestalAlpha(2);
606  m_las_D4_AlphaPed = laserObj->getPedestalAlpha(3);
607 
608  m_las_D1_AlphaPed_RMS = laserObj->getSigmaPedAlpha(0);
609  m_las_D2_AlphaPed_RMS = laserObj->getSigmaPedAlpha(1);
610  m_las_D3_AlphaPed_RMS = laserObj->getSigmaPedAlpha(2);
611  m_las_D4_AlphaPed_RMS = laserObj->getSigmaPedAlpha(3);
612 
613  m_las_PMT1_ADC = laserObj->getPMADC(0);
614  m_las_PMT2_ADC = laserObj->getPMADC(1);
615 
616  m_las_PMT1_TDC = laserObj->getTDC(0);
617  m_las_PMT2_TDC = laserObj->getTDC(1);
618 
619  m_las_PMT1_Ped = laserObj->getPMPedestal(0);
620  m_las_PMT2_Ped = laserObj->getPMPedestal(1);
621 
622  m_las_PMT1_Ped_RMS = laserObj->getPMSigmaPedestal(0);
623  m_las_PMT2_Ped_RMS = laserObj->getPMSigmaPedestal(1);
624 
625  m_las_Temperature = laserObj->getPumpDiodeTemp();
626 
627  ATH_MSG_DEBUG( "storeLaser() completed" );
628 
629  return StatusCode::SUCCESS;
630 }

◆ storeRawChannels()

StatusCode TileTBAANtuple::storeRawChannels ( const EventContext &  ctx,
const SG::ReadHandleKey< TileRawChannelContainer > &  containerKey,
bool  calib_mode,
std::vector< std::array< float, MAX_CHAN >> *  eneVec,
std::vector< std::array< float, MAX_CHAN >> *  timeVec,
std::vector< std::array< float, MAX_CHAN >> *  chi2Vec,
std::vector< std::array< float, MAX_CHAN >> *  pedVec,
bool  saveDQstatus = false 
)
private

/ Fill ntuple with data from TRC.

/ Default TRC container contains flat filtered and / named container fitted/opt filtered

final calibration

Definition at line 1289 of file TileTBAANtuple.cxx.

1297 {
1298 
1299 
1300  if (containerKey.empty()) {// empty name, nothing to do
1301  return StatusCode::FAILURE;
1302  }
1303 
1304  bool isFELIX = containerKey.key().find("Flx") != std::string::npos;
1305  int nDrawers = isFELIX ? m_nDrawersFlx : m_nDrawers;
1306  std::map<unsigned int, unsigned int, std::less<unsigned int>>& drawerMap = (isFELIX) ? m_drawerFlxMap : m_drawerMap;
1307 
1308  // get named container
1309  const TileRawChannelContainer* rcCnt = SG::makeHandle (containerKey, ctx).get();
1310 
1311  TileRawChannelUnit::UNIT rChUnit = rcCnt->get_unit();
1312  ATH_MSG_DEBUG( "RawChannel unit is " << rChUnit );
1313 
1314 
1315  if (rChUnit >= TileRawChannelUnit::OnlineADCcounts) { // this is container with DSP results
1316  m_dspUnit = rChUnit;
1317  m_dspFlags = rcCnt->get_bsflags() >> 16;
1318  ATH_MSG_DEBUG( "DSP flag is 0x" << MSG::hex << m_dspFlags << MSG::dec << " DSP unit is " << m_dspUnit );
1319 
1320  } else if ((m_useDspUnits || m_finalUnit >= TileRawChannelUnit::OnlineADCcounts)
1321  && rChUnit != TileRawChannelUnit::ADCcounts) {
1322 
1323  ATH_MSG_ERROR( "RawChannel units are not ADC counts, can't apply DSP-like calibration" );
1324  return StatusCode::FAILURE;
1325  }
1326 
1327  if (m_calibrateEnergyThisEvent) {
1328  if (m_useDspUnits) { // calibrate a-la online
1329  m_rchUnit = m_dspUnit;
1330  } else { // convert to final units
1331  m_rchUnit = (TileRawChannelUnit::UNIT)m_finalUnit.value();
1332  }
1333  } else {
1334  m_rchUnit = rChUnit;
1335  }
1336 
1337  ATH_MSG_DEBUG( "Final RawChannel unit is " << m_rchUnit );
1338 
1339  // drawerIndex is 0 - m_nDrawers-1, fragType is 1-4 B+/B-/EB+/EB-
1340  int drawerIndex, fragType;
1341 
1342  // Go through all TileRawChannelCollections
1343  for (const TileRawChannelCollection* rawChannelCollection : *rcCnt) {
1344  // determine type
1345  int fragId = rawChannelCollection->identify();
1346  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
1347 
1348  drawerMap_iterator itr = drawerMap.find(fragId);
1349  if ( itr != drawerMap.end() ) {
1350  drawerIndex = (*itr).second;
1351  } else {
1352  drawerIndex= -1;
1353  }
1354 
1355  if (drawerIndex < 0) {
1356  if ( !rawChannelCollection->empty() )
1357  ATH_MSG_DEBUG( "frag id 0x" << MSG::hex << fragId << MSG::dec << " was not found among valid frag IDs when storing TRC!" );
1358  } else {
1359  fragType = isFELIX ? fragId >> 8 : m_drawerType[drawerIndex];
1360  ATH_MSG_DEBUG( "TRC (" << containerKey.key()
1361  << ") Event# " << m_evtNr
1362  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1363  << " index "<< drawerIndex );
1364 
1365  // go through all TileRawChannels in collection
1366  for (const TileRawChannel* rch : *rawChannelCollection) {
1367  int index = drawerIndex;
1368  HWIdentifier hwid = rch->adc_HWID();
1369 
1370  // determine channel and gain
1371  int channel = m_tileHWID->channel(hwid);
1372  int gain = m_tileHWID->adc(hwid);
1373 
1374  if (calib_mode) {
1375  // gain, if hi add m_nDrawers to index
1376  if (gain == 1) index += nDrawers;
1377  }
1378 
1380  double energy = rch->amplitude();
1381  if (m_rchUnit != rChUnit) {
1382  if (m_rchUnit < TileRawChannelUnit::OnlineOffset)
1383  energy = m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, energy, rChUnit, m_rchUnit);
1384  else
1385  energy = m_tileToolEmscale->channelCalibOnl(drawerIdx, channel, gain, energy, m_rchUnit);
1386  }
1387 
1388  // cabling for testbeam (convert to pmt#-1)
1389  if ((m_TBperiod < 2015 ||
1390  (m_TBperiod==2015 && fragType<3) ||
1391  ((m_TBperiod==2016 || m_TBperiod==2021) && ((fragId&0xFF)<4 && fragId != 0x201)) ||
1392  (m_TBperiod==2017 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x203))) ||
1393  (m_TBperiod==2018 && ((fragId&0xFF)<4 && !(fragId == 0x201 || fragId == 0x402))) ||
1394  (m_TBperiod==2019 && ((fragId&0xFF)<5 && !(fragId == 0x201 || fragId == 0x203 || fragId >= 0x402))) ||
1395  (m_TBperiod==2022 && ((fragId&0xFF)<4 && !(fragId == 0x201 || (m_run >= 2210456 && fragId == 0x402)))))
1396  && fragType > 0 && m_pmtOrder)
1397  channel = digiChannel2PMT(fragType, channel);
1398 
1399  eneVec->at(index)[channel] = energy;
1400  timeVec->at(index)[channel] = rch->time();
1401  if (chi2Vec) {
1402  chi2Vec->at(index)[channel] = rch->quality();
1403  }
1404  if (pedVec) {
1405  pedVec->at(index)[channel] = rch->pedestal();
1406  }
1407 
1408  ATH_MSG_DEBUG( "TRC ene=" << energy
1409  << " time=" << rch->time()
1410  << " chi2=" << rch->quality()
1411  << " ped=" << rch->pedestal()
1412  << " pmt-1=" << channel
1413  << " index " << index );
1414 
1415  }
1416 
1417  if (saveDQstatus && !isFELIX) {
1418 
1419  int index1 = drawerIndex, index2 = drawerIndex + 1;
1420  if (calib_mode) index2 += m_nDrawers;
1421 
1422  for (int index = index1; index < index2; index += m_nDrawers) {
1423 
1424  m_ROD_GlobalCRCVec.at(index) = rawChannelCollection->getFragGlobalCRC() & 1;
1425  m_ROD_DMUMaskVec.at(index)[0] = rawChannelCollection->getFragRODChipMask();
1426  m_ROD_DMUMaskVec.at(index)[1] = rawChannelCollection->getFragFEChipMask();
1427 
1428  for (unsigned int dmu = 0; dmu < MAX_DMU; ++dmu) {
1429 
1430  m_ROD_DMUBCIDVec.at(index)[dmu] = (rawChannelCollection->getFragBCID() >> dmu) & 1;
1431  m_ROD_DMUmemoryErrVec.at(index)[dmu] = (rawChannelCollection->getFragMemoryPar() >> dmu) & 1;
1432  m_ROD_DMUSstrobeErrVec.at(index)[dmu] = (rawChannelCollection->getFragSstrobe() >> dmu) & 1;
1433  m_ROD_DMUDstrobeErrVec.at(index)[dmu] = (rawChannelCollection->getFragDstrobe() >> dmu) & 1;
1434  m_ROD_DMUHeadformatErrVec.at(index)[dmu] = (rawChannelCollection->getFragHeaderBit() >> dmu) & 1;
1435  m_ROD_DMUDataformatErrVec.at(index)[dmu] = (rawChannelCollection->getFragSampleBit() >> dmu) & 1;
1436  }
1437  }
1438  }
1439  }
1440  }
1441 
1442  return StatusCode::SUCCESS;
1443 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

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

◆ TRIGGER_addBranch()

void TileTBAANtuple::TRIGGER_addBranch ( void  )
private

///////////////////////////////////////////////////////////////////////////

/ Variables Legenda / / - C : a character string terminated by the 0 character / - B : an 8 bit signed integer / - b : an 8 bit unsigned integer 2^8=256 / - S : a 16 bit signed integer (i.e. a "short") / - s : a 16 bit unsigned integer 2^16=65536 / - I : a 32 bit signed integer (i.e an "int") / - i : a 32 bit unsigned integer 2^32=4294967296 / - F : a 32 bit floating point (i.e. a "float") / - D : a 64 bit floating point (i.e. a "double") / - L : a 64 bit signed integer / - l : a 64 bit unsigned integer / - O : a boolean //////////////////////////////////////////////////////////////////////////// /Add TRIGGER variables to the Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 2579 of file TileTBAANtuple.cxx.

2580 {
2581 
2582  m_ntuplePtr->Branch("EvTime",&m_evTime,"EvTime/I");
2583  m_ntuplePtr->Branch("Run",&m_run,"Run/I");
2584  m_ntuplePtr->Branch("Evt",&m_evt,"Evt/I");
2585  m_ntuplePtr->Branch("Trig",&m_trigType,"Trig/S");
2586  m_ntuplePtr->Branch("DSPflags",&m_dspFlags,"DSPflags/I");
2587  m_ntuplePtr->Branch("DSPunits",&m_dspUnit,"DSPunits/S");
2588  m_ntuplePtr->Branch("OFLunits",&m_rchUnit,"OFLunits/S");
2589 
2590  if ( m_completeNtuple ) {
2591  int nDrawersAll = m_nDrawers.value() + m_nDrawersFlx.value();
2592  if (nDrawersAll > 0) {
2593  m_l1ID.resize(nDrawersAll + 1);
2594  m_l1Type.resize(nDrawersAll + 1);
2595  m_evType.resize(nDrawersAll + 1);
2596  m_evBCID.resize(nDrawersAll + 1);
2597  m_frBCID.resize(nDrawersAll);
2598  }
2599 
2600  // Info from ROD headers
2601  // m_nDrawers drawers separately (i.e. with duplications) + Beam ROD
2602  m_ntuplePtr->Branch("L1ID",&m_l1ID);
2603  m_ntuplePtr->Branch("L1Type",&m_l1Type);
2604  m_ntuplePtr->Branch("EvType",&m_evType);
2605  m_ntuplePtr->Branch("EvBCID",&m_evBCID);
2606  m_ntuplePtr->Branch("FrBCID",&m_frBCID);
2607  }
2608 
2609 
2610 }

◆ TRIGGER_clearBranch()

void TileTBAANtuple::TRIGGER_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER variables

////////////////////////////////////////////////////////////////////////////

Definition at line 2678 of file TileTBAANtuple.cxx.

2678  {
2679 
2680  m_evTime = 0;
2681  m_run = 0;
2682  m_evt = 0;
2683  m_trigType = 0;
2684 
2685  if (m_completeNtuple) {
2686  std::fill(m_l1ID.begin(), m_l1ID.end(), 0);
2687  std::fill(m_l1Type.begin(), m_l1Type.end(), 0);
2688  std::fill(m_evType.begin(), m_evType.end(), 0);
2689  std::fill(m_evBCID.begin(), m_evBCID.end(), 0);
2690  std::fill(m_frBCID.begin(), m_frBCID.end(), 0);
2691  }
2692 }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_adder

int** TileTBAANtuple::m_adder
private

Definition at line 444 of file TileTBAANtuple.h.

◆ m_adderFilterAlgTool

ToolHandle<TileRawChannelBuilderFlatFilter> TileTBAANtuple::m_adderFilterAlgTool
private
Initial value:
{this,
"TileRawChannelBuilderFlatFilter", "TileRawChannelBuilderFlatFilter", "Tile raw channel builder tool"}

Definition at line 159 of file TileTBAANtuple.h.

◆ m_BarEne

std::array<float, 3> TileTBAANtuple::m_BarEne
private

Definition at line 581 of file TileTBAANtuple.h.

◆ m_bcidVec

std::vector<std::array<int, MAX_DMU> > TileTBAANtuple::m_bcidVec
private

Definition at line 515 of file TileTBAANtuple.h.

◆ m_beamBC0X1

Gaudi::Property<float> TileTBAANtuple::m_beamBC0X1 {this, "BC0X1", 0.0, "Params for Beam TDC: Beam chamber: 0"}
private

Definition at line 198 of file TileTBAANtuple.h.

◆ m_beamBC0X2

Gaudi::Property<float> TileTBAANtuple::m_beamBC0X2 {this, "BC0X2", 0.2, "Params for Beam TDC: Beam chamber: 0"}
private

Definition at line 199 of file TileTBAANtuple.h.

◆ m_beamBC0Y1

Gaudi::Property<float> TileTBAANtuple::m_beamBC0Y1 {this, "BC0Y1", 0.0, "Params for Beam TDC: Beam chamber: 0"}
private

Definition at line 200 of file TileTBAANtuple.h.

◆ m_beamBC0Y2

Gaudi::Property<float> TileTBAANtuple::m_beamBC0Y2 {this, "BC0Y2", 0.2, "Params for Beam TDC: Beam chamber: 0"}
private

Definition at line 201 of file TileTBAANtuple.h.

◆ m_beamBC0Z

Gaudi::Property<float> TileTBAANtuple::m_beamBC0Z {this, "BC0Z", 17138.0, "Params for Beam TDC: Beam chamber: 0"}
private

Definition at line 202 of file TileTBAANtuple.h.

◆ m_beamBC1X1

Gaudi::Property<float> TileTBAANtuple::m_beamBC1X1 {this, "BC1X1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 204 of file TileTBAANtuple.h.

◆ m_beamBC1X2

Gaudi::Property<float> TileTBAANtuple::m_beamBC1X2 {this, "BC1X2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 205 of file TileTBAANtuple.h.

◆ m_beamBC1Y1

Gaudi::Property<float> TileTBAANtuple::m_beamBC1Y1 {this, "BC1Y1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 206 of file TileTBAANtuple.h.

◆ m_beamBC1Y2

Gaudi::Property<float> TileTBAANtuple::m_beamBC1Y2 {this, "BC1Y2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 207 of file TileTBAANtuple.h.

◆ m_beamBC1Z

Gaudi::Property<float> TileTBAANtuple::m_beamBC1Z {this, "BC1Z", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 208 of file TileTBAANtuple.h.

◆ m_beamBC1Z_0

Gaudi::Property<float> TileTBAANtuple::m_beamBC1Z_0 {this, "BC1Z_0", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 209 of file TileTBAANtuple.h.

◆ m_beamBC1Z_90

Gaudi::Property<float> TileTBAANtuple::m_beamBC1Z_90 {this, "BC1Z_90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 210 of file TileTBAANtuple.h.

◆ m_beamBC1Z_min90

Gaudi::Property<float> TileTBAANtuple::m_beamBC1Z_min90 {this, "BC1Z_min90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 1"}
private

Definition at line 211 of file TileTBAANtuple.h.

◆ m_beamBC2X1

Gaudi::Property<float> TileTBAANtuple::m_beamBC2X1 {this, "BC2X1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 213 of file TileTBAANtuple.h.

◆ m_beamBC2X2

Gaudi::Property<float> TileTBAANtuple::m_beamBC2X2 {this, "BC2X2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 214 of file TileTBAANtuple.h.

◆ m_beamBC2Y1

Gaudi::Property<float> TileTBAANtuple::m_beamBC2Y1 {this, "BC2Y1", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 215 of file TileTBAANtuple.h.

◆ m_beamBC2Y2

Gaudi::Property<float> TileTBAANtuple::m_beamBC2Y2 {this, "BC2Y2", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 216 of file TileTBAANtuple.h.

◆ m_beamBC2Z

Gaudi::Property<float> TileTBAANtuple::m_beamBC2Z {this, "BC2Z", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 217 of file TileTBAANtuple.h.

◆ m_beamBC2Z_0

Gaudi::Property<float> TileTBAANtuple::m_beamBC2Z_0 {this, "BC2Z_0", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 218 of file TileTBAANtuple.h.

◆ m_beamBC2Z_90

Gaudi::Property<float> TileTBAANtuple::m_beamBC2Z_90 {this, "BC2Z_90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 219 of file TileTBAANtuple.h.

◆ m_beamBC2Z_min90

Gaudi::Property<float> TileTBAANtuple::m_beamBC2Z_min90 {this, "BC2Z_min90", NOT_SETUP - 1, "Params for Beam TDC: Beam chamber: 2"}
private

Definition at line 220 of file TileTBAANtuple.h.

◆ m_beamBN1X1

Gaudi::Property<float> TileTBAANtuple::m_beamBN1X1 {this, "BN1X1", 0.0, "Params for Beam TDC: Beam chamber: -1"}
private

Definition at line 193 of file TileTBAANtuple.h.

◆ m_beamBN1X2

Gaudi::Property<float> TileTBAANtuple::m_beamBN1X2 {this, "BN1X2", 0.2, "Params for Beam TDC: Beam chamber: -1"}
private

Definition at line 194 of file TileTBAANtuple.h.

◆ m_beamBN1Y1

Gaudi::Property<float> TileTBAANtuple::m_beamBN1Y1 {this, "BN1Y1", 0.0, "Params for Beam TDC: Beam chamber: -1"}
private

Definition at line 195 of file TileTBAANtuple.h.

◆ m_beamBN1Y2

Gaudi::Property<float> TileTBAANtuple::m_beamBN1Y2 {this, "BN1Y2", 0.2, "Params for Beam TDC: Beam chamber: -1"}
private

Definition at line 196 of file TileTBAANtuple.h.

◆ m_beamBN2X1

Gaudi::Property<float> TileTBAANtuple::m_beamBN2X1 {this, "BN2X1", 0.0, "Params for Beam TDC: Beam chamber: -2"}
private

Definition at line 188 of file TileTBAANtuple.h.

◆ m_beamBN2X2

Gaudi::Property<float> TileTBAANtuple::m_beamBN2X2 {this, "BN2X2", 0.2, "Params for Beam TDC: Beam chamber: -2"}
private

Definition at line 189 of file TileTBAANtuple.h.

◆ m_beamBN2Y1

Gaudi::Property<float> TileTBAANtuple::m_beamBN2Y1 {this, "BN2Y1", 0.0, "Params for Beam TDC: Beam chamber: -2"}
private

Definition at line 190 of file TileTBAANtuple.h.

◆ m_beamBN2Y2

Gaudi::Property<float> TileTBAANtuple::m_beamBN2Y2 {this, "BN2Y2", 0.2, "Params for Beam TDC: Beam chamber: -2"}
private

Definition at line 191 of file TileTBAANtuple.h.

◆ m_beamElemContainerKey

SG::ReadHandleKey<TileBeamElemContainer> TileTBAANtuple::m_beamElemContainerKey
private
Initial value:
{this,
"TileBeamElemContainer", "TileBeamElemCnt", "Input Tile beam elements container"}

Definition at line 120 of file TileTBAANtuple.h.

◆ m_beamFragList

Gaudi::Property<std::vector<std::string> > TileTBAANtuple::m_beamFragList {this, "beamFragList", {}, "List of beam frag IDs to store in the ntuple"}
private

Definition at line 186 of file TileTBAANtuple.h.

◆ m_beamIdList

bool TileTBAANtuple::m_beamIdList[32]
private

Definition at line 607 of file TileTBAANtuple.h.

◆ m_bsInput

Gaudi::Property<bool> TileTBAANtuple::m_bsInput {this, "BSInput", true, "Bytestream input"}
private

Definition at line 171 of file TileTBAANtuple.h.

◆ m_btdc

std::vector<std::vector<int> >* TileTBAANtuple::m_btdc
private

Definition at line 473 of file TileTBAANtuple.h.

◆ m_btdc1

std::array<int, 16> TileTBAANtuple::m_btdc1
private

Definition at line 470 of file TileTBAANtuple.h.

◆ m_btdc2

std::array<int, 16> TileTBAANtuple::m_btdc2
private

Definition at line 471 of file TileTBAANtuple.h.

◆ m_btdcNchMultiHit

int TileTBAANtuple::m_btdcNchMultiHit[2]
private

Definition at line 477 of file TileTBAANtuple.h.

◆ m_btdcNhit

int TileTBAANtuple::m_btdcNhit[16]
private

Definition at line 476 of file TileTBAANtuple.h.

◆ m_cabling

const TileCablingService* TileTBAANtuple::m_cabling {nullptr}
private

Definition at line 628 of file TileTBAANtuple.h.

◆ m_calibMode

Gaudi::Property<bool> TileTBAANtuple::m_calibMode {this, "CalibMode", false, "If data should be put in calib mode"}
private

Definition at line 168 of file TileTBAANtuple.h.

◆ m_calibrateEnergy

Gaudi::Property<bool> TileTBAANtuple::m_calibrateEnergy {this, "CalibrateEnergy", true, "Calibrate energy"}
private

Definition at line 165 of file TileTBAANtuple.h.

◆ m_calibrateEnergyThisEvent

bool TileTBAANtuple::m_calibrateEnergyThisEvent
private

Definition at line 620 of file TileTBAANtuple.h.

◆ m_cellContainerKey

SG::ReadHandleKey<CaloCellContainer> TileTBAANtuple::m_cellContainerKey
private
Initial value:
{this,
"CaloCellContainer", "AllCalo", "Input Calo cell container"}

Definition at line 153 of file TileTBAANtuple.h.

◆ m_cher1

uint32_t TileTBAANtuple::m_cher1
private

Definition at line 456 of file TileTBAANtuple.h.

◆ m_cher2

uint32_t TileTBAANtuple::m_cher2
private

Definition at line 457 of file TileTBAANtuple.h.

◆ m_cher3

uint32_t TileTBAANtuple::m_cher3
private

Definition at line 458 of file TileTBAANtuple.h.

◆ m_chi2cVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_chi2cVec
private

Definition at line 542 of file TileTBAANtuple.h.

◆ m_chi2DspVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_chi2DspVec
private

Definition at line 549 of file TileTBAANtuple.h.

◆ m_chi2FlatVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_chi2FlatVec
private

Definition at line 534 of file TileTBAANtuple.h.

◆ m_chi2flxfitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_chi2flxfitVec
private

Definition at line 553 of file TileTBAANtuple.h.

◆ m_chi2flxoptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_chi2flxoptVec
private

Definition at line 557 of file TileTBAANtuple.h.

◆ m_chi2OptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_chi2OptVec
private

Definition at line 546 of file TileTBAANtuple.h.

◆ m_chi2Vec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_chi2Vec
private

Definition at line 538 of file TileTBAANtuple.h.

◆ m_cispar

int TileTBAANtuple::m_cispar[16]
private

Definition at line 450 of file TileTBAANtuple.h.

◆ m_coincFlag1

int TileTBAANtuple::m_coincFlag1
private

Definition at line 594 of file TileTBAANtuple.h.

◆ m_coincFlag2

int TileTBAANtuple::m_coincFlag2
private

Definition at line 595 of file TileTBAANtuple.h.

◆ m_coincFlag3

int TileTBAANtuple::m_coincFlag3
private

Definition at line 596 of file TileTBAANtuple.h.

◆ m_coincFlag4

int TileTBAANtuple::m_coincFlag4
private

Definition at line 597 of file TileTBAANtuple.h.

◆ m_coincFlag5

int TileTBAANtuple::m_coincFlag5
private

Definition at line 598 of file TileTBAANtuple.h.

◆ m_coincFlag6

int TileTBAANtuple::m_coincFlag6
private

Definition at line 599 of file TileTBAANtuple.h.

◆ m_coincFlag7

int TileTBAANtuple::m_coincFlag7
private

Definition at line 600 of file TileTBAANtuple.h.

◆ m_coincFlag8

int TileTBAANtuple::m_coincFlag8
private

Definition at line 601 of file TileTBAANtuple.h.

◆ m_coincTrig1

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig1
private

Definition at line 585 of file TileTBAANtuple.h.

◆ m_coincTrig2

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig2
private

Definition at line 586 of file TileTBAANtuple.h.

◆ m_coincTrig3

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig3
private

Definition at line 587 of file TileTBAANtuple.h.

◆ m_coincTrig4

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig4
private

Definition at line 588 of file TileTBAANtuple.h.

◆ m_coincTrig5

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig5
private

Definition at line 589 of file TileTBAANtuple.h.

◆ m_coincTrig6

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig6
private

Definition at line 590 of file TileTBAANtuple.h.

◆ m_coincTrig7

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig7
private

Definition at line 591 of file TileTBAANtuple.h.

◆ m_coincTrig8

std::array<unsigned int, 96> TileTBAANtuple::m_coincTrig8
private

Definition at line 592 of file TileTBAANtuple.h.

◆ m_commonPU

int TileTBAANtuple::m_commonPU
private

Definition at line 441 of file TileTBAANtuple.h.

◆ m_completeNtuple

Gaudi::Property<bool> TileTBAANtuple::m_completeNtuple {this, "CompleteNtuple", true, "Complete the ntuple"}
private

Definition at line 170 of file TileTBAANtuple.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_digitsContainerFlxKey

SG::ReadHandleKey<TileDigitsContainer> TileTBAANtuple::m_digitsContainerFlxKey
private
Initial value:
{this,
"TileDigitsContainerFlx", "", "Input Tile FELIX digits container"}

Definition at line 117 of file TileTBAANtuple.h.

◆ m_digitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileTBAANtuple::m_digitsContainerKey
private
Initial value:
{this,
"TileDigitsContainer", "TileDigitsCnt", "Input Tile digits container"}

Definition at line 114 of file TileTBAANtuple.h.

◆ m_DMUDataparityErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_DMUDataparityErrVec
private

Definition at line 523 of file TileTBAANtuple.h.

◆ m_DMUDstrobeErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_DMUDstrobeErrVec
private

Definition at line 520 of file TileTBAANtuple.h.

◆ m_DMUformatErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_DMUformatErrVec
private

Definition at line 517 of file TileTBAANtuple.h.

◆ m_DMUheaderVec

std::vector<std::array<uint32_t, MAX_DMU> > TileTBAANtuple::m_DMUheaderVec
private

Definition at line 516 of file TileTBAANtuple.h.

◆ m_DMUHeadparityErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_DMUHeadparityErrVec
private

Definition at line 522 of file TileTBAANtuple.h.

◆ m_dmuMaskVec

std::vector<std::array<int, 2> > TileTBAANtuple::m_dmuMaskVec
private

Definition at line 524 of file TileTBAANtuple.h.

◆ m_DMUmemoryErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_DMUmemoryErrVec
private

Definition at line 519 of file TileTBAANtuple.h.

◆ m_DMUparityErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_DMUparityErrVec
private

Definition at line 518 of file TileTBAANtuple.h.

◆ m_DMUSstrobeErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_DMUSstrobeErrVec
private

Definition at line 521 of file TileTBAANtuple.h.

◆ m_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileTBAANtuple::m_dqStatusKey
private
Initial value:
{ this,
"TileDQstatus", "TileDQstatus", "TileDQstatus key" }

Definition at line 162 of file TileTBAANtuple.h.

◆ m_drawerFlxMap

std::map<unsigned int, unsigned int, std::less<unsigned int> > TileTBAANtuple::m_drawerFlxMap
private

Definition at line 604 of file TileTBAANtuple.h.

◆ m_drawerList

Gaudi::Property<std::vector<std::string> > TileTBAANtuple::m_drawerList {this, "drawerList", {"-1"}, "List of frag IDs in correct order; Setup drawer list from data"}
private

Definition at line 184 of file TileTBAANtuple.h.

◆ m_drawerMap

std::map<unsigned int, unsigned int, std::less<unsigned int> > TileTBAANtuple::m_drawerMap
private

Definition at line 603 of file TileTBAANtuple.h.

◆ m_drawerType

Gaudi::Property<std::vector<int> > TileTBAANtuple::m_drawerType {this, "drawerType", {}, "Type of every drawer 1-4: B+, B-, EB+, EB-; Take drawer type from Frag ID (doesn't work for 2003)"}
private

Definition at line 185 of file TileTBAANtuple.h.

◆ m_dspFlags

int TileTBAANtuple::m_dspFlags
private

Definition at line 356 of file TileTBAANtuple.h.

◆ m_dspRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileTBAANtuple::m_dspRawChannelContainerKey
private
Initial value:
{this,
"TileRawChannelContainerDsp", "", "Input Tile DSP raw channel container"}

Definition at line 132 of file TileTBAANtuple.h.

◆ m_dspUnit

TileRawChannelUnit::UNIT TileTBAANtuple::m_dspUnit
private

Unit for TileRawChannels in DSP.

Definition at line 623 of file TileTBAANtuple.h.

◆ m_ecal

std::array<float,8> TileTBAANtuple::m_ecal
private

Definition at line 372 of file TileTBAANtuple.h.

◆ m_eDspVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_eDspVec
private

Definition at line 547 of file TileTBAANtuple.h.

◆ m_efitcVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_efitcVec
private

Definition at line 539 of file TileTBAANtuple.h.

◆ m_efitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_efitVec
private

Definition at line 535 of file TileTBAANtuple.h.

◆ m_eflxfitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_eflxfitVec
private

Definition at line 551 of file TileTBAANtuple.h.

◆ m_eflxoptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_eflxoptVec
private

Definition at line 555 of file TileTBAANtuple.h.

◆ m_ehitCnt

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_ehitCnt
private

Definition at line 617 of file TileTBAANtuple.h.

◆ m_ehitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_ehitVec
private

Definition at line 615 of file TileTBAANtuple.h.

◆ m_eneAdd

std::array<float, 16> TileTBAANtuple::m_eneAdd
private

Definition at line 446 of file TileTBAANtuple.h.

◆ m_eneVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_eneVec
private

Definition at line 531 of file TileTBAANtuple.h.

◆ m_eOptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_eOptVec
private

Definition at line 543 of file TileTBAANtuple.h.

◆ m_eta

float TileTBAANtuple::m_eta
private

Definition at line 611 of file TileTBAANtuple.h.

◆ m_etaFileName

Gaudi::Property<std::string> TileTBAANtuple::m_etaFileName {this, "EtaFileName", "TileEtaCTB.txt", "File name with ETA, for CTB 2004 only"}
private

Definition at line 223 of file TileTBAANtuple.h.

◆ m_evBCID

std::vector<int> TileTBAANtuple::m_evBCID
private

Definition at line 361 of file TileTBAANtuple.h.

◆ m_eventsPerFile

Gaudi::Property<int> TileTBAANtuple::m_eventsPerFile {this, "EventsPerFile", 200000, "Number of events per file"}
private

Definition at line 178 of file TileTBAANtuple.h.

◆ m_evt

int TileTBAANtuple::m_evt
private

Definition at line 354 of file TileTBAANtuple.h.

◆ m_evtflxVec

std::vector<int> TileTBAANtuple::m_evtflxVec
private

Definition at line 508 of file TileTBAANtuple.h.

◆ m_evTime

int TileTBAANtuple::m_evTime
private

Definition at line 352 of file TileTBAANtuple.h.

◆ m_evtNr

int TileTBAANtuple::m_evtNr
private

Definition at line 349 of file TileTBAANtuple.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_evtVec

std::vector<int> TileTBAANtuple::m_evtVec
private

Definition at line 504 of file TileTBAANtuple.h.

◆ m_evType

std::vector<int> TileTBAANtuple::m_evType
private

Definition at line 362 of file TileTBAANtuple.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_ExtEne

std::array<float, 3> TileTBAANtuple::m_ExtEne
private

Definition at line 582 of file TileTBAANtuple.h.

◆ m_feCRCVec

std::vector<std::array<int, MAX_DMU> > TileTBAANtuple::m_feCRCVec
private

Definition at line 528 of file TileTBAANtuple.h.

◆ m_finalUnit

Gaudi::Property<int> TileTBAANtuple::m_finalUnit {this, "OfflineUnits", TileRawChannelUnit::MegaElectronVolts, "Calibrate everything to this level"}
private

Definition at line 167 of file TileTBAANtuple.h.

◆ m_fitcRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileTBAANtuple::m_fitcRawChannelContainerKey
private
Initial value:
{this,
"TileRawChannelContainerFitCool", "", "Input Tile raw channel container reconstructed with Fit COOL method"}

Definition at line 135 of file TileTBAANtuple.h.

◆ m_fitRawChannelContainerKey

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

Definition at line 126 of file TileTBAANtuple.h.

◆ m_flatRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileTBAANtuple::m_flatRawChannelContainerKey
private
Initial value:
{this,
"TileRawChannelContainerFlat", "", "Input Tile raw channel container reconstructed with Flat method"}

Definition at line 123 of file TileTBAANtuple.h.

◆ m_flxFitRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileTBAANtuple::m_flxFitRawChannelContainerKey
private
Initial value:
{this,
"TileRawChannelContainerFitFlx", "", "Input Tile FELIX raw channel container reconstructed with Fit method"}

Definition at line 138 of file TileTBAANtuple.h.

◆ m_flxOptRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileTBAANtuple::m_flxOptRawChannelContainerKey
private
Initial value:
{this,
"TileRawChannelContainerOptFlx", "", "Input Tile FELIX raw channel container reconstructed with Opt2 method"}

Definition at line 141 of file TileTBAANtuple.h.

◆ m_frBCID

std::vector<int> TileTBAANtuple::m_frBCID
private

Definition at line 363 of file TileTBAANtuple.h.

◆ m_gainflxVec

std::vector<std::array<int, MAX_CHAN> > TileTBAANtuple::m_gainflxVec
private

Definition at line 512 of file TileTBAANtuple.h.

◆ m_gainVec

std::vector<std::array<int, MAX_CHAN> > TileTBAANtuple::m_gainVec
private

Definition at line 526 of file TileTBAANtuple.h.

◆ m_GapEne

std::array<float, 3> TileTBAANtuple::m_GapEne
private

Definition at line 583 of file TileTBAANtuple.h.

◆ m_hitContainerKey

SG::ReadHandleKey<TileHitContainer> TileTBAANtuple::m_hitContainerKey
private
Initial value:
{this,
"TileHitContainer", "TileHitCnt", "Input Tile hit container"}

Definition at line 147 of file TileTBAANtuple.h.

◆ m_hitVectorKey

SG::ReadHandleKey<TileHitVector> TileTBAANtuple::m_hitVectorKey
private
Initial value:
{this,
"TileHitVector", "TileHitVec", "Input Tile hit vector"}

Definition at line 150 of file TileTBAANtuple.h.

◆ m_l1ID

std::vector<int> TileTBAANtuple::m_l1ID
private

Definition at line 359 of file TileTBAANtuple.h.

◆ m_l1Type

std::vector<int> TileTBAANtuple::m_l1Type
private

Definition at line 360 of file TileTBAANtuple.h.

◆ m_LarEne

std::array<float, 4> TileTBAANtuple::m_LarEne
private

Definition at line 580 of file TileTBAANtuple.h.

◆ m_las0

float TileTBAANtuple::m_las0
private

Definition at line 434 of file TileTBAANtuple.h.

◆ m_las1

float TileTBAANtuple::m_las1
private

Definition at line 435 of file TileTBAANtuple.h.

◆ m_las2

float TileTBAANtuple::m_las2
private

Definition at line 436 of file TileTBAANtuple.h.

◆ m_las3

float TileTBAANtuple::m_las3
private

Definition at line 437 of file TileTBAANtuple.h.

◆ m_las_BCID

int TileTBAANtuple::m_las_BCID
private

Definition at line 378 of file TileTBAANtuple.h.

◆ m_las_D1_ADC

int TileTBAANtuple::m_las_D1_ADC
private

Definition at line 384 of file TileTBAANtuple.h.

◆ m_las_D1_Alpha

double TileTBAANtuple::m_las_D1_Alpha
private

Definition at line 399 of file TileTBAANtuple.h.

◆ m_las_D1_Alpha_RMS

double TileTBAANtuple::m_las_D1_Alpha_RMS
private

Definition at line 404 of file TileTBAANtuple.h.

◆ m_las_D1_AlphaPed

double TileTBAANtuple::m_las_D1_AlphaPed
private

Definition at line 409 of file TileTBAANtuple.h.

◆ m_las_D1_AlphaPed_RMS

double TileTBAANtuple::m_las_D1_AlphaPed_RMS
private

Definition at line 414 of file TileTBAANtuple.h.

◆ m_las_D1_Ped

double TileTBAANtuple::m_las_D1_Ped
private

Definition at line 389 of file TileTBAANtuple.h.

◆ m_las_D1_Ped_RMS

double TileTBAANtuple::m_las_D1_Ped_RMS
private

Definition at line 394 of file TileTBAANtuple.h.

◆ m_las_D2_ADC

int TileTBAANtuple::m_las_D2_ADC
private

Definition at line 385 of file TileTBAANtuple.h.

◆ m_las_D2_Alpha

double TileTBAANtuple::m_las_D2_Alpha
private

Definition at line 400 of file TileTBAANtuple.h.

◆ m_las_D2_Alpha_RMS

double TileTBAANtuple::m_las_D2_Alpha_RMS
private

Definition at line 405 of file TileTBAANtuple.h.

◆ m_las_D2_AlphaPed

double TileTBAANtuple::m_las_D2_AlphaPed
private

Definition at line 410 of file TileTBAANtuple.h.

◆ m_las_D2_AlphaPed_RMS

double TileTBAANtuple::m_las_D2_AlphaPed_RMS
private

Definition at line 415 of file TileTBAANtuple.h.

◆ m_las_D2_Ped

double TileTBAANtuple::m_las_D2_Ped
private

Definition at line 390 of file TileTBAANtuple.h.

◆ m_las_D2_Ped_RMS

double TileTBAANtuple::m_las_D2_Ped_RMS
private

Definition at line 395 of file TileTBAANtuple.h.

◆ m_las_D3_ADC

int TileTBAANtuple::m_las_D3_ADC
private

Definition at line 386 of file TileTBAANtuple.h.

◆ m_las_D3_Alpha

double TileTBAANtuple::m_las_D3_Alpha
private

Definition at line 401 of file TileTBAANtuple.h.

◆ m_las_D3_Alpha_RMS

double TileTBAANtuple::m_las_D3_Alpha_RMS
private

Definition at line 406 of file TileTBAANtuple.h.

◆ m_las_D3_AlphaPed

double TileTBAANtuple::m_las_D3_AlphaPed
private

Definition at line 411 of file TileTBAANtuple.h.

◆ m_las_D3_AlphaPed_RMS

double TileTBAANtuple::m_las_D3_AlphaPed_RMS
private

Definition at line 416 of file TileTBAANtuple.h.

◆ m_las_D3_Ped

double TileTBAANtuple::m_las_D3_Ped
private

Definition at line 391 of file TileTBAANtuple.h.

◆ m_las_D3_Ped_RMS

double TileTBAANtuple::m_las_D3_Ped_RMS
private

Definition at line 396 of file TileTBAANtuple.h.

◆ m_las_D4_ADC

int TileTBAANtuple::m_las_D4_ADC
private

Definition at line 387 of file TileTBAANtuple.h.

◆ m_las_D4_Alpha

double TileTBAANtuple::m_las_D4_Alpha
private

Definition at line 402 of file TileTBAANtuple.h.

◆ m_las_D4_Alpha_RMS

double TileTBAANtuple::m_las_D4_Alpha_RMS
private

Definition at line 407 of file TileTBAANtuple.h.

◆ m_las_D4_AlphaPed

double TileTBAANtuple::m_las_D4_AlphaPed
private

Definition at line 412 of file TileTBAANtuple.h.

◆ m_las_D4_AlphaPed_RMS

double TileTBAANtuple::m_las_D4_AlphaPed_RMS
private

Definition at line 417 of file TileTBAANtuple.h.

◆ m_las_D4_Ped

double TileTBAANtuple::m_las_D4_Ped
private

Definition at line 392 of file TileTBAANtuple.h.

◆ m_las_D4_Ped_RMS

double TileTBAANtuple::m_las_D4_Ped_RMS
private

Definition at line 397 of file TileTBAANtuple.h.

◆ m_las_Filt

int TileTBAANtuple::m_las_Filt
private

Definition at line 380 of file TileTBAANtuple.h.

◆ m_las_MeasAmp

double TileTBAANtuple::m_las_MeasAmp
private

Definition at line 382 of file TileTBAANtuple.h.

◆ m_las_PMT1_ADC

int TileTBAANtuple::m_las_PMT1_ADC
private

Definition at line 419 of file TileTBAANtuple.h.

◆ m_las_PMT1_Ped

double TileTBAANtuple::m_las_PMT1_Ped
private

Definition at line 425 of file TileTBAANtuple.h.

◆ m_las_PMT1_Ped_RMS

double TileTBAANtuple::m_las_PMT1_Ped_RMS
private

Definition at line 428 of file TileTBAANtuple.h.

◆ m_las_PMT1_TDC

int TileTBAANtuple::m_las_PMT1_TDC
private

Definition at line 422 of file TileTBAANtuple.h.

◆ m_las_PMT2_ADC

int TileTBAANtuple::m_las_PMT2_ADC
private

Definition at line 420 of file TileTBAANtuple.h.

◆ m_las_PMT2_Ped

double TileTBAANtuple::m_las_PMT2_Ped
private

Definition at line 426 of file TileTBAANtuple.h.

◆ m_las_PMT2_Ped_RMS

double TileTBAANtuple::m_las_PMT2_Ped_RMS
private

Definition at line 429 of file TileTBAANtuple.h.

◆ m_las_PMT2_TDC

int TileTBAANtuple::m_las_PMT2_TDC
private

Definition at line 423 of file TileTBAANtuple.h.

◆ m_las_ReqAmp

double TileTBAANtuple::m_las_ReqAmp
private

Definition at line 381 of file TileTBAANtuple.h.

◆ m_las_Temperature

double TileTBAANtuple::m_las_Temperature
private

Definition at line 431 of file TileTBAANtuple.h.

◆ m_laserObjectKey

SG::ReadHandleKey<TileLaserObject> TileTBAANtuple::m_laserObjectKey
private
Initial value:
{this,
"TileLaserObj", "", "Input Tile laser object"}

Definition at line 144 of file TileTBAANtuple.h.

◆ m_lasExtra

std::array<float, 4> TileTBAANtuple::m_lasExtra
private

Definition at line 438 of file TileTBAANtuple.h.

◆ m_lasFlag

int TileTBAANtuple::m_lasFlag
private

Definition at line 433 of file TileTBAANtuple.h.

◆ m_mdBcidflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdBcidflxVec
private

Definition at line 570 of file TileTBAANtuple.h.

◆ m_mdCapacitorflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdCapacitorflxVec
private

Definition at line 578 of file TileTBAANtuple.h.

◆ m_mdChargeflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdChargeflxVec
private

Definition at line 576 of file TileTBAANtuple.h.

◆ m_mdChargeTimeflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdChargeTimeflxVec
private

Definition at line 577 of file TileTBAANtuple.h.

◆ m_mdL1idflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdL1idflxVec
private

Definition at line 569 of file TileTBAANtuple.h.

◆ m_mdModuleflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdModuleflxVec
private

Definition at line 571 of file TileTBAANtuple.h.

◆ m_mdPedHiflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdPedHiflxVec
private

Definition at line 574 of file TileTBAANtuple.h.

◆ m_mdPedLoflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdPedLoflxVec
private

Definition at line 573 of file TileTBAANtuple.h.

◆ m_mdRunflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdRunflxVec
private

Definition at line 575 of file TileTBAANtuple.h.

◆ m_mdRunTypeflxVec

std::vector<std::array<int, MAX_MINIDRAWER> > TileTBAANtuple::m_mdRunTypeflxVec
private

Definition at line 572 of file TileTBAANtuple.h.

◆ m_muBack

std::array<float,14> TileTBAANtuple::m_muBack
private

Definition at line 368 of file TileTBAANtuple.h.

◆ m_muBackHit

float TileTBAANtuple::m_muBackHit
private

Definition at line 366 of file TileTBAANtuple.h.

◆ m_muBackSum

float TileTBAANtuple::m_muBackSum
private

Definition at line 367 of file TileTBAANtuple.h.

◆ m_muCalib

std::array<float,2> TileTBAANtuple::m_muCalib
private

Definition at line 369 of file TileTBAANtuple.h.

◆ m_muHalo

uint32_t TileTBAANtuple::m_muHalo
private

Definition at line 460 of file TileTBAANtuple.h.

◆ m_muTag

uint32_t TileTBAANtuple::m_muTag
private

Definition at line 459 of file TileTBAANtuple.h.

◆ m_muVeto

uint32_t TileTBAANtuple::m_muVeto
private

Definition at line 461 of file TileTBAANtuple.h.

◆ m_nDrawers

Gaudi::Property<unsigned int> TileTBAANtuple::m_nDrawers {this, "NDrawers", 6, "Number of drawers"}
private

Definition at line 175 of file TileTBAANtuple.h.

◆ m_nDrawersFlx

Gaudi::Property<unsigned int> TileTBAANtuple::m_nDrawersFlx {this, "NDrawersFelix", 0, "Number of drawers for FELIX"}
private

Definition at line 176 of file TileTBAANtuple.h.

◆ m_nSamples

Gaudi::Property<int> TileTBAANtuple::m_nSamples {this, "NSamples", NOT_SETUP, "Number of samples"}
private

Definition at line 173 of file TileTBAANtuple.h.

◆ m_nSamplesFlx

Gaudi::Property<int> TileTBAANtuple::m_nSamplesFlx {this, "NSamplesFelix", NOT_SETUP, "Number of samples for FELIX"}
private

Definition at line 174 of file TileTBAANtuple.h.

◆ m_nSamplesFlxInDrawer

std::vector<int> TileTBAANtuple::m_nSamplesFlxInDrawer
private

Definition at line 633 of file TileTBAANtuple.h.

◆ m_nSamplesFlxInDrawerMap

std::map<int, int> TileTBAANtuple::m_nSamplesFlxInDrawerMap
private

Definition at line 631 of file TileTBAANtuple.h.

◆ m_nSamplesInDrawer

std::vector<int> TileTBAANtuple::m_nSamplesInDrawer
private

Definition at line 632 of file TileTBAANtuple.h.

◆ m_nSamplesInDrawerMap

std::map<int, int> TileTBAANtuple::m_nSamplesInDrawerMap
private

Definition at line 630 of file TileTBAANtuple.h.

◆ m_ntupleCreated

bool TileTBAANtuple::m_ntupleCreated
private

Definition at line 346 of file TileTBAANtuple.h.

◆ m_ntupleID

Gaudi::Property<std::string> TileTBAANtuple::m_ntupleID {this, "NTupleID", "h1000", "Name of the ntuple ID"}
private

Definition at line 181 of file TileTBAANtuple.h.

◆ m_ntuplePtr

TTree* TileTBAANtuple::m_ntuplePtr {nullptr}
private

Definition at line 345 of file TileTBAANtuple.h.

◆ m_optRawChannelContainerKey

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

Definition at line 129 of file TileTBAANtuple.h.

◆ m_pedfitcVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_pedfitcVec
private

Definition at line 541 of file TileTBAANtuple.h.

◆ m_pedfitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_pedfitVec
private

Definition at line 537 of file TileTBAANtuple.h.

◆ m_pedFlatVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_pedFlatVec
private

Definition at line 533 of file TileTBAANtuple.h.

◆ m_pedflxfitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_pedflxfitVec
private

Definition at line 554 of file TileTBAANtuple.h.

◆ m_pedflxoptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_pedflxoptVec
private

Definition at line 558 of file TileTBAANtuple.h.

◆ m_pedOptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_pedOptVec
private

Definition at line 545 of file TileTBAANtuple.h.

◆ m_pmtOrder

Gaudi::Property<bool> TileTBAANtuple::m_pmtOrder {this, "PMTOrder", true, "Change channel ordering to pmt ordering in the ntuple"}
private

Definition at line 172 of file TileTBAANtuple.h.

◆ m_qdc

std::array<uint32_t,33> TileTBAANtuple::m_qdc
private

Definition at line 375 of file TileTBAANtuple.h.

◆ m_radius

Gaudi::Property<float> TileTBAANtuple::m_radius {this, "Radius", 2280.0, "Inner radius of calo, for CTB 2004 only"}
private

Definition at line 222 of file TileTBAANtuple.h.

◆ m_rchUnit

TileRawChannelUnit::UNIT TileTBAANtuple::m_rchUnit
private

Unit for TileRawChannels (ADC, pCb, MeV)

Definition at line 622 of file TileTBAANtuple.h.

◆ m_ROD_DMUBCIDVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_ROD_DMUBCIDVec
private

Definition at line 561 of file TileTBAANtuple.h.

◆ m_ROD_DMUDataformatErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_ROD_DMUDataformatErrVec
private

Definition at line 566 of file TileTBAANtuple.h.

◆ m_ROD_DMUDstrobeErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_ROD_DMUDstrobeErrVec
private

Definition at line 564 of file TileTBAANtuple.h.

◆ m_ROD_DMUHeadformatErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_ROD_DMUHeadformatErrVec
private

Definition at line 565 of file TileTBAANtuple.h.

◆ m_ROD_DMUMaskVec

std::vector<std::array<short, 2> > TileTBAANtuple::m_ROD_DMUMaskVec
private

Definition at line 567 of file TileTBAANtuple.h.

◆ m_ROD_DMUmemoryErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_ROD_DMUmemoryErrVec
private

Definition at line 562 of file TileTBAANtuple.h.

◆ m_ROD_DMUSstrobeErrVec

std::vector<std::array<short, MAX_DMU> > TileTBAANtuple::m_ROD_DMUSstrobeErrVec
private

Definition at line 563 of file TileTBAANtuple.h.

◆ m_ROD_GlobalCRCVec

std::vector<short> TileTBAANtuple::m_ROD_GlobalCRCVec
private

Definition at line 560 of file TileTBAANtuple.h.

◆ m_rodBCIDflxVec

std::vector<short> TileTBAANtuple::m_rodBCIDflxVec
private

Definition at line 509 of file TileTBAANtuple.h.

◆ m_rodBCIDVec

std::vector<short> TileTBAANtuple::m_rodBCIDVec
private

Definition at line 505 of file TileTBAANtuple.h.

◆ m_rodCRCVec

std::vector<std::array<int, MAX_DMU> > TileTBAANtuple::m_rodCRCVec
private

Definition at line 529 of file TileTBAANtuple.h.

◆ m_rosName

Gaudi::Property<std::vector<std::string> > TileTBAANtuple::m_rosName {this, "rosName", {"B", "A", "C", "D", "E"}, "Name of arrays in ntuple for different ROSes"}
private

Definition at line 183 of file TileTBAANtuple.h.

◆ m_run

int TileTBAANtuple::m_run
private

Definition at line 353 of file TileTBAANtuple.h.

◆ m_runNumber

int TileTBAANtuple::m_runNumber
private

Definition at line 610 of file TileTBAANtuple.h.

◆ m_s1cou

uint32_t TileTBAANtuple::m_s1cou
private

Definition at line 453 of file TileTBAANtuple.h.

◆ m_s2cou

uint32_t TileTBAANtuple::m_s2cou
private

Definition at line 454 of file TileTBAANtuple.h.

◆ m_s2extra

int TileTBAANtuple::m_s2extra
private

Definition at line 463 of file TileTBAANtuple.h.

◆ m_s3cou

uint32_t TileTBAANtuple::m_s3cou
private

Definition at line 455 of file TileTBAANtuple.h.

◆ m_s3extra

int TileTBAANtuple::m_s3extra
private

Definition at line 464 of file TileTBAANtuple.h.

◆ m_sampleflxVec

std::vector<std::unique_ptr<int []> > TileTBAANtuple::m_sampleflxVec
private

Definition at line 513 of file TileTBAANtuple.h.

◆ m_sampleVec

std::vector<std::unique_ptr<int []> > TileTBAANtuple::m_sampleVec
private

Definition at line 527 of file TileTBAANtuple.h.

◆ m_samplingFractionKey

SG::ReadCondHandleKey<TileSamplingFraction> TileTBAANtuple::m_samplingFractionKey
private
Initial value:
{this,
"TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"}

Name of TileSamplingFraction in condition store.

Definition at line 111 of file TileTBAANtuple.h.

◆ m_saveFelixData

bool TileTBAANtuple::m_saveFelixData {false}
private

Definition at line 634 of file TileTBAANtuple.h.

◆ m_sc1

int TileTBAANtuple::m_sc1
private

Definition at line 466 of file TileTBAANtuple.h.

◆ m_sc2

int TileTBAANtuple::m_sc2
private

Definition at line 467 of file TileTBAANtuple.h.

◆ m_scaler

std::array<int, 16> TileTBAANtuple::m_scaler
private

Definition at line 472 of file TileTBAANtuple.h.

◆ m_sizeflxVec

std::vector<short> TileTBAANtuple::m_sizeflxVec
private

Definition at line 510 of file TileTBAANtuple.h.

◆ m_sizeVec

std::vector<short> TileTBAANtuple::m_sizeVec
private

Definition at line 506 of file TileTBAANtuple.h.

◆ m_slinkCRCVec

std::vector<std::array<int, 2> > TileTBAANtuple::m_slinkCRCVec
private

Definition at line 525 of file TileTBAANtuple.h.

◆ m_streamName

Gaudi::Property<std::string> TileTBAANtuple::m_streamName {this, "StreamName", "AANT", "Name of the output stream"}
private

Definition at line 180 of file TileTBAANtuple.h.

◆ m_TBperiod

Gaudi::Property<int> TileTBAANtuple::m_TBperiod {this, "TBperiod", 2016, "Tuned for 2016 testbeam by default"}
private

Definition at line 177 of file TileTBAANtuple.h.

◆ m_tDspVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_tDspVec
private

Definition at line 548 of file TileTBAANtuple.h.

◆ m_tfitcVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_tfitcVec
private

Definition at line 540 of file TileTBAANtuple.h.

◆ m_tfitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_tfitVec
private

Definition at line 536 of file TileTBAANtuple.h.

◆ m_tflxfitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_tflxfitVec
private

Definition at line 552 of file TileTBAANtuple.h.

◆ m_tflxoptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_tflxoptVec
private

Definition at line 556 of file TileTBAANtuple.h.

◆ m_theta

float TileTBAANtuple::m_theta
private

Definition at line 612 of file TileTBAANtuple.h.

◆ m_thistSvc

ServiceHandle<ITHistSvc> TileTBAANtuple::m_thistSvc
private

Definition at line 342 of file TileTBAANtuple.h.

◆ m_thitCnt

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_thitCnt
private

Definition at line 618 of file TileTBAANtuple.h.

◆ m_thitVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_thitVec
private

Definition at line 616 of file TileTBAANtuple.h.

◆ m_tileHWID

const TileHWID* TileTBAANtuple::m_tileHWID {nullptr}
private

Definition at line 627 of file TileTBAANtuple.h.

◆ m_tileID

const TileID* TileTBAANtuple::m_tileID {nullptr}
private

Definition at line 626 of file TileTBAANtuple.h.

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileTBAANtuple::m_tileToolEmscale
private
Initial value:
{this,
"TileCondToolEmscale", "TileCondToolEmscale", "Tile EMS conditions tool"}

Definition at line 156 of file TileTBAANtuple.h.

◆ m_timeAdd

std::array<float, 16> TileTBAANtuple::m_timeAdd
private

Definition at line 447 of file TileTBAANtuple.h.

◆ m_timeVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_timeVec
private

Definition at line 532 of file TileTBAANtuple.h.

◆ m_tjitter

int TileTBAANtuple::m_tjitter
private

Definition at line 474 of file TileTBAANtuple.h.

◆ m_tof

std::array<int, 16> TileTBAANtuple::m_tof
private

Definition at line 469 of file TileTBAANtuple.h.

◆ m_tOptVec

std::vector<std::array<float, MAX_CHAN> > TileTBAANtuple::m_tOptVec
private

Definition at line 544 of file TileTBAANtuple.h.

◆ m_treeSize

Gaudi::Property<Long64_t> TileTBAANtuple::m_treeSize {this, "TreeSize", 16000000000LL, "Size of tree"}
private

Definition at line 179 of file TileTBAANtuple.h.

◆ m_trigType

int TileTBAANtuple::m_trigType
private

Definition at line 355 of file TileTBAANtuple.h.

◆ m_tscTOF

int TileTBAANtuple::m_tscTOF
private

Definition at line 475 of file TileTBAANtuple.h.

◆ m_unpackAdder

Gaudi::Property<bool> TileTBAANtuple::m_unpackAdder {this, "UnpackAdder", false, "Unpack adder"}
private

Definition at line 169 of file TileTBAANtuple.h.

◆ m_useDspUnits

Gaudi::Property<bool> TileTBAANtuple::m_useDspUnits {this, "UseDspUnits", false, "Use DSP untis"}
private

Definition at line 166 of file TileTBAANtuple.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_xCha0

float TileTBAANtuple::m_xCha0
private

Definition at line 483 of file TileTBAANtuple.h.

◆ m_xCha1

float TileTBAANtuple::m_xCha1
private

Definition at line 486 of file TileTBAANtuple.h.

◆ m_xCha1_0

float TileTBAANtuple::m_xCha1_0
private

Definition at line 490 of file TileTBAANtuple.h.

◆ m_xCha2

float TileTBAANtuple::m_xCha2
private

Definition at line 488 of file TileTBAANtuple.h.

◆ m_xCha2_0

float TileTBAANtuple::m_xCha2_0
private

Definition at line 492 of file TileTBAANtuple.h.

◆ m_xChN1

float TileTBAANtuple::m_xChN1
private

Definition at line 481 of file TileTBAANtuple.h.

◆ m_xChN2

float TileTBAANtuple::m_xChN2
private

Definition at line 479 of file TileTBAANtuple.h.

◆ m_xImp

float TileTBAANtuple::m_xImp
private

Definition at line 494 of file TileTBAANtuple.h.

◆ m_xImp_0

float TileTBAANtuple::m_xImp_0
private

Definition at line 497 of file TileTBAANtuple.h.

◆ m_xImp_90

float TileTBAANtuple::m_xImp_90
private

Definition at line 499 of file TileTBAANtuple.h.

◆ m_xImp_min90

float TileTBAANtuple::m_xImp_min90
private

Definition at line 501 of file TileTBAANtuple.h.

◆ m_yCha0

float TileTBAANtuple::m_yCha0
private

Definition at line 484 of file TileTBAANtuple.h.

◆ m_yCha1

float TileTBAANtuple::m_yCha1
private

Definition at line 487 of file TileTBAANtuple.h.

◆ m_yCha1_0

float TileTBAANtuple::m_yCha1_0
private

Definition at line 491 of file TileTBAANtuple.h.

◆ m_yCha2

float TileTBAANtuple::m_yCha2
private

Definition at line 489 of file TileTBAANtuple.h.

◆ m_yCha2_0

float TileTBAANtuple::m_yCha2_0
private

Definition at line 493 of file TileTBAANtuple.h.

◆ m_yChN1

float TileTBAANtuple::m_yChN1
private

Definition at line 482 of file TileTBAANtuple.h.

◆ m_yChN2

float TileTBAANtuple::m_yChN2
private

Definition at line 480 of file TileTBAANtuple.h.

◆ m_yImp

float TileTBAANtuple::m_yImp
private

Definition at line 495 of file TileTBAANtuple.h.

◆ m_yImp_0

float TileTBAANtuple::m_yImp_0
private

Definition at line 498 of file TileTBAANtuple.h.

◆ m_yImp_90

float TileTBAANtuple::m_yImp_90
private

Definition at line 500 of file TileTBAANtuple.h.

◆ m_yImp_min90

float TileTBAANtuple::m_yImp_min90
private

Definition at line 502 of file TileTBAANtuple.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileTBAANtuple::m_sampleflxVec
std::vector< std::unique_ptr< int[]> > m_sampleflxVec
Definition: TileTBAANtuple.h:513
TileTBAANtuple::m_beamBC1Z_0
Gaudi::Property< float > m_beamBC1Z_0
Definition: TileTBAANtuple.h:209
TileTBAANtuple::m_feCRCVec
std::vector< std::array< int, MAX_DMU > > m_feCRCVec
Definition: TileTBAANtuple.h:528
TileTBAANtuple::m_xCha1
float m_xCha1
Definition: TileTBAANtuple.h:486
TileTBAANtuple::m_pedflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_pedflxoptVec
Definition: TileTBAANtuple.h:558
TileTBAANtuple::m_coincTrig4
std::array< unsigned int, 96 > m_coincTrig4
Definition: TileTBAANtuple.h:588
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
COIN_TRIG7_FRAG
#define COIN_TRIG7_FRAG
Definition: TileTBFrag.h:38
TileSamplingFraction::getSamplingFraction
float getSamplingFraction(unsigned int drawerIdx, unsigned int channel) const
Return Tile Calorimeter sampling fraction.
Definition: TileSamplingFraction.h:53
TileTBAANtuple::m_coincFlag7
int m_coincFlag7
Definition: TileTBAANtuple.h:600
TileTBAANtuple::m_coincTrig3
std::array< unsigned int, 96 > m_coincTrig3
Definition: TileTBAANtuple.h:587
TileTBAANtuple::COINCBOARD_clearBranch
void COINCBOARD_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree COINCBOARD va...
Definition: TileTBAANtuple.cxx:3219
TileTBAANtuple::m_beamIdList
bool m_beamIdList[32]
Definition: TileTBAANtuple.h:607
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
TileTBAANtuple::m_beamBC0Z
Gaudi::Property< float > m_beamBC0Z
Definition: TileTBAANtuple.h:202
TileTBAANtuple::m_yChN2
float m_yChN2
Definition: TileTBAANtuple.h:480
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
TileTBAANtuple::m_ecal
std::array< float, 8 > m_ecal
Definition: TileTBAANtuple.h:372
TileLaserObject::getTDC
int getTDC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:209
TileTBAANtuple::m_treeSize
Gaudi::Property< Long64_t > m_treeSize
Definition: TileTBAANtuple.h:179
TileTBAANtuple::m_mdChargeTimeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeTimeflxVec
Definition: TileTBAANtuple.h:577
TileTBAANtuple::m_s1cou
uint32_t m_s1cou
Definition: TileTBAANtuple.h:453
TileTBAANtuple::m_calibMode
Gaudi::Property< bool > m_calibMode
Definition: TileTBAANtuple.h:168
TileTBAANtuple::m_beamBC1Y2
Gaudi::Property< float > m_beamBC1Y2
Definition: TileTBAANtuple.h:207
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
COMMON_TDC2_FRAG
#define COMMON_TDC2_FRAG
Definition: TileTBFrag.h:47
TileTBAANtuple::m_las_D4_AlphaPed
double m_las_D4_AlphaPed
Definition: TileTBAANtuple.h:412
TileTBAANtuple::m_coincFlag8
int m_coincFlag8
Definition: TileTBAANtuple.h:601
COMMON_PTN_FRAG
#define COMMON_PTN_FRAG
Definition: TileTBFrag.h:48
TileTBAANtuple::m_BarEne
std::array< float, 3 > m_BarEne
Definition: TileTBAANtuple.h:581
TileTBAANtuple::m_frBCID
std::vector< int > m_frBCID
Definition: TileTBAANtuple.h:363
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
TileTBAANtuple::m_chi2FlatVec
std::vector< std::array< float, MAX_CHAN > > m_chi2FlatVec
Definition: TileTBAANtuple.h:534
TileTBAANtuple::m_cellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Definition: TileTBAANtuple.h:153
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:186
header
Definition: hcg.cxx:526
TileTBAANtuple::m_DMUSstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUSstrobeErrVec
Definition: TileTBAANtuple.h:521
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TileTBAANtuple::m_xChN2
float m_xChN2
Definition: TileTBAANtuple.h:479
TileTBAANtuple::m_las_D4_ADC
int m_las_D4_ADC
Definition: TileTBAANtuple.h:387
TileTBAANtuple::m_las_D1_ADC
int m_las_D1_ADC
Definition: TileTBAANtuple.h:384
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
ADD_FADC_FRAG
#define ADD_FADC_FRAG
Definition: TileTBFrag.h:29
TileTBAANtuple::NOT_SETUP
@ NOT_SETUP
Definition: TileTBAANtuple.h:105
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileTBAANtuple::m_yChN1
float m_yChN1
Definition: TileTBAANtuple.h:482
TileTBAANtuple::m_gainflxVec
std::vector< std::array< int, MAX_CHAN > > m_gainflxVec
Definition: TileTBAANtuple.h:512
TileTBAANtuple::m_slinkCRCVec
std::vector< std::array< int, 2 > > m_slinkCRCVec
Definition: TileTBAANtuple.h:525
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
TileTBAANtuple::m_muBack
std::array< float, 14 > m_muBack
Definition: TileTBAANtuple.h:368
TileTBAANtuple::m_las_ReqAmp
double m_las_ReqAmp
Definition: TileTBAANtuple.h:381
TileTBAANtuple::m_coincFlag4
int m_coincFlag4
Definition: TileTBAANtuple.h:597
TileTBAANtuple::m_las_PMT1_Ped
double m_las_PMT1_Ped
Definition: TileTBAANtuple.h:425
TileTBAANtuple::checkIsPropertySetup
void checkIsPropertySetup(float property, const std::string &name)
Definition: TileTBAANtuple.h:322
TileTBAANtuple::m_tof
std::array< int, 16 > m_tof
Definition: TileTBAANtuple.h:469
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
TileTBAANtuple::m_chi2cVec
std::vector< std::array< float, MAX_CHAN > > m_chi2cVec
Definition: TileTBAANtuple.h:542
TileTBAANtuple::m_mdRunTypeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunTypeflxVec
Definition: TileTBAANtuple.h:572
TileTBAANtuple::m_DMUparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUparityErrVec
Definition: TileTBAANtuple.h:518
TileTBAANtuple::m_tscTOF
int m_tscTOF
Definition: TileTBAANtuple.h:475
TileTBAANtuple::m_beamBC2Y2
Gaudi::Property< float > m_beamBC2Y2
Definition: TileTBAANtuple.h:216
TileTBAANtuple::FELIX_addBranch
void FELIX_addBranch(void)
Definition: TileTBAANtuple.cxx:3569
TileTBAANtuple::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: TileTBAANtuple.h:156
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileTBAANtuple::m_sizeflxVec
std::vector< short > m_sizeflxVec
Definition: TileTBAANtuple.h:510
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
TileTBAANtuple::m_flatRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flatRawChannelContainerKey
Definition: TileTBAANtuple.h:123
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
TileTBAANtuple::m_las_PMT2_Ped
double m_las_PMT2_Ped
Definition: TileTBAANtuple.h:426
TileTBAANtuple::m_drawerFlxMap
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerFlxMap
Definition: TileTBAANtuple.h:604
TileTBAANtuple::m_las_Filt
int m_las_Filt
Definition: TileTBAANtuple.h:380
index
Definition: index.py:1
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileTBAANtuple::m_drawerType
Gaudi::Property< std::vector< int > > m_drawerType
Definition: TileTBAANtuple.h:185
TileTBAANtuple::m_rodBCIDVec
std::vector< short > m_rodBCIDVec
Definition: TileTBAANtuple.h:505
TileTBAANtuple::storeHitVector
StatusCode storeHitVector(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:1915
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
TileTBAANtuple::m_efitVec
std::vector< std::array< float, MAX_CHAN > > m_efitVec
Definition: TileTBAANtuple.h:535
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
TileLaserObject::getPumpDiodeTemp
double getPumpDiodeTemp() const
Definition: TileLaserObject.h:234
TileTBAANtuple::m_laserObjectKey
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
Definition: TileTBAANtuple.h:144
TileTBAANtuple::m_hitContainerKey
SG::ReadHandleKey< TileHitContainer > m_hitContainerKey
Definition: TileTBAANtuple.h:147
TileTBAANtuple::m_evBCID
std::vector< int > m_evBCID
Definition: TileTBAANtuple.h:361
TileTBAANtuple::m_DMUmemoryErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUmemoryErrVec
Definition: TileTBAANtuple.h:519
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
TileTBAANtuple::m_coincTrig7
std::array< unsigned int, 96 > m_coincTrig7
Definition: TileTBAANtuple.h:591
TileTBAANtuple::m_mdBcidflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdBcidflxVec
Definition: TileTBAANtuple.h:570
TileTBAANtuple::m_chi2OptVec
std::vector< std::array< float, MAX_CHAN > > m_chi2OptVec
Definition: TileTBAANtuple.h:546
tree
TChain * tree
Definition: tile_monitor.h:30
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileTBAANtuple::m_pedFlatVec
std::vector< std::array< float, MAX_CHAN > > m_pedFlatVec
Definition: TileTBAANtuple.h:533
TileTBAANtuple::CISPAR_addBranch
void CISPAR_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variabl...
Definition: TileTBAANtuple.cxx:2903
AtlasHitsVector
Definition: AtlasHitsVector.h:33
TileTBAANtuple::m_calibrateEnergyThisEvent
bool m_calibrateEnergyThisEvent
Definition: TileTBAANtuple.h:620
TileTBAANtuple::m_btdcNhit
int m_btdcNhit[16]
Definition: TileTBAANtuple.h:476
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TileTBAANtuple::QDC_addBranch
void QDC_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add QDC variables to th...
Definition: TileTBAANtuple.cxx:2661
TileLaserObject::getAlpha
double getAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:138
TileTBAANtuple::m_ntuplePtr
TTree * m_ntuplePtr
Definition: TileTBAANtuple.h:345
TileTBAANtuple::m_ROD_DMUBCIDVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUBCIDVec
Definition: TileTBAANtuple.h:561
TileTBAANtuple::m_muBackHit
float m_muBackHit
Definition: TileTBAANtuple.h:366
TileTBAANtuple::m_coincFlag3
int m_coincFlag3
Definition: TileTBAANtuple.h:596
TileTBAANtuple::m_samplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_samplingFractionKey
Name of TileSamplingFraction in condition store.
Definition: TileTBAANtuple.h:111
WRONG_SAMPLE
#define WRONG_SAMPLE(frag, chan, size)
Definition: TileTBAANtuple.cxx:47
TileTBAANtuple::m_xImp_0
float m_xImp_0
Definition: TileTBAANtuple.h:497
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TileTBAANtuple::m_mdCapacitorflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdCapacitorflxVec
Definition: TileTBAANtuple.h:578
TileTBAANtuple::m_pedOptVec
std::vector< std::array< float, MAX_CHAN > > m_pedOptVec
Definition: TileTBAANtuple.h:545
PlotCalibFromCool.nchan
nchan
Definition: PlotCalibFromCool.py:564
TileLaserObject::getDiodeCurrOrd
double getDiodeCurrOrd() const
Definition: TileLaserObject.h:219
TileTBAANtuple::m_eta
float m_eta
Definition: TileTBAANtuple.h:611
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileTBAANtuple::m_ntupleID
Gaudi::Property< std::string > m_ntupleID
Definition: TileTBAANtuple.h:181
TileTBAANtuple::m_rodBCIDflxVec
std::vector< short > m_rodBCIDflxVec
Definition: TileTBAANtuple.h:509
TileHWID::frag
int frag(const HWIdentifier &id) const
extract frag field from HW identifier
Definition: TileHWID.h:181
TileTBAANtuple::m_beamBC0X2
Gaudi::Property< float > m_beamBC0X2
Definition: TileTBAANtuple.h:199
TileTBAANtuple::storeDigitsFlx
StatusCode storeDigitsFlx(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey)
Definition: TileTBAANtuple.cxx:1742
DIGI_PAR_FRAG
#define DIGI_PAR_FRAG
Definition: TileTBFrag.h:41
COIN_TRIG8_FRAG
#define COIN_TRIG8_FRAG
Definition: TileTBFrag.h:39
ADDR_ADC_FRAG
#define ADDR_ADC_FRAG
Definition: TileTBFrag.h:26
TileTBAANtuple::m_drawerMap
std::map< unsigned int, unsigned int, std::less< unsigned int > > m_drawerMap
Definition: TileTBAANtuple.h:603
COMMON_TOF_FRAG
#define COMMON_TOF_FRAG
Definition: TileTBFrag.h:45
Tile_Base_ID::HIGHGAIN
@ HIGHGAIN
Definition: Tile_Base_ID.h:57
TileTBAANtuple::m_muBackSum
float m_muBackSum
Definition: TileTBAANtuple.h:367
TileTBAANtuple::m_finalUnit
Gaudi::Property< int > m_finalUnit
Definition: TileTBAANtuple.h:167
TileTBAANtuple::m_las_D1_AlphaPed
double m_las_D1_AlphaPed
Definition: TileTBAANtuple.h:409
TileTBAANtuple::m_mdModuleflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdModuleflxVec
Definition: TileTBAANtuple.h:571
TileTBAANtuple::m_tfitcVec
std::vector< std::array< float, MAX_CHAN > > m_tfitcVec
Definition: TileTBAANtuple.h:540
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
TileTBAANtuple::m_yImp_90
float m_yImp_90
Definition: TileTBAANtuple.h:500
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
COMMON_ADC1_FRAG
#define COMMON_ADC1_FRAG
Definition: TileTBFrag.h:43
LASE_ADC_FRAG
#define LASE_ADC_FRAG
Definition: TileTBFrag.h:28
TileTBAANtuple::m_evtVec
std::vector< int > m_evtVec
Definition: TileTBAANtuple.h:504
TileTBAANtuple::HIT_addBranch
void HIT_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree HIT variables ...
Definition: TileTBAANtuple.cxx:3758
TileTBAANtuple::m_coincTrig6
std::array< unsigned int, 96 > m_coincTrig6
Definition: TileTBAANtuple.h:590
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
TileTBAANtuple::m_las_Temperature
double m_las_Temperature
Definition: TileTBAANtuple.h:431
TileTBAANtuple::m_s2extra
int m_s2extra
Definition: TileTBAANtuple.h:463
TileTBAANtuple::LASER_clearBranch
void LASER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variabl...
Definition: TileTBAANtuple.cxx:2816
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileTBAANtuple::m_las_PMT1_ADC
int m_las_PMT1_ADC
Definition: TileTBAANtuple.h:419
TileTBAANtuple::m_yImp_0
float m_yImp_0
Definition: TileTBAANtuple.h:498
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
TileTBAANtuple::m_eflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_eflxfitVec
Definition: TileTBAANtuple.h:551
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
TileTBAANtuple::m_xCha0
float m_xCha0
Definition: TileTBAANtuple.h:483
TileTBAANtuple::ntuple_clear
StatusCode ntuple_clear()
Definition: TileTBAANtuple.cxx:2076
TileDigitsContainer
Definition: TileDigitsContainer.h:13
TileHitCollection
Definition: TileHitCollection.h:12
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
TileTBAANtuple::m_las_D3_AlphaPed_RMS
double m_las_D3_AlphaPed_RMS
Definition: TileTBAANtuple.h:416
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
TileTBAANtuple::m_beamBN1X2
Gaudi::Property< float > m_beamBN1X2
Definition: TileTBAANtuple.h:194
HWIdentifier
Definition: HWIdentifier.h:13
TileTBAANtuple::MAX_CHAN
@ MAX_CHAN
Definition: TileTBAANtuple.h:106
TileTBAANtuple::m_DMUheaderVec
std::vector< std::array< uint32_t, MAX_DMU > > m_DMUheaderVec
Definition: TileTBAANtuple.h:516
TileTBAANtuple::m_commonPU
int m_commonPU
Definition: TileTBAANtuple.h:441
TileTBAANtuple::m_muHalo
uint32_t m_muHalo
Definition: TileTBAANtuple.h:460
TileTBAANtuple::m_bsInput
Gaudi::Property< bool > m_bsInput
Definition: TileTBAANtuple.h:171
TileTBAANtuple::ENETOTAL_clearBranch
void ENETOTAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ENETOTAL vari...
Definition: TileTBAANtuple.cxx:3159
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
TileTBAANtuple::m_yCha2_0
float m_yCha2_0
Definition: TileTBAANtuple.h:493
TileTBAANtuple::ntuple_initialize
StatusCode ntuple_initialize(const EventContext &ctx)
Alg standard interface function LF TODO: We could have a problem with the new feature introduced by S...
Definition: TileTBAANtuple.cxx:241
TileTBAANtuple::m_las_MeasAmp
double m_las_MeasAmp
Definition: TileTBAANtuple.h:382
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileTBAANtuple::m_pedflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_pedflxfitVec
Definition: TileTBAANtuple.h:554
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TileTBAANtuple::m_xCha2_0
float m_xCha2_0
Definition: TileTBAANtuple.h:492
TileTBAANtuple::m_cher1
uint32_t m_cher1
Definition: TileTBAANtuple.h:456
TileTBAANtuple::m_useDspUnits
Gaudi::Property< bool > m_useDspUnits
Definition: TileTBAANtuple.h:166
BEAM_ADC_FRAG
#define BEAM_ADC_FRAG
Definition: TileTBFrag.h:24
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TileTBAANtuple::m_beamBN2X2
Gaudi::Property< float > m_beamBN2X2
Definition: TileTBAANtuple.h:189
TileTBAANtuple::m_beamBC2Z
Gaudi::Property< float > m_beamBC2Z
Definition: TileTBAANtuple.h:217
TileTBAANtuple::m_mdPedHiflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedHiflxVec
Definition: TileTBAANtuple.h:574
TileTBAANtuple::storeDigits
StatusCode storeDigits(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey, const TileDQstatus *dqStatus=nullptr)
/ Fill Ntuple with info from TileDigits / Return true if the collection is empty, / which means that ...
Definition: TileTBAANtuple.cxx:1451
TileTBAANtuple::m_saveFelixData
bool m_saveFelixData
Definition: TileTBAANtuple.h:634
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TileTBAANtuple::clear_samples
void clear_samples(std::vector< std::unique_ptr< int[]>> &vec, const std::vector< int > &nsamples, int nchan=MAX_CHAN)
Definition: TileTBAANtuple.cxx:3871
TileLaserObject::getPMADC
int getPMADC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:195
TileTBAANtuple::m_tflxfitVec
std::vector< std::array< float, MAX_CHAN > > m_tflxfitVec
Definition: TileTBAANtuple.h:552
COMMON_TDC1_FRAG
#define COMMON_TDC1_FRAG
Definition: TileTBFrag.h:46
TileTBAANtuple::ENETOTAL_addBranch
void ENETOTAL_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree ENETOTAL varia...
Definition: TileTBAANtuple.cxx:3143
TileLaserObject::getFiltNumber
int getFiltNumber() const
Definition: TileLaserObject.h:229
TileTBAANtuple::m_lasFlag
int m_lasFlag
Definition: TileTBAANtuple.h:433
TileTBAANtuple::clear_init_zero
void clear_init_zero(std::vector< std::array< T, N >> &vec)
Definition: TileTBAANtuple.cxx:3865
TileTBAANtuple::ECAL_clearBranch
void ECAL_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ECAL variable...
Definition: TileTBAANtuple.cxx:2712
TileTBAANtuple::m_eneVec
std::vector< std::array< float, MAX_CHAN > > m_eneVec
Definition: TileTBAANtuple.h:531
TileLaserObject::getSigmaPedAlpha
double getSigmaPedAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:180
TileTBAANtuple::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: TileTBAANtuple.h:342
TileTBAANtuple::m_beamBN1Y2
Gaudi::Property< float > m_beamBN1Y2
Definition: TileTBAANtuple.h:196
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
TileTBAANtuple::m_dmuMaskVec
std::vector< std::array< int, 2 > > m_dmuMaskVec
Definition: TileTBAANtuple.h:524
TileTBAANtuple::m_yImp_min90
float m_yImp_min90
Definition: TileTBAANtuple.h:502
TileTBAANtuple::m_s3extra
int m_s3extra
Definition: TileTBAANtuple.h:464
TileTBAANtuple::m_beamBN1X1
Gaudi::Property< float > m_beamBN1X1
Definition: TileTBAANtuple.h:193
TileTBAANtuple::m_dspRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
Definition: TileTBAANtuple.h:132
TileTBAANtuple::m_cher3
uint32_t m_cher3
Definition: TileTBAANtuple.h:458
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileTBAANtuple::FELIX_clearBranch
void FELIX_clearBranch(void)
Definition: TileTBAANtuple.cxx:3721
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileTBAANtuple::MAX_DMU
@ MAX_DMU
Definition: TileTBAANtuple.h:106
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileTBAANtuple::setupBeamChambersBeforeTB2015
void setupBeamChambersBeforeTB2015(void)
Definition: TileTBAANtuple.cxx:3878
TileTBAANtuple::m_beamBN2Y1
Gaudi::Property< float > m_beamBN2Y1
Definition: TileTBAANtuple.h:190
TileTBAANtuple::m_yCha1_0
float m_yCha1_0
Definition: TileTBAANtuple.h:491
FRAG_FOUND
#define FRAG_FOUND(frag, chan, size)
Definition: TileTBAANtuple.cxx:58
TileTBAANtuple::m_las3
float m_las3
Definition: TileTBAANtuple.h:437
TileTBAANtuple::m_tjitter
int m_tjitter
Definition: TileTBAANtuple.h:474
TileTBAANtuple::m_ExtEne
std::array< float, 3 > m_ExtEne
Definition: TileTBAANtuple.h:582
TileTBAANtuple::m_evTime
int m_evTime
Definition: TileTBAANtuple.h:352
TileTBAANtuple::m_calibrateEnergy
Gaudi::Property< bool > m_calibrateEnergy
Definition: TileTBAANtuple.h:165
FortranAlgorithmOptions.fileName
fileName
Definition: FortranAlgorithmOptions.py:13
AthCommonDataStore
Definition: AthCommonDataStore.h:52
TileTBAANtuple::m_beamBC2Z_0
Gaudi::Property< float > m_beamBC2Z_0
Definition: TileTBAANtuple.h:218
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
TileTBAANtuple::drawerMap_iterator
std::map< unsigned int, unsigned int, std::less< unsigned int > >::iterator drawerMap_iterator
Definition: TileTBAANtuple.h:605
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileTBAANtuple::setupBeamChambersTB2015
void setupBeamChambersTB2015(void)
Definition: TileTBAANtuple.cxx:3899
TileTBAANtuple::m_btdc2
std::array< int, 16 > m_btdc2
Definition: TileTBAANtuple.h:471
Trk::index1
@ index1
Definition: BoundarySurfaceFace.h:48
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
TileTBAANtuple::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileTBAANtuple.h:627
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
TileTBAANtuple::m_beamBC1X2
Gaudi::Property< float > m_beamBC1X2
Definition: TileTBAANtuple.h:205
TileTBAANtuple::m_las_D1_Ped
double m_las_D1_Ped
Definition: TileTBAANtuple.h:389
TileTBAANtuple::m_tDspVec
std::vector< std::array< float, MAX_CHAN > > m_tDspVec
Definition: TileTBAANtuple.h:548
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
TileTBAANtuple::m_runNumber
int m_runNumber
Definition: TileTBAANtuple.h:610
TileTBAANtuple::setupPropertyDefaultValue
void setupPropertyDefaultValue(float property, float defaultValue, const std::string &name)
Definition: TileTBAANtuple.h:328
COIN_TRIG6_FRAG
#define COIN_TRIG6_FRAG
Definition: TileTBFrag.h:37
TileTBAANtuple::m_nSamplesFlx
Gaudi::Property< int > m_nSamplesFlx
Definition: TileTBAANtuple.h:174
TileTBAANtuple::m_theta
float m_theta
Definition: TileTBAANtuple.h:612
lumiFormat.i
int i
Definition: lumiFormat.py:92
TileTBAANtuple::m_chi2Vec
std::vector< std::array< float, MAX_CHAN > > m_chi2Vec
Definition: TileTBAANtuple.h:538
COIN_TRIG1_FRAG
#define COIN_TRIG1_FRAG
Definition: TileTBFrag.h:32
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
TileTBAANtuple::m_evType
std::vector< int > m_evType
Definition: TileTBAANtuple.h:362
TileTBAANtuple::storeHitContainer
StatusCode storeHitContainer(const EventContext &ctx)
/ Fill Ntuple with MC truth info from simulation / Namely, hit energies corrected by photoelectron st...
Definition: TileTBAANtuple.cxx:1960
TileTBAANtuple::m_flxOptRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxOptRawChannelContainerKey
Definition: TileTBAANtuple.h:141
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileTBAANtuple::m_tileID
const TileID * m_tileID
Definition: TileTBAANtuple.h:626
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
TileTBAANtuple::m_evtflxVec
std::vector< int > m_evtflxVec
Definition: TileTBAANtuple.h:508
TileTBAANtuple::m_sampleVec
std::vector< std::unique_ptr< int[]> > m_sampleVec
Definition: TileTBAANtuple.h:527
TileTBAANtuple::m_las0
float m_las0
Definition: TileTBAANtuple.h:434
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileTBAANtuple::m_beamBN1Y1
Gaudi::Property< float > m_beamBN1Y1
Definition: TileTBAANtuple.h:195
TileRawDataContainer::get_bsflags
uint32_t get_bsflags() const
Definition: TileRawDataContainer.h:64
CaloCell_ID_FCS::TileGap2
@ TileGap2
Definition: FastCaloSim_CaloCell_ID.h:35
TileTBAANtuple::BEAM_addBranch
void BEAM_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree BEAM variables...
Definition: TileTBAANtuple.cxx:2929
WRONG_CHANNEL
#define WRONG_CHANNEL(frag, chan)
Definition: TileTBAANtuple.cxx:53
TileRawChannelUnit::OnlineOffset
@ OnlineOffset
Definition: TileRawChannelUnit.h:25
TileTBAANtuple::m_btdcNchMultiHit
int m_btdcNchMultiHit[2]
Definition: TileTBAANtuple.h:477
TileTBAANtuple::digiChannel2PMT
int digiChannel2PMT(int fragType, int chan)
Definition: TileTBAANtuple.h:296
TileTBAANtuple::m_muTag
uint32_t m_muTag
Definition: TileTBAANtuple.h:459
TileTBAANtuple::m_btdc
std::vector< std::vector< int > > * m_btdc
Definition: TileTBAANtuple.h:473
TileTBAANtuple::m_eventsPerFile
Gaudi::Property< int > m_eventsPerFile
Definition: TileTBAANtuple.h:178
TileTBAANtuple::m_ROD_DMUMaskVec
std::vector< std::array< short, 2 > > m_ROD_DMUMaskVec
Definition: TileTBAANtuple.h:567
TileTBAANtuple::m_mdPedLoflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdPedLoflxVec
Definition: TileTBAANtuple.h:573
TileTBAANtuple::initListFlx
StatusCode initListFlx(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:2412
TileTBAANtuple::m_beamBN2Y2
Gaudi::Property< float > m_beamBN2Y2
Definition: TileTBAANtuple.h:191
TileTBAANtuple::HIT_clearBranch
void HIT_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree HIT variable...
Definition: TileTBAANtuple.cxx:3844
TileTBAANtuple::setupBeamChambersTB2016_2020
void setupBeamChambersTB2016_2020(void)
Definition: TileTBAANtuple.cxx:3919
TileTBAANtuple::CheckDMUParity
short CheckDMUParity(uint32_t header)
Parity of the DMU header should be odd.
Definition: TileTBAANtuple.h:311
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
TileTBAANtuple::m_nDrawersFlx
Gaudi::Property< unsigned int > m_nDrawersFlx
Definition: TileTBAANtuple.h:176
TileTBAANtuple::m_drawerList
Gaudi::Property< std::vector< std::string > > m_drawerList
Definition: TileTBAANtuple.h:184
TileTBAANtuple::m_digitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
Definition: TileTBAANtuple.h:114
TileRawChannel
Definition: TileRawChannel.h:35
TileTBAANtuple::m_yImp
float m_yImp
Definition: TileTBAANtuple.h:495
TileTBAANtuple::m_beamElemContainerKey
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
Definition: TileTBAANtuple.h:120
TileTBAANtuple::m_streamName
Gaudi::Property< std::string > m_streamName
Definition: TileTBAANtuple.h:180
TileTBAANtuple::MAX_MINIDRAWER
@ MAX_MINIDRAWER
Definition: TileTBAANtuple.h:106
TileTBAANtuple::m_beamBC2Z_min90
Gaudi::Property< float > m_beamBC2Z_min90
Definition: TileTBAANtuple.h:220
TileTBAANtuple::m_ehitVec
std::vector< std::array< float, MAX_CHAN > > m_ehitVec
Definition: TileTBAANtuple.h:615
TileTBAANtuple::m_l1ID
std::vector< int > m_l1ID
Definition: TileTBAANtuple.h:359
TileTBAANtuple::m_coincTrig2
std::array< unsigned int, 96 > m_coincTrig2
Definition: TileTBAANtuple.h:586
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
TileTBAANtuple::m_beamBC1Z
Gaudi::Property< float > m_beamBC1Z
Definition: TileTBAANtuple.h:208
BEAM_TDC_FRAG
#define BEAM_TDC_FRAG
Definition: TileTBFrag.h:23
TileTBAANtuple::storeCells
StatusCode storeCells(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:2236
TileTBAANtuple::m_beamBC2X1
Gaudi::Property< float > m_beamBC2X1
Definition: TileTBAANtuple.h:213
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
TileTBAANtuple::m_s3cou
uint32_t m_s3cou
Definition: TileTBAANtuple.h:455
TileTBAANtuple::m_cabling
const TileCablingService * m_cabling
Definition: TileTBAANtuple.h:628
TrigInDetValidation_Base.malloc
malloc
Definition: TrigInDetValidation_Base.py:131
TileTBAANtuple::m_completeNtuple
Gaudi::Property< bool > m_completeNtuple
Definition: TileTBAANtuple.h:170
TileTBAANtuple::initNTuple
StatusCode initNTuple(void)
Definition: TileTBAANtuple.cxx:2126
TileTBAANtuple::m_beamBC0Y1
Gaudi::Property< float > m_beamBC0Y1
Definition: TileTBAANtuple.h:200
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
TileTBAANtuple::m_nSamplesInDrawerMap
std::map< int, int > m_nSamplesInDrawerMap
Definition: TileTBAANtuple.h:630
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
TileTBAANtuple::m_sizeVec
std::vector< short > m_sizeVec
Definition: TileTBAANtuple.h:506
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TileTBAANtuple::m_beamBN2X1
Gaudi::Property< float > m_beamBN2X1
Definition: TileTBAANtuple.h:188
TileTBAANtuple::m_coincFlag6
int m_coincFlag6
Definition: TileTBAANtuple.h:599
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
TileTBAANtuple::MUON_clearBranch
void MUON_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree MUON variable...
Definition: TileTBAANtuple.cxx:2700
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TileTBAANtuple::m_evtNr
int m_evtNr
Definition: TileTBAANtuple.h:349
TileTBAANtuple::m_coincTrig5
std::array< unsigned int, 96 > m_coincTrig5
Definition: TileTBAANtuple.h:589
TileTBAANtuple::m_digitsContainerFlxKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerFlxKey
Definition: TileTBAANtuple.h:117
TileTBAANtuple::m_nSamplesInDrawer
std::vector< int > m_nSamplesInDrawer
Definition: TileTBAANtuple.h:632
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileTBAANtuple::m_DMUformatErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUformatErrVec
Definition: TileTBAANtuple.h:517
TileTBAANtuple::m_nDrawers
Gaudi::Property< unsigned int > m_nDrawers
Definition: TileTBAANtuple.h:175
TileBeamElemContainer
Definition: TileBeamElemContainer.h:13
TileTBAANtuple::DIGI_addBranch
void DIGI_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables...
Definition: TileTBAANtuple.cxx:3232
TileTBAANtuple::m_qdc
std::array< uint32_t, 33 > m_qdc
Definition: TileTBAANtuple.h:375
TileTBAANtuple::m_las_D4_Ped
double m_las_D4_Ped
Definition: TileTBAANtuple.h:392
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
CaloCell_ID_FCS::TileGap1
@ TileGap1
Definition: FastCaloSim_CaloCell_ID.h:34
TileTBAANtuple::m_xImp_90
float m_xImp_90
Definition: TileTBAANtuple.h:499
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
TileHitContainer
Definition: TileHitContainer.h:13
TileTBAANtuple::m_beamBC1X1
Gaudi::Property< float > m_beamBC1X1
Definition: TileTBAANtuple.h:204
TileTBAANtuple::ADDER_addBranch
void ADDER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree ADDER variable...
Definition: TileTBAANtuple.cxx:2868
TileTBAANtuple::m_hitVectorKey
SG::ReadHandleKey< TileHitVector > m_hitVectorKey
Definition: TileTBAANtuple.h:150
min
#define min(a, b)
Definition: cfImp.cxx:40
TileTBAANtuple::storeRawChannels
StatusCode storeRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, bool calibMode, std::vector< std::array< float, MAX_CHAN >> *eneVec, std::vector< std::array< float, MAX_CHAN >> *timeVec, std::vector< std::array< float, MAX_CHAN >> *chi2Vec, std::vector< std::array< float, MAX_CHAN >> *pedVec, bool saveDQstatus=false)
/ Fill ntuple with data from TRC.
Definition: TileTBAANtuple.cxx:1289
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TileTBAANtuple::m_thitCnt
std::vector< std::array< float, MAX_CHAN > > m_thitCnt
Definition: TileTBAANtuple.h:618
TileTBAANtuple::m_fitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
Definition: TileTBAANtuple.h:126
TileTBAANtuple::m_las_PMT2_TDC
int m_las_PMT2_TDC
Definition: TileTBAANtuple.h:423
TileTBAANtuple::m_las_BCID
int m_las_BCID
Definition: TileTBAANtuple.h:378
LASE_PTN_FRAG
#define LASE_PTN_FRAG
Definition: TileTBFrag.h:27
TileTBAANtuple::QDC_clearBranch
void QDC_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree QDC variables
Definition: TileTBAANtuple.cxx:2723
TileDigitsCollection
Definition: TileDigitsCollection.h:18
TileLaserObject::getDiodeSigmaPedestal
double getDiodeSigmaPedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:123
TileTBAANtuple::COINCBOARD_addBranch
void COINCBOARD_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree COINCBOARD var...
Definition: TileTBAANtuple.cxx:3171
TileTBAANtuple::m_las_D3_AlphaPed
double m_las_D3_AlphaPed
Definition: TileTBAANtuple.h:411
TileTBAANtuple::m_tfitVec
std::vector< std::array< float, MAX_CHAN > > m_tfitVec
Definition: TileTBAANtuple.h:536
TileTBAANtuple::m_fitcRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
Definition: TileTBAANtuple.h:135
TileTBAANtuple::m_s2cou
uint32_t m_s2cou
Definition: TileTBAANtuple.h:454
Trk::index2
@ index2
Definition: BoundarySurfaceFace.h:49
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TileTBAANtuple::m_rodCRCVec
std::vector< std::array< int, MAX_DMU > > m_rodCRCVec
Definition: TileTBAANtuple.h:529
TileTBAANtuple::m_ROD_GlobalCRCVec
std::vector< short > m_ROD_GlobalCRCVec
Definition: TileTBAANtuple.h:560
TileDQstatus::checkSampleParityErr
int checkSampleParityErr(int partition, int drawer, int dmu, int gain) const
returns 1 if DMU has data word parity error
Definition: TileDQstatus.h:125
TileTBAANtuple::m_cispar
int m_cispar[16]
Definition: TileTBAANtuple.h:450
TileTBAANtuple::m_xImp
float m_xImp
Definition: TileTBAANtuple.h:494
TileTBAANtuple::ECAL_addBranch
void ECAL_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add ECAL variables to t...
Definition: TileTBAANtuple.cxx:2646
TileTBAANtuple::m_las_D2_AlphaPed
double m_las_D2_AlphaPed
Definition: TileTBAANtuple.h:410
TileCablingService::getTestBeam
bool getTestBeam() const
Definition: TileCablingService.h:274
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
TileDigits
Definition: TileDigits.h:30
TileTBAANtuple::m_ROD_DMUHeadformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUHeadformatErrVec
Definition: TileTBAANtuple.h:565
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
TileLaserObject::getBCID
int getBCID() const
Definition: TileLaserObject.h:335
TileTBAANtuple::m_las2
float m_las2
Definition: TileTBAANtuple.h:436
MAX_DRAWERS
#define MAX_DRAWERS
Definition: TileTBAANtuple.cxx:73
TileLaserObject::getDiodeADC
int getDiodeADC(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:95
TileTBAANtuple::m_adder
int ** m_adder
Definition: TileTBAANtuple.h:444
TileTBAANtuple::m_coincFlag2
int m_coincFlag2
Definition: TileTBAANtuple.h:595
TileTBAANtuple::m_beamFragList
Gaudi::Property< std::vector< std::string > > m_beamFragList
Definition: TileTBAANtuple.h:186
TileRawChannelCollection
Definition: TileRawChannelCollection.h:12
TileDQstatus::checkHeaderParityErr
int checkHeaderParityErr(int partition, int drawer, int dmu, int gain) const
returns 1 if DMU has header word parity error
Definition: TileDQstatus.h:117
TileTBAANtuple::m_xCha2
float m_xCha2
Definition: TileTBAANtuple.h:488
TileTBAANtuple::m_coincTrig1
std::array< unsigned int, 96 > m_coincTrig1
Definition: TileTBAANtuple.h:585
TileTBAANtuple::m_las_D2_ADC
int m_las_D2_ADC
Definition: TileTBAANtuple.h:385
TileTBAANtuple::TRIGGER_addBranch
void TRIGGER_addBranch(void)
///////////////////////////////////////////////////////////////////////////
Definition: TileTBAANtuple.cxx:2579
TileTBAANtuple::clear_init_minus1
void clear_init_minus1(std::vector< T > &vec)
Definition: TileTBAANtuple.cxx:3853
TileTBAANtuple::m_btdc1
std::array< int, 16 > m_btdc1
Definition: TileTBAANtuple.h:470
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TileTBAANtuple::LASER_addBranch
void LASER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variable...
Definition: TileTBAANtuple.cxx:2735
TileTBAANtuple::m_las_D2_Alpha
double m_las_D2_Alpha
Definition: TileTBAANtuple.h:400
TileTBAANtuple::m_lasExtra
std::array< float, 4 > m_lasExtra
Definition: TileTBAANtuple.h:438
TileTBAANtuple::m_mdL1idflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdL1idflxVec
Definition: TileTBAANtuple.h:569
TileTBAANtuple::m_coincFlag1
int m_coincFlag1
Definition: TileTBAANtuple.h:594
TileHit
Definition: TileSimEvent/TileSimEvent/TileHit.h:30
TileTBAANtuple::m_beamBC1Z_min90
Gaudi::Property< float > m_beamBC1Z_min90
Definition: TileTBAANtuple.h:211
TileTBAANtuple::MUON_addBranch
void MUON_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add MUON variables to t...
Definition: TileTBAANtuple.cxx:2618
TileLaserObject::getPMPedestal
double getPMPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:223
TileTBAANtuple::BEAM_clearBranch
void BEAM_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree BEAM variable...
Definition: TileTBAANtuple.cxx:3051
TileTBAANtuple::m_yCha1
float m_yCha1
Definition: TileTBAANtuple.h:487
TileTBAANtuple::m_las_D1_Ped_RMS
double m_las_D1_Ped_RMS
Definition: TileTBAANtuple.h:394
TileTBAANtuple::m_etaFileName
Gaudi::Property< std::string > m_etaFileName
Definition: TileTBAANtuple.h:223
TileTBAANtuple::m_run
int m_run
Definition: TileTBAANtuple.h:353
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
TileTBAANtuple::m_eDspVec
std::vector< std::array< float, MAX_CHAN > > m_eDspVec
Definition: TileTBAANtuple.h:547
TileTBAANtuple::m_tOptVec
std::vector< std::array< float, MAX_CHAN > > m_tOptVec
Definition: TileTBAANtuple.h:544
TileLaserObject::getDiodeCurrMeas
double getDiodeCurrMeas() const
Definition: TileLaserObject.h:224
TileTBAANtuple::m_radius
Gaudi::Property< float > m_radius
Definition: TileTBAANtuple.h:222
TileTBAANtuple::m_beamBC1Y1
Gaudi::Property< float > m_beamBC1Y1
Definition: TileTBAANtuple.h:206
TileTBAANtuple::m_GapEne
std::array< float, 3 > m_GapEne
Definition: TileTBAANtuple.h:583
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TileTBAANtuple::m_las_D3_Alpha
double m_las_D3_Alpha
Definition: TileTBAANtuple.h:401
ReadOfcFromCool.nsamples
nsamples
Definition: ReadOfcFromCool.py:115
TileTBAANtuple::m_pedfitcVec
std::vector< std::array< float, MAX_CHAN > > m_pedfitcVec
Definition: TileTBAANtuple.h:541
MUON_ADC_FRAG
#define MUON_ADC_FRAG
Definition: TileTBFrag.h:25
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
TileTBAANtuple::m_nSamplesFlxInDrawer
std::vector< int > m_nSamplesFlxInDrawer
Definition: TileTBAANtuple.h:633
python.PyAthena.v
v
Definition: PyAthena.py:157
TileTBAANtuple::m_las_D1_AlphaPed_RMS
double m_las_D1_AlphaPed_RMS
Definition: TileTBAANtuple.h:414
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
TileTBAANtuple::m_las_PMT1_TDC
int m_las_PMT1_TDC
Definition: TileTBAANtuple.h:422
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
TileTBAANtuple::m_tflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_tflxoptVec
Definition: TileTBAANtuple.h:556
TileTBAANtuple::m_timeAdd
std::array< float, 16 > m_timeAdd
Definition: TileTBAANtuple.h:447
COIN_TRIG3_FRAG
#define COIN_TRIG3_FRAG
Definition: TileTBFrag.h:34
TileTBAANtuple::m_beamBC2X2
Gaudi::Property< float > m_beamBC2X2
Definition: TileTBAANtuple.h:214
DeMoScan.index
string index
Definition: DeMoScan.py:362
TileTBAANtuple::m_las_D3_ADC
int m_las_D3_ADC
Definition: TileTBAANtuple.h:386
TileTBAANtuple::m_bcidVec
std::vector< std::array< int, MAX_DMU > > m_bcidVec
Definition: TileTBAANtuple.h:515
TileTBAANtuple::m_sc1
int m_sc1
Definition: TileTBAANtuple.h:466
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TileTBAANtuple::m_las_D4_Alpha_RMS
double m_las_D4_Alpha_RMS
Definition: TileTBAANtuple.h:407
a
TList * a
Definition: liststreamerinfos.cxx:10
TileTBAANtuple::m_DMUHeadparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUHeadparityErrVec
Definition: TileTBAANtuple.h:522
TileTBAANtuple::m_dspUnit
TileRawChannelUnit::UNIT m_dspUnit
Unit for TileRawChannels in DSP.
Definition: TileTBAANtuple.h:623
TileTBAANtuple::TRIGGER_clearBranch
void TRIGGER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER varia...
Definition: TileTBAANtuple.cxx:2678
h
TileTBAANtuple::m_rchUnit
TileRawChannelUnit::UNIT m_rchUnit
Unit for TileRawChannels (ADC, pCb, MeV)
Definition: TileTBAANtuple.h:622
TileTBAANtuple::m_muCalib
std::array< float, 2 > m_muCalib
Definition: TileTBAANtuple.h:369
TileTBAANtuple::storeLaser
StatusCode storeLaser(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:562
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
TileTBAANtuple::m_las_D2_Ped
double m_las_D2_Ped
Definition: TileTBAANtuple.h:390
COIN_TRIG2_FRAG
#define COIN_TRIG2_FRAG
Definition: TileTBFrag.h:33
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
TileRawDataContainer::get_unit
UNIT get_unit() const
Definition: TileRawDataContainer.h:60
TileTBAANtuple::m_ROD_DMUSstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUSstrobeErrVec
Definition: TileTBAANtuple.h:563
lumiFormat.fill
fill
Definition: lumiFormat.py:111
TileTBAANtuple::getEta
void getEta(void)
Definition: TileTBAANtuple.cxx:2503
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileTBAANtuple::m_las_PMT2_ADC
int m_las_PMT2_ADC
Definition: TileTBAANtuple.h:420
TileTBAANtuple::m_cher2
uint32_t m_cher2
Definition: TileTBAANtuple.h:457
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
TileTBAANtuple::m_unpackAdder
Gaudi::Property< bool > m_unpackAdder
Definition: TileTBAANtuple.h:169
TileTBAANtuple::m_mdRunflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdRunflxVec
Definition: TileTBAANtuple.h:575
TileTBAANtuple::m_optRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
Definition: TileTBAANtuple.h:129
TileLaserObject::getPMSigmaPedestal
double getPMSigmaPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:237
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
TileTBAANtuple::m_beamBC0Y2
Gaudi::Property< float > m_beamBC0Y2
Definition: TileTBAANtuple.h:201
DEBUG
#define DEBUG
Definition: page_access.h:11
F
#define F(x, y, z)
Definition: MD5.cxx:112
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileLaserObject::getDiodePedestal
double getDiodePedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:109
TileTBAANtuple::m_yCha0
float m_yCha0
Definition: TileTBAANtuple.h:484
TileTBAANtuple::m_beamBC2Z_90
Gaudi::Property< float > m_beamBC2Z_90
Definition: TileTBAANtuple.h:219
TileTBAANtuple::m_pmtOrder
Gaudi::Property< bool > m_pmtOrder
Definition: TileTBAANtuple.h:172
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:569
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
TileTBAANtuple::m_nSamples
Gaudi::Property< int > m_nSamples
Definition: TileTBAANtuple.h:173
TileTBAANtuple::m_chi2flxoptVec
std::vector< std::array< float, MAX_CHAN > > m_chi2flxoptVec
Definition: TileTBAANtuple.h:557
TileTBAANtuple::m_coincFlag5
int m_coincFlag5
Definition: TileTBAANtuple.h:598
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
TileTBAANtuple::m_beamBC2Y1
Gaudi::Property< float > m_beamBC2Y1
Definition: TileTBAANtuple.h:215
TileTBAANtuple::m_ROD_DMUmemoryErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUmemoryErrVec
Definition: TileTBAANtuple.h:562
TileTBAANtuple::m_chi2DspVec
std::vector< std::array< float, MAX_CHAN > > m_chi2DspVec
Definition: TileTBAANtuple.h:549
TileTBAANtuple::m_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDstrobeErrVec
Definition: TileTBAANtuple.h:520
TileTBAANtuple::m_thitVec
std::vector< std::array< float, MAX_CHAN > > m_thitVec
Definition: TileTBAANtuple.h:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
TileTBAANtuple::m_evt
int m_evt
Definition: TileTBAANtuple.h:354
TileTBAANtuple::m_xChN1
float m_xChN1
Definition: TileTBAANtuple.h:481
TileTBAANtuple::m_las_D3_Ped_RMS
double m_las_D3_Ped_RMS
Definition: TileTBAANtuple.h:396
TileTBAANtuple::m_sc2
int m_sc2
Definition: TileTBAANtuple.h:467
TileTBAANtuple::m_DMUDataparityErrVec
std::vector< std::array< short, MAX_DMU > > m_DMUDataparityErrVec
Definition: TileTBAANtuple.h:523
TileTBAANtuple::m_las_D3_Ped
double m_las_D3_Ped
Definition: TileTBAANtuple.h:391
TileTBAANtuple::m_trigType
int m_trigType
Definition: TileTBAANtuple.h:355
TileTBAANtuple::m_scaler
std::array< int, 16 > m_scaler
Definition: TileTBAANtuple.h:472
SIGNAL_FOUND
#define SIGNAL_FOUND(frag, chan, amplitude)
Definition: TileTBAANtuple.cxx:66
COMMON_ADC2_FRAG
#define COMMON_ADC2_FRAG
Definition: TileTBFrag.h:44
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
TileTBAANtuple::ADDER_clearBranch
void ADDER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree ADDER variabl...
Definition: TileTBAANtuple.cxx:2891
TileTBAANtuple::m_las_D2_Ped_RMS
double m_las_D2_Ped_RMS
Definition: TileTBAANtuple.h:395
TileTBAANtuple::m_las_PMT2_Ped_RMS
double m_las_PMT2_Ped_RMS
Definition: TileTBAANtuple.h:429
TileTBAANtuple::m_beamBC1Z_90
Gaudi::Property< float > m_beamBC1Z_90
Definition: TileTBAANtuple.h:210
LArDigits2NtupleDumper.nSamples
nSamples
Definition: LArDigits2NtupleDumper.py:70
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
TileTBAANtuple::storeHit
void storeHit(const TileHit *hit, int fragType, int fragId, std::array< float, MAX_CHAN > &ehitVec, std::array< float, MAX_CHAN > &thitVec, const TileSamplingFraction *samplingFraction)
Definition: TileTBAANtuple.cxx:2007
TileTBAANtuple::m_ROD_DMUDataformatErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDataformatErrVec
Definition: TileTBAANtuple.h:566
TileTBAANtuple::m_ROD_DMUDstrobeErrVec
std::vector< std::array< short, MAX_DMU > > m_ROD_DMUDstrobeErrVec
Definition: TileTBAANtuple.h:564
TileTBAANtuple::m_adderFilterAlgTool
ToolHandle< TileRawChannelBuilderFlatFilter > m_adderFilterAlgTool
Definition: TileTBAANtuple.h:159
TileTBAANtuple::m_las_D1_Alpha
double m_las_D1_Alpha
Definition: TileTBAANtuple.h:399
calibdata.copy
bool copy
Definition: calibdata.py:27
TileTBAANtuple::CISPAR_clearBranch
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
Definition: TileTBAANtuple.cxx:2917
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TileTBAANtuple::m_flxFitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_flxFitRawChannelContainerKey
Definition: TileTBAANtuple.h:138
TileTBAANtuple::m_las_PMT1_Ped_RMS
double m_las_PMT1_Ped_RMS
Definition: TileTBAANtuple.h:428
TileTBAANtuple::m_las_D4_Alpha
double m_las_D4_Alpha
Definition: TileTBAANtuple.h:402
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
TileHWID::to_string
std::string to_string(const HWIdentifier &id, int level=0) const
extract all fields from HW identifier HWIdentifier get_all_fields ( const HWIdentifier & id,...
Definition: TileHWID.cxx:49
TileTBAANtuple::m_xCha1_0
float m_xCha1_0
Definition: TileTBAANtuple.h:490
TileTBAANtuple::m_timeVec
std::vector< std::array< float, MAX_CHAN > > m_timeVec
Definition: TileTBAANtuple.h:532
TileLaserObject::getSigmaAlpha
double getSigmaAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:152
TileTBAANtuple::m_eflxoptVec
std::vector< std::array< float, MAX_CHAN > > m_eflxoptVec
Definition: TileTBAANtuple.h:555
TileTBAANtuple::m_LarEne
std::array< float, 4 > m_LarEne
Definition: TileTBAANtuple.h:580
TileTBAANtuple::m_gainVec
std::vector< std::array< int, MAX_CHAN > > m_gainVec
Definition: TileTBAANtuple.h:526
TileTBAANtuple::m_nSamplesFlxInDrawerMap
std::map< int, int > m_nSamplesFlxInDrawerMap
Definition: TileTBAANtuple.h:631
TileTBAANtuple::m_eneAdd
std::array< float, 16 > m_eneAdd
Definition: TileTBAANtuple.h:446
TileTBAANtuple::m_las_D4_AlphaPed_RMS
double m_las_D4_AlphaPed_RMS
Definition: TileTBAANtuple.h:417
TileTBAANtuple::m_chi2flxfitVec
std::vector< std::array< float, MAX_CHAN > > m_chi2flxfitVec
Definition: TileTBAANtuple.h:553
TileTBAANtuple::m_las_D2_Alpha_RMS
double m_las_D2_Alpha_RMS
Definition: TileTBAANtuple.h:405
ECAL_ADC_FRAG
#define ECAL_ADC_FRAG
Definition: TileTBFrag.h:30
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
TileTBAANtuple::m_las_D2_AlphaPed_RMS
double m_las_D2_AlphaPed_RMS
Definition: TileTBAANtuple.h:415
TileCalibUtils::getDrawerIdxFromFragId
static unsigned int getDrawerIdxFromFragId(unsigned int fragId)
Returns a drawer hash from fragId This function assumes drawer context (i.e.
Definition: TileCalibUtils.cxx:71
TileTBAANtuple::m_las_D1_Alpha_RMS
double m_las_D1_Alpha_RMS
Definition: TileTBAANtuple.h:404
TileTBAANtuple::m_las_D4_Ped_RMS
double m_las_D4_Ped_RMS
Definition: TileTBAANtuple.h:397
TileTBAANtuple::initList
StatusCode initList(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:2295
TileTBAANtuple::m_rosName
Gaudi::Property< std::vector< std::string > > m_rosName
Definition: TileTBAANtuple.h:183
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
COIN_TRIG5_FRAG
#define COIN_TRIG5_FRAG
Definition: TileTBFrag.h:36
TileTBAANtuple::m_l1Type
std::vector< int > m_l1Type
Definition: TileTBAANtuple.h:360
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileTBAANtuple::m_ntupleCreated
bool m_ntupleCreated
Definition: TileTBAANtuple.h:346
TileTBAANtuple::storeBeamElements
StatusCode storeBeamElements(const EventContext &ctx)
Definition: TileTBAANtuple.cxx:632
TileTBAANtuple::DIGI_clearBranch
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
Definition: TileTBAANtuple.cxx:3514
TileTBAANtuple::m_TBperiod
Gaudi::Property< int > m_TBperiod
Definition: TileTBAANtuple.h:177
TileLaserObject
Definition: TileLaserObject.h:33
TileTBAANtuple::m_ehitCnt
std::vector< std::array< float, MAX_CHAN > > m_ehitCnt
Definition: TileTBAANtuple.h:617
TileTBAANtuple::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition: TileTBAANtuple.h:162
COIN_TRIG4_FRAG
#define COIN_TRIG4_FRAG
Definition: TileTBFrag.h:35
TileTBAANtuple::m_eOptVec
std::vector< std::array< float, MAX_CHAN > > m_eOptVec
Definition: TileTBAANtuple.h:543
TileTBAANtuple::m_coincTrig8
std::array< unsigned int, 96 > m_coincTrig8
Definition: TileTBAANtuple.h:592
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
TileTBAANtuple::m_las1
float m_las1
Definition: TileTBAANtuple.h:435
TileTBAANtuple::m_dspFlags
int m_dspFlags
Definition: TileTBAANtuple.h:356
TileTBAANtuple::m_pedfitVec
std::vector< std::array< float, MAX_CHAN > > m_pedfitVec
Definition: TileTBAANtuple.h:537
TileTBAANtuple::m_muVeto
uint32_t m_muVeto
Definition: TileTBAANtuple.h:461
TileTBAANtuple::m_yCha2
float m_yCha2
Definition: TileTBAANtuple.h:489
fitman.k
k
Definition: fitman.py:528
TileRawChannelUnit::OnlineMegaElectronVolts
@ OnlineMegaElectronVolts
Definition: TileRawChannelUnit.h:24
TileTBAANtuple::m_las_D3_Alpha_RMS
double m_las_D3_Alpha_RMS
Definition: TileTBAANtuple.h:406
TileTBAANtuple::m_efitcVec
std::vector< std::array< float, MAX_CHAN > > m_efitcVec
Definition: TileTBAANtuple.h:539
TileLaserObject::getPedestalAlpha
double getPedestalAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:166
TileTBAANtuple::m_xImp_min90
float m_xImp_min90
Definition: TileTBAANtuple.h:501
TileTBAANtuple::m_mdChargeflxVec
std::vector< std::array< int, MAX_MINIDRAWER > > m_mdChargeflxVec
Definition: TileTBAANtuple.h:576
ServiceHandle< ICondSvc >
TileTBAANtuple::CheckDMUFormat
short CheckDMUFormat(uint32_t header)
bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0
Definition: TileTBAANtuple.h:302
TileTBAANtuple::m_beamBC0X1
Gaudi::Property< float > m_beamBC0X1
Definition: TileTBAANtuple.h:198
Generated on Fri Jul 5 2024 22:03:13 for ATLAS Offline Software by   doxygen 1.8.18